import org.apache.calcite.sql.type.SqlReturnTypeInference; //导入依赖的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.SqlReturnTypeInference; //导入依赖的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.SqlReturnTypeInference; //导入依赖的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.SqlReturnTypeInference; //导入依赖的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.SqlReturnTypeInference; //导入依赖的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.SqlReturnTypeInference; //导入依赖的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.SqlReturnTypeInference; //导入依赖的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.SqlReturnTypeInference; //导入依赖的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.SqlReturnTypeInference; //导入依赖的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.SqlReturnTypeInference; //导入依赖的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.SqlReturnTypeInference; //导入依赖的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.SqlReturnTypeInference; //导入依赖的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.SqlReturnTypeInference; //导入依赖的package包/类
public SqlAggOperator(String name, int argCountMin, int argCountMax, SqlReturnTypeInference sqlReturnTypeInference) {
  super(name,
      new SqlIdentifier(name, SqlParserPos.ZERO),
      SqlKind.OTHER_FUNCTION,
      sqlReturnTypeInference,
      null,
      Checker.getChecker(argCountMin, argCountMax),
      SqlFunctionCategory.USER_DEFINED_FUNCTION);
}
 

import org.apache.calcite.sql.type.SqlReturnTypeInference; //导入依赖的package包/类
public SqlOperatorImpl(String name, int argCountMin, int argCountMax, boolean isDeterministic,
    SqlReturnTypeInference sqlReturnTypeInference) {
  this(name,
      argCountMin,
      argCountMax,
      isDeterministic,
      DynamicReturnType.INSTANCE,
      SqlSyntax.FUNCTION);
}
 

import org.apache.calcite.sql.type.SqlReturnTypeInference; //导入依赖的package包/类
/**
 * Give the name and BaseFunctionHolder list, return the inference mechanism.
 */
public static SqlReturnTypeInference getSqlReturnTypeInference(
    final String name,
    final List<BaseFunctionHolder> functions) {

  final String nameCap = name.toUpperCase();
  if(funcNameToInference.containsKey(nameCap)) {
    return funcNameToInference.get(nameCap);
  } else {
    return new DefaultSqlReturnTypeInference(functions);
  }
}
 

import org.apache.calcite.sql.type.SqlReturnTypeInference; //导入依赖的package包/类
private Set<RelColumnMapping> getColumnMappings(SqlOperator op) {
	SqlReturnTypeInference rti = op.getReturnTypeInference();
	if (rti == null) {
		return null;
	}
	if (rti instanceof TableFunctionReturnTypeInference) {
		TableFunctionReturnTypeInference tfrti =
			(TableFunctionReturnTypeInference) rti;
		return tfrti.getColumnMappings();
	} else {
		return null;
	}
}
 

import org.apache.calcite.sql.type.SqlReturnTypeInference; //导入依赖的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.SqlReturnTypeInference; //导入依赖的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 returnTypeInference Inference of the functions return type
* @param operandTypeChecker Operand type checker
*/
public SqlGroupFunction(String name, SqlKind kind, SqlGroupFunction groupFunction,
    SqlReturnTypeInference returnTypeInference, SqlOperandTypeChecker operandTypeChecker) {
  super(name, kind, returnTypeInference, null, operandTypeChecker,
    SqlFunctionCategory.SYSTEM);
  this.groupFunction = groupFunction;
  if (groupFunction != null) {
    assert groupFunction.groupFunction == null;
  }
}
 

import org.apache.calcite.sql.type.SqlReturnTypeInference; //导入依赖的package包/类
/**
 * This constructor exists for the legacy reason.
 *
 * It is because Drill cannot access to DrillOperatorTable at the place where this constructor is being called.
 * In principle, if Drill needs a DrillSqlOperator, it is supposed to go to DrillOperatorTable for pickup.
 */
@Deprecated
public DrillSqlOperator(final String name, final int argCount, final boolean isDeterministic,
    final SqlReturnTypeInference sqlReturnTypeInference, final boolean isNiladic) {
  this(name,
      new ArrayList<DrillFuncHolder>(),
      argCount,
      argCount,
      isDeterministic,
      sqlReturnTypeInference,
      isNiladic);
}
 

import org.apache.calcite.sql.type.SqlReturnTypeInference; //导入依赖的package包/类
private DrillCalciteSqlAggFunctionWrapper(
    SqlAggFunction sqlAggFunction,
    SqlReturnTypeInference sqlReturnTypeInference) {
  super(sqlAggFunction.getName(),
      sqlAggFunction.getSqlIdentifier(),
      sqlAggFunction.getKind(),
      sqlReturnTypeInference,
      sqlAggFunction.getOperandTypeInference(),
      Checker.ANY_CHECKER,
      sqlAggFunction.getFunctionType(),
      sqlAggFunction.requiresOrder(),
      sqlAggFunction.requiresOver());
  this.operator = sqlAggFunction;
}