import org.apache.calcite.sql.type.InferTypes; //导入依赖的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.InferTypes; //导入依赖的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.InferTypes; //导入依赖的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.InferTypes; //导入依赖的package包/类
public SqlDatePartFunction(String name, TimeUnit timeUnit) {
  super(name,
      SqlKind.OTHER,
      ReturnTypes.BIGINT_NULLABLE,
      InferTypes.FIRST_KNOWN,
      OperandTypes.DATETIME,
      SqlFunctionCategory.TIMEDATE);
  this.timeUnit = timeUnit;
}
 

import org.apache.calcite.sql.type.InferTypes; //导入依赖的package包/类
SqlLiteralChainOperator() {
  super(
      "$LiteralChain",
      SqlKind.LITERAL_CHAIN,
      80,
      true,

      // precedence tighter than the * and || operators
      ReturnTypes.ARG0,
      InferTypes.FIRST_KNOWN,
      OperandTypes.VARIADIC);
}
 

import org.apache.calcite.sql.type.InferTypes; //导入依赖的package包/类
protected SqlInOperator(String name, SqlKind kind) {
  super(name, kind,
      32,
      true,
      ReturnTypes.BOOLEAN_NULLABLE,
      InferTypes.FIRST_KNOWN,
      null);
}
 

import org.apache.calcite.sql.type.InferTypes; //导入依赖的package包/类
protected SqlMultisetValueConstructor(String name, SqlKind kind) {
  super(
      name,
      kind, MDX_PRECEDENCE,
      false,
      ReturnTypes.ARG0,
      InferTypes.FIRST_KNOWN,
      OperandTypes.VARIADIC);
}
 

import org.apache.calcite.sql.type.InferTypes; //导入依赖的package包/类
public SqlCastFunction() {
  super(
      "CAST",
      SqlKind.CAST,
      null,
      InferTypes.FIRST_KNOWN,
      null,
      SqlFunctionCategory.SYSTEM);
}
 

import org.apache.calcite.sql.type.InferTypes; //导入依赖的package包/类
public SqlDatetimeSubtractionOperator() {
  super(
      "-",
      SqlKind.MINUS,
      40,
      true,
      ReturnTypes.ARG2_NULLABLE,
      InferTypes.FIRST_KNOWN,
      OperandTypes.MINUS_DATE_OPERATOR);
}
 

import org.apache.calcite.sql.type.InferTypes; //导入依赖的package包/类
public SqlMultisetSetOperator(String name, int prec, boolean all) {
  super(
      name,
      SqlKind.OTHER,
      prec,
      true,
      ReturnTypes.MULTISET_NULLABLE,
      InferTypes.FIRST_KNOWN,
      OperandTypes.MULTISET_MULTISET);
  this.all = all;
}
 

import org.apache.calcite.sql.type.InferTypes; //导入依赖的package包/类
/** Converts a function to a {@link org.apache.calcite.sql.SqlOperator}.
 *
 * <p>The {@code typeFactory} argument is technical debt; see [CALCITE-2082]
 * Remove RelDataTypeFactory argument from SqlUserDefinedAggFunction
 * constructor. */
private static SqlOperator toOp(RelDataTypeFactory typeFactory,
    SqlIdentifier name, final Function function) {
  List<RelDataType> argTypes = new ArrayList<>();
  List<SqlTypeFamily> typeFamilies = new ArrayList<>();
  for (FunctionParameter o : function.getParameters()) {
    final RelDataType type = o.getType(typeFactory);
    argTypes.add(type);
    typeFamilies.add(
        Util.first(type.getSqlTypeName().getFamily(), SqlTypeFamily.ANY));
  }
  final Predicate<Integer> optional =
      new PredicateImpl<Integer>() {
        public boolean test(Integer input) {
          return function.getParameters().get(input).isOptional();
        }
      };
  final FamilyOperandTypeChecker typeChecker =
      OperandTypes.family(typeFamilies, optional);
  final List<RelDataType> paramTypes = toSql(typeFactory, argTypes);
  if (function instanceof ScalarFunction) {
    return new SqlUserDefinedFunction(name, infer((ScalarFunction) function),
        InferTypes.explicit(argTypes), typeChecker, paramTypes, function);
  } else if (function instanceof AggregateFunction) {
    return new SqlUserDefinedAggFunction(name,
        infer((AggregateFunction) function), InferTypes.explicit(argTypes),
        typeChecker, (AggregateFunction) function, false, false, typeFactory);
  } else if (function instanceof TableMacro) {
    return new SqlUserDefinedTableMacro(name, ReturnTypes.CURSOR,
        InferTypes.explicit(argTypes), typeChecker, paramTypes,
        (TableMacro) function);
  } else if (function instanceof TableFunction) {
    return new SqlUserDefinedTableFunction(name, ReturnTypes.CURSOR,
        InferTypes.explicit(argTypes), typeChecker, paramTypes,
        (TableFunction) function);
  } else {
    throw new AssertionError("unknown function type " + function);
  }
}
 

import org.apache.calcite.sql.type.InferTypes; //导入依赖的package包/类
public SqlBetweenOperator(Flag flag, boolean negated) {
  super(negated ? NOT_BETWEEN_NAMES : BETWEEN_NAMES, SqlKind.BETWEEN, 32,
      null, InferTypes.FIRST_KNOWN, OTC_CUSTOM);
  this.flag = flag;
  this.negated = negated;
}
 

import org.apache.calcite.sql.type.InferTypes; //导入依赖的package包/类
SqlDefaultOperator() {
  super("DEFAULT", SqlKind.DEFAULT, 100, true,
      ReturnTypes.explicit(SqlTypeName.ANY), InferTypes.RETURN_TYPE,
      OperandTypes.NILADIC);
}
 

import org.apache.calcite.sql.type.InferTypes; //导入依赖的package包/类
private SqlCaseOperator() {
  super("CASE", SqlKind.CASE, MDX_PRECEDENCE, true, null,
      InferTypes.RETURN_TYPE, null);
}
 

import org.apache.calcite.sql.type.InferTypes; //导入依赖的package包/类
SqlOverlapsOperator(SqlKind kind) {
  super(kind.sql, kind, 30, true, ReturnTypes.BOOLEAN_NULLABLE,
      InferTypes.FIRST_KNOWN,
      OperandTypes.sequence("'<PERIOD> " + kind.sql + " <PERIOD>'",
          OperandTypes.PERIOD, OperandTypes.PERIOD));
}
 

import org.apache.calcite.sql.type.InferTypes; //导入依赖的package包/类
SqlArgumentAssignmentOperator() {
  super("=>", SqlKind.ARGUMENT_ASSIGNMENT, 20, true, ReturnTypes.ARG0,
      InferTypes.RETURN_TYPE, OperandTypes.ANY_ANY);
}