import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
public SqlDatePartOperator() {
  super(
      "DATE_PART",
      SqlKind.OTHER_FUNCTION,
      ReturnTypes.BIGINT_NULLABLE,
      null,
      OperandTypes.sequence(
          "<PERIOD LITERAL>, <DATE or TIMESTAMP or INTERVAL>",
          new EnumeratedListChecker(VALID_PERIODS.keySet()),
          OperandTypes.or(
              OperandTypes.family(SqlTypeFamily.DATE),
              OperandTypes.family(SqlTypeFamily.TIMESTAMP),
              OperandTypes.family(SqlTypeFamily.DATETIME),
              OperandTypes.family(SqlTypeFamily.DATETIME_INTERVAL),
              OperandTypes.family(SqlTypeFamily.INTERVAL_DAY_TIME),
              OperandTypes.family(SqlTypeFamily.INTERVAL_YEAR_MONTH))
          ),
          SqlFunctionCategory.SYSTEM);
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
@Override
public RexNode apply(RexBuilderContext context) {
	RelOptCluster cluster = context.getCluster();
	RelDataTypeFactory typeFactory = cluster.getTypeFactory();
	final SqlFunction UDF =
			new SqlUserDefinedFunction(
					new SqlIdentifier("RESOLVE_SIMPLE", SqlParserPos.ZERO),
					ReturnTypes.explicit(typeFactory.createJavaType(Object.class)),
					null,
					OperandTypes.ANY_ANY,
					ImmutableList.of(typeFactory.createTypeWithNullability(typeFactory.createJavaType(IObject.class), false),
							typeFactory.createJavaType(int.class)),
					ScalarFunctionImpl.create(IObjectMethods.class, "resolveSimpleValue"));
	RexBuilder b = context.getBuilder();
	RexNode rexNode = b.makeCall(UDF, context.getIObject(), b.makeLiteral(name));
	return b.makeCast(dataType, rexNode);
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
@Override
public RexNode getSnapshot() {
    if (snapshot == null) {
        RelDataTypeFactory typeFactory = getCluster().getTypeFactory();
        RexBuilder b = getBuilder();
        final SqlFunction UDF =
                new SqlUserDefinedFunction(
                        new SqlIdentifier("GET_SNAPSHOT", SqlParserPos.ZERO),
                        ReturnTypes.explicit(typeFactory.createTypeWithNullability(typeFactory.createJavaType(ISnapshot.class), false)),
                        null,
                        OperandTypes.NUMERIC,
                        ImmutableList.of(typeFactory.createJavaType(Integer.class)),
                        ScalarFunctionImpl.create(SnapshotHolder.class, "get"));
        snapshot = b.makeCall(UDF, b.makeLiteral(snapshotId, typeFactory.createSqlType(SqlTypeName.INTEGER), false));
    }
    return snapshot;
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
public RexNode getIObject() {
    if (object == null) {
        RelDataTypeFactory typeFactory = getCluster().getTypeFactory();
        RexBuilder b = getBuilder();
        final SqlFunction GET_IOBJECT =
                new SqlUserDefinedFunction(
                        new SqlIdentifier("GET_IOBJECT", SqlParserPos.ZERO),
                        ReturnTypes.explicit(typeFactory.createTypeWithNullability(typeFactory.createJavaType(IObject.class), false)),
                        null,
                        OperandTypes.ANY_ANY,
                        ImmutableList.of(typeFactory.createTypeWithNullability(typeFactory.createJavaType(ISnapshot.class), false),
                                typeFactory.createJavaType(int.class)),
                        ScalarFunctionImpl.create(ISnapshotMethods.class, "getIObject"));
        object = b.makeCall(GET_IOBJECT, getSnapshot(), getIObjectId());
    }
    return object;
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
/** Creates a SqlMinMaxAggFunction. */
public SqlMinMaxAggFunction(SqlKind kind) {
  super(kind.name(),
      null,
      kind,
      ReturnTypes.ARG0_NULLABLE_IF_EMPTY,
      null,
      OperandTypes.COMPARABLE_ORDERED,
      SqlFunctionCategory.SYSTEM,
      false,
      false);
  this.argTypes = ImmutableList.of();
  this.minMaxKind = MINMAX_COMPARABLE;
  Preconditions.checkArgument(kind == SqlKind.MIN
      || kind == SqlKind.MAX);
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
/**
 * Most dialects that natively support datetime floor will use this.
 * In those cases the call will look like TRUNC(datetime, 'year').
 *
 * @param writer SqlWriter
 * @param call SqlCall
 * @param funName Name of the sql function to call
 * @param datetimeFirst Specify the order of the datetime & timeUnit
 * arguments
 */
public static void unparseDatetimeFunction(SqlWriter writer, SqlCall call,
    String funName, Boolean datetimeFirst) {
  SqlFunction func = new SqlFunction(funName, SqlKind.OTHER_FUNCTION,
      ReturnTypes.ARG0_NULLABLE_VARYING, null, null,
      SqlFunctionCategory.STRING);

  SqlCall call1;
  if (datetimeFirst) {
    call1 = call;
  } else {
    // switch order of operands
    SqlNode op1 = call.operand(0);
    SqlNode op2 = call.operand(1);

    call1 = call.getOperator().createCall(call.getParserPosition(), op2, op1);
  }

  SqlUtil.unparseFunctionSyntax(func, writer, call1);
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
/**
 * Creates a SqlLikeOperator.
 *
 * @param name    Operator name
 * @param kind    Kind
 * @param negated Whether this is 'NOT LIKE'
 */
SqlLikeOperator(
    String name,
    SqlKind kind,
    boolean negated) {
  // LIKE is right-associative, because that makes it easier to capture
  // dangling ESCAPE clauses: "a like b like c escape d" becomes
  // "a like (b like c escape d)".
  super(
      name,
      kind,
      32,
      false,
      ReturnTypes.BOOLEAN_NULLABLE,
      InferTypes.FIRST_KNOWN,
      OperandTypes.STRING_SAME_SAME_SAME);
  this.negated = negated;
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
/**
 * Creates a SqlCovarAggFunction.
 */
public SqlCovarAggFunction(SqlKind kind) {
  super(kind.name(),
      null,
      kind,
      ReturnTypes.COVAR_FUNCTION,
      null,
      OperandTypes.NUMERIC_NUMERIC,
      SqlFunctionCategory.NUMERIC,
      false,
      false);
  Preconditions.checkArgument(kind == SqlKind.COVAR_POP
      || kind == SqlKind.COVAR_SAMP
      || kind == SqlKind.REGR_SXX
      || kind == SqlKind.REGR_SYY);
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
@Test public void testIsDeterministic() {
  SqlOperator ndc = new SqlSpecialOperator(
          "NDC",
          SqlKind.OTHER_FUNCTION,
          0,
          false,
          ReturnTypes.BOOLEAN,
          null, null) {
    @Override public boolean isDeterministic() {
      return false;
    }
  };
  RexNode n = rexBuilder.makeCall(ndc);
  assertFalse(RexUtil.isDeterministic(n));
  assertEquals(0,
          RexUtil.retainDeterministic(RelOptUtil.conjunctions(n)).size());
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
public SqlSumCountAggFunction(RelDataType type) {
  super("$SUM0",
      SqlKind.OTHER_FUNCTION,
      ReturnTypes.BIGINT, // use the inferred return type of SqlCountAggFunction
      null,
      OperandTypes.NUMERIC,
      SqlFunctionCategory.NUMERIC);

  this.type = type;
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
public SqlHllAggFunction() {
  super("HLL",
    null,
    SqlKind.OTHER_FUNCTION,
    ReturnTypes.explicit(SqlTypeName.BINARY),
    null,
    OperandTypes.ANY,
    SqlFunctionCategory.USER_DEFINED_FUNCTION,
    false,
    false
  );
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
public SqlHllMergeAggFunction() {
  super("NDV_MERGE",
    null,
    SqlKind.OTHER_FUNCTION,
    ReturnTypes.BIGINT_FORCE_NULLABLE,
    null,
    OperandTypes.BINARY,
    SqlFunctionCategory.USER_DEFINED_FUNCTION,
    false,
    false
  );
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
SqlAggFunction createCustomAggFunction(String funcName, RelDataType returnType, Class<?> customAggFuncClz) {
    RelDataTypeFactory typeFactory = getCluster().getTypeFactory();
    SqlIdentifier sqlIdentifier = new SqlIdentifier(funcName, new SqlParserPos(1, 1));
    AggregateFunction aggFunction = AggregateFunctionImpl.create(customAggFuncClz);
    List<RelDataType> argTypes = new ArrayList<RelDataType>();
    List<SqlTypeFamily> typeFamilies = new ArrayList<SqlTypeFamily>();
    for (FunctionParameter o : aggFunction.getParameters()) {
        final RelDataType type = o.getType(typeFactory);
        argTypes.add(type);
        typeFamilies.add(Util.first(type.getSqlTypeName().getFamily(), SqlTypeFamily.ANY));
    }
    return new SqlUserDefinedAggFunction(sqlIdentifier, ReturnTypes.explicit(returnType),
            InferTypes.explicit(argTypes), OperandTypes.family(typeFamilies), aggFunction, false, false);
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
@Deprecated // to be removed before 2.0
public SqlGroupedWindowFunction(String name, SqlKind kind,
    SqlGroupedWindowFunction groupFunction,
    SqlOperandTypeChecker operandTypeChecker) {
  this(name, kind, groupFunction, ReturnTypes.ARG0, null, operandTypeChecker,
      SqlFunctionCategory.SYSTEM);
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
public SqlSetOperator(
    String name,
    SqlKind kind,
    int prec,
    boolean all) {
  super(
      name,
      kind,
      prec,
      true,
      ReturnTypes.LEAST_RESTRICTIVE,
      null,
      OperandTypes.SET_OP);
  this.all = all;
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
/**
 * Creates an AS operator.
 */
public SqlAsOperator() {
  this(
      "AS",
      SqlKind.AS,
      20,
      true,
      ReturnTypes.ARG0,
      InferTypes.RETURN_TYPE,
      OperandTypes.ANY_ANY);
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
public RelDataType inferReturnType(
    SqlOperatorBinding opBinding) {
  SqlCallBinding callBinding = (SqlCallBinding) opBinding;
  ExplicitOperatorBinding newOpBinding =
      new ExplicitOperatorBinding(
          opBinding,
          collectOperandTypes(
              callBinding.getValidator(),
              callBinding.getScope(),
              callBinding.getCall()));
  return ReturnTypes.BOOLEAN_NULLABLE.inferReturnType(
      newOpBinding);
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
public SqlMultisetMemberOfOperator() {
  // TODO check if precedence is correct
  super(
      "MEMBER OF",
      SqlKind.OTHER,
      30,
      true,
      ReturnTypes.BOOLEAN_NULLABLE,
      null,
      null);
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
public SqlCurrentDateFunction() {
  super(
      "CURRENT_DATE",
      SqlKind.OTHER_FUNCTION,
      ReturnTypes.DATE,
      null,
      OperandTypes.NILADIC,
      SqlFunctionCategory.TIMEDATE);
}
 

import org.apache.calcite.sql.type.ReturnTypes; //导入依赖的package包/类
public SqlFloorFunction(SqlKind kind) {
  super(kind.name(), kind, ReturnTypes.ARG0_OR_EXACT_NO_SCALE, null,
      OperandTypes.or(OperandTypes.NUMERIC_OR_INTERVAL,
          OperandTypes.sequence(
              "'" + kind + "(<DATE> TO <TIME_UNIT>)'\n"
              + "'" + kind + "(<TIME> TO <TIME_UNIT>)'\n"
              + "'" + kind + "(<TIMESTAMP> TO <TIME_UNIT>)'",
              OperandTypes.DATETIME,
              OperandTypes.ANY)),
      SqlFunctionCategory.NUMERIC);
  Preconditions.checkArgument(kind == SqlKind.FLOOR || kind == SqlKind.CEIL);
}