import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
/** Converts a {@link SqlCall} to a {@link RexCall} with a perhaps different
 * operator. */
private RexNode convertCall(
    SqlRexContext cx,
    SqlCall call,
    SqlOperator op) {
  final List<SqlNode> operands = call.getOperandList();
  final RexBuilder rexBuilder = cx.getRexBuilder();
  final SqlOperandTypeChecker.Consistency consistency =
      op.getOperandTypeChecker() == null
          ? SqlOperandTypeChecker.Consistency.NONE
          : op.getOperandTypeChecker().getConsistency();
  final List<RexNode> exprs =
      convertExpressionList(cx, operands, consistency);
  RelDataType type = rexBuilder.deriveReturnType(op, exprs);
  return rexBuilder.makeCall(type, op, RexUtil.flatten(exprs, op));
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
private static List<RexNode> convertExpressionList(SqlRexContext cx,
    List<SqlNode> nodes, SqlOperandTypeChecker.Consistency consistency) {
  final List<RexNode> exprs = Lists.newArrayList();
  for (SqlNode node : nodes) {
    exprs.add(cx.convertExpression(node));
  }
  if (exprs.size() > 1) {
    final RelDataType type =
        consistentType(cx, consistency, RexUtil.types(exprs));
    if (type != null) {
      final List<RexNode> oldExprs = Lists.newArrayList(exprs);
      exprs.clear();
      for (RexNode expr : oldExprs) {
        exprs.add(cx.getRexBuilder().ensureType(type, expr, true));
      }
    }
  }
  return exprs;
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
public RexNode convertFunction(
    SqlRexContext cx,
    SqlFunction fun,
    SqlCall call) {
  final List<SqlNode> operands = call.getOperandList();
  final List<RexNode> exprs = convertExpressionList(cx, operands,
      SqlOperandTypeChecker.Consistency.NONE);
  if (fun.getFunctionType() == SqlFunctionCategory.USER_DEFINED_CONSTRUCTOR) {
    return makeConstructorCall(cx, fun, exprs);
  }
  RelDataType returnType =
      cx.getValidator().getValidatedNodeTypeIfKnown(call);
  if (returnType == null) {
    returnType = cx.getRexBuilder().deriveReturnType(fun, exprs);
  }
  return cx.getRexBuilder().makeCall(returnType, fun, exprs);
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
public RexNode convertAggregateFunction(
    SqlRexContext cx,
    SqlAggFunction fun,
    SqlCall call) {
  final List<SqlNode> operands = call.getOperandList();
  final List<RexNode> exprs;
  if (call.isCountStar()) {
    exprs = ImmutableList.of();
  } else {
    exprs = convertExpressionList(cx, operands,
        SqlOperandTypeChecker.Consistency.NONE);
  }
  RelDataType returnType =
      cx.getValidator().getValidatedNodeTypeIfKnown(call);
  final int groupCount = cx.getGroupCount();
  if (returnType == null) {
    RexCallBinding binding =
        new RexCallBinding(cx.getTypeFactory(), fun, exprs, ImmutableList.<RelCollation>of()) {
          @Override public int getGroupCount() {
            return groupCount;
          }
        };
    returnType = fun.inferReturnType(binding);
  }
  return cx.getRexBuilder().makeCall(returnType, fun, exprs);
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
public SqlSpecialOperator(
    String name,
    SqlKind kind,
    int prec,
    boolean leftAssoc,
    SqlReturnTypeInference returnTypeInference,
    SqlOperandTypeInference operandTypeInference,
    SqlOperandTypeChecker operandTypeChecker) {
  super(
      name,
      kind,
      prec,
      leftAssoc,
      returnTypeInference,
      operandTypeInference,
      operandTypeChecker);
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
public SqlSetOperator(
    String name,
    SqlKind kind,
    int prec,
    boolean all,
    SqlReturnTypeInference returnTypeInference,
    SqlOperandTypeInference operandTypeInference,
    SqlOperandTypeChecker operandTypeChecker) {
  super(
      name,
      kind,
      prec,
      true,
      returnTypeInference,
      operandTypeInference,
      operandTypeChecker);
  this.all = all;
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
public SqlInternalOperator(
    String name,
    SqlKind kind,
    int prec,
    boolean isLeftAssoc,
    SqlReturnTypeInference returnTypeInference,
    SqlOperandTypeInference operandTypeInference,
    SqlOperandTypeChecker operandTypeChecker) {
  super(
      name,
      kind,
      prec,
      isLeftAssoc,
      returnTypeInference,
      operandTypeInference,
      operandTypeChecker);
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
public SqlPostfixOperator(
    String name,
    SqlKind kind,
    int prec,
    SqlReturnTypeInference returnTypeInference,
    SqlOperandTypeInference operandTypeInference,
    SqlOperandTypeChecker operandTypeChecker) {
  super(
      name,
      kind,
      leftPrec(prec, true),
      rightPrec(prec, true),
      returnTypeInference,
      operandTypeInference,
      operandTypeChecker);
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
/**
 * Creates a SqlBinaryOperator.
 *
 * @param name                 Name of operator
 * @param kind                 Kind
 * @param prec                 Precedence
 * @param leftAssoc            Left-associativity
 * @param returnTypeInference  Strategy to infer return type
 * @param operandTypeInference Strategy to infer operand types
 * @param operandTypeChecker   Validator for operand types
 */
public SqlBinaryOperator(
    String name,
    SqlKind kind,
    int prec,
    boolean leftAssoc,
    SqlReturnTypeInference returnTypeInference,
    SqlOperandTypeInference operandTypeInference,
    SqlOperandTypeChecker operandTypeChecker) {
  super(
      name,
      kind,
      leftPrec(prec, leftAssoc),
      rightPrec(prec, leftAssoc),
      returnTypeInference,
      operandTypeInference,
      operandTypeChecker);
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
protected SqlInfixOperator(
    String[] names,
    SqlKind kind,
    int precedence,
    SqlReturnTypeInference returnTypeInference,
    SqlOperandTypeInference operandTypeInference,
    SqlOperandTypeChecker operandTypeChecker) {
  super(
      names[0],
      kind,
      precedence,
      true,
      returnTypeInference,
      operandTypeInference,
      operandTypeChecker);
  assert names.length > 1;
  this.names = names;
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
public SqlMonotonicBinaryOperator(
    String name,
    SqlKind kind,
    int prec,
    boolean isLeftAssoc,
    SqlReturnTypeInference returnTypeInference,
    SqlOperandTypeInference operandTypeInference,
    SqlOperandTypeChecker operandTypeChecker) {
  super(
      name,
      kind,
      prec,
      isLeftAssoc,
      returnTypeInference,
      operandTypeInference,
      operandTypeChecker);
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
public SqlPrefixOperator(
    String name,
    SqlKind kind,
    int prec,
    SqlReturnTypeInference returnTypeInference,
    SqlOperandTypeInference operandTypeInference,
    SqlOperandTypeChecker operandTypeChecker) {
  super(
      name,
      kind,
      leftPrec(prec, true),
      rightPrec(prec, true),
      returnTypeInference,
      operandTypeInference,
      operandTypeChecker);
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
/** Creates a built-in or user-defined SqlAggFunction or window function.
 *
 * <p>A user-defined function will have a value for {@code sqlIdentifier}; for
 * a built-in function it will be null. */
protected SqlAggFunction(
    String name,
    SqlIdentifier sqlIdentifier,
    SqlKind kind,
    SqlReturnTypeInference returnTypeInference,
    SqlOperandTypeInference operandTypeInference,
    SqlOperandTypeChecker operandTypeChecker,
    SqlFunctionCategory funcType,
    boolean requiresOrder,
    boolean requiresOver) {
  super(name, sqlIdentifier, kind, returnTypeInference, operandTypeInference,
      operandTypeChecker, null, funcType);
  this.requiresOrder = requiresOrder;
  this.requiresOver = requiresOver;
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
/**
 * Creates a new SqlFunction for a call to a builtin function.
 *
 * @param name                 Name of builtin function
 * @param kind                 kind of operator implemented by function
 * @param returnTypeInference  strategy to use for return type inference
 * @param operandTypeInference strategy to use for parameter type inference
 * @param operandTypeChecker   strategy to use for parameter type checking
 * @param category             categorization for function
 */
public SqlFunction(
    String name,
    SqlKind kind,
    SqlReturnTypeInference returnTypeInference,
    SqlOperandTypeInference operandTypeInference,
    SqlOperandTypeChecker operandTypeChecker,
    SqlFunctionCategory category) {
  // We leave sqlIdentifier as null to indicate
  // that this is a builtin.  Same for paramTypes.
  this(name, null, kind, returnTypeInference, operandTypeInference,
      operandTypeChecker, null, category);

  assert !((category == SqlFunctionCategory.USER_DEFINED_CONSTRUCTOR)
      && (returnTypeInference == null));
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
/**
 * Creates an operator.
 */
protected SqlOperator(
    String name,
    SqlKind kind,
    int leftPrecedence,
    int rightPrecedence,
    SqlReturnTypeInference returnTypeInference,
    SqlOperandTypeInference operandTypeInference,
    SqlOperandTypeChecker operandTypeChecker) {
  assert kind != null;
  this.name = name;
  this.kind = kind;
  this.leftPrec = leftPrecedence;
  this.rightPrec = rightPrecedence;
  this.returnTypeInference = returnTypeInference;
  this.operandTypeInference = operandTypeInference;
  this.operandTypeChecker = operandTypeChecker;
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
public SqlFunctionalOperator(
    String name,
    SqlKind kind,
    int pred,
    boolean isLeftAssoc,
    SqlReturnTypeInference returnTypeInference,
    SqlOperandTypeInference operandTypeInference,
    SqlOperandTypeChecker operandTypeChecker) {
  super(
      name,
      kind,
      pred,
      isLeftAssoc,
      returnTypeInference,
      operandTypeInference,
      operandTypeChecker);
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
public SqlUserDefinedAggFunction(SqlIdentifier opName,
                                 SqlReturnTypeInference returnTypeInference,
                                 SqlOperandTypeInference operandTypeInference,
                                 SqlOperandTypeChecker operandTypeChecker,
                                 AggregateFunction function,
                                 Boolean requestsOver) {
    super(Util.last(opName.names), opName, SqlKind.OTHER_FUNCTION,
          returnTypeInference, operandTypeInference, operandTypeChecker,
          SqlFunctionCategory.USER_DEFINED_FUNCTION, false, requestsOver);
    this.function = function;
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
/** Creates a SqlGroupFunction.
 *
 * @param name Function name
 * @param kind Kind
 * @param groupFunction Group function, if this is an auxiliary;
 *                      null, if this is a group function
 * @param operandTypeChecker Operand type checker
 */
public SqlGroupFunction(String name, SqlKind kind, SqlGroupFunction groupFunction,
    SqlOperandTypeChecker operandTypeChecker) {
  super(name, kind, ReturnTypes.ARG0, null,
      operandTypeChecker, SqlFunctionCategory.SYSTEM);
  this.groupFunction = groupFunction;
  if (groupFunction != null) {
    assert groupFunction.groupFunction == null;
  }
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
public RexNode convertDatetimeMinus(
    SqlRexContext cx,
    SqlDatetimeSubtractionOperator op,
    SqlCall call) {
  // Rewrite datetime minus
  final RexBuilder rexBuilder = cx.getRexBuilder();
  final List<SqlNode> operands = call.getOperandList();
  final List<RexNode> exprs = convertExpressionList(cx, operands,
      SqlOperandTypeChecker.Consistency.NONE);

  RelDataType int8Type =
      cx.getTypeFactory().createSqlType(SqlTypeName.BIGINT);
  final RexNode[] casts = new RexNode[2];
  casts[0] =
      rexBuilder.makeCast(
          cx.getTypeFactory().createTypeWithNullability(
              int8Type,
              exprs.get(0).getType().isNullable()),
          exprs.get(0));
  casts[1] =
      rexBuilder.makeCast(
          cx.getTypeFactory().createTypeWithNullability(
              int8Type,
              exprs.get(1).getType().isNullable()),
          exprs.get(1));
  final RelDataType resType =
      cx.getValidator().getValidatedNodeType(call);
  return rexBuilder.makeCall(resType, op, exprs.subList(0, 2));
}
 

import org.apache.calcite.sql.type.SqlOperandTypeChecker; //导入依赖的package包/类
/** Creates a SqlGroupedWindowFunction.
 *
 * @param name Function name
 * @param kind Kind
 * @param groupFunction Group function, if this is an auxiliary;
 *                      null, if this is a group function
 * @param returnTypeInference  Strategy to use for return type inference
 * @param operandTypeInference Strategy to use for parameter type inference
 * @param operandTypeChecker   Strategy to use for parameter type checking
 * @param category             Categorization for function
 */
public SqlGroupedWindowFunction(String name, SqlKind kind,
    SqlGroupedWindowFunction groupFunction,
    SqlReturnTypeInference returnTypeInference,
    SqlOperandTypeInference operandTypeInference,
    SqlOperandTypeChecker operandTypeChecker, SqlFunctionCategory category) {
  super(name, kind, returnTypeInference, operandTypeInference,
      operandTypeChecker, category);
  this.groupFunction = groupFunction;
  Preconditions.checkArgument(groupFunction == null
      || groupFunction.groupFunction == null);
}