import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
private RelDataType createCalciteTypeWithNullability(RelDataTypeFactory typeFactory,
                                                     SqlTypeName sqlTypeName,
                                                     boolean isNullable) {
  RelDataType type;
  if (sqlTypeName == SqlTypeName.INTERVAL_DAY_TIME) {
    type = typeFactory.createSqlIntervalType(
        new SqlIntervalQualifier(
            TimeUnit.DAY,
            TimeUnit.MINUTE,
            SqlParserPos.ZERO));
  } else if (sqlTypeName == SqlTypeName.INTERVAL_YEAR_MONTH) {
    type = typeFactory.createSqlIntervalType(
        new SqlIntervalQualifier(
            TimeUnit.YEAR,
            TimeUnit.MONTH,
           SqlParserPos.ZERO));
  } else if (sqlTypeName == SqlTypeName.VARCHAR) {
    type = typeFactory.createSqlType(sqlTypeName, TypeHelper.VARCHAR_DEFAULT_CAST_LEN);
  } else {
    type = typeFactory.createSqlType(sqlTypeName);
  }
  return typeFactory.createTypeWithNullability(type, isNullable);
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
@JsonCreator
public FieldType(
    @JsonProperty("name")                       String name,
    @JsonProperty("type")                       SqlTypeName type,
    @JsonProperty("precision")                  Integer precision,
    @JsonProperty("scale")                      Integer scale,
    @JsonProperty("startUnit")                  TimeUnit startUnit,
    @JsonProperty("endUnit")                    TimeUnit endUnit,
    @JsonProperty("fractionalSecondPrecision")  Integer fractionalSecondPrecision,
    @JsonProperty("isNullable")                 Boolean isNullable) {
  this.name = name;
  this.type = type;
  this.precision = precision;
  this.scale = scale;
  this.intervalQualifier =
      null == startUnit
      ? null
      : new SqlIntervalQualifier(
          startUnit, precision, endUnit, fractionalSecondPrecision, SqlParserPos.ZERO );

  // Property "isNullable" is not part of the initial view definition and
  // was added in DRILL-2342.  If the default value is null, consider it as
  // "true".  It is safe to default to "nullable" than "required" type.
  this.isNullable = isNullable == null ? true : isNullable;
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
@Override
public RexNode convertCall(SqlRexContext cx, SqlCall call) {
  final RexBuilder rexBuilder = cx.getRexBuilder();
  final List<SqlNode> operands = call.getOperandList();
  final List<RexNode> exprs = new LinkedList<>();

  String timeUnit = ((SqlIntervalQualifier) operands.get(0)).timeUnitRange.toString();

  RelDataTypeFactory typeFactory = cx.getTypeFactory();

  //RelDataType nullableReturnType =

  for (SqlNode node: operands) {
     exprs.add(cx.convertExpression(node));
  }

  final RelDataType returnType
      = typeFactory.createTypeWithNullability(typeFactory.createSqlType(SqlTypeName.BIGINT), exprs.get(1).getType().isNullable());
  return rexBuilder.makeCall(returnType, call.getOperator(), exprs);
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
/**
 * Given a {@link SqlTypeName} and nullability, create a RelDataType from the RelDataTypeFactory
 *
 * @param typeFactory RelDataTypeFactory used to create the RelDataType
 * @param sqlTypeName the given SqlTypeName
 * @param isNullable  the nullability of the created RelDataType
 * @return RelDataType Type of call
 */
public static RelDataType createCalciteTypeWithNullability(RelDataTypeFactory typeFactory,
                                                           SqlTypeName sqlTypeName,
                                                           boolean isNullable) {
  RelDataType type;
  if (sqlTypeName == SqlTypeName.INTERVAL_DAY_TIME) {
    type = typeFactory.createSqlIntervalType(
        new SqlIntervalQualifier(
            TimeUnit.DAY,
            TimeUnit.MINUTE,
            SqlParserPos.ZERO));
  } else if (sqlTypeName == SqlTypeName.INTERVAL_YEAR_MONTH) {
    type = typeFactory.createSqlIntervalType(
        new SqlIntervalQualifier(
            TimeUnit.YEAR,
            TimeUnit.MONTH,
            SqlParserPos.ZERO));
  } else if (sqlTypeName == SqlTypeName.VARCHAR) {
    type = typeFactory.createSqlType(sqlTypeName, Types.MAX_VARCHAR_LENGTH);
  } else {
    type = typeFactory.createSqlType(sqlTypeName);
  }
  return typeFactory.createTypeWithNullability(type, isNullable);
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
public static long intervalToMillis(
    String literal,
    SqlIntervalQualifier intervalQualifier) {
  Preconditions.checkArgument(!intervalQualifier.isYearMonth(),
      "interval must be day time");
  int[] ret;
  try {
    ret = intervalQualifier.evaluateIntervalLiteral(literal,
        intervalQualifier.getParserPosition(), RelDataTypeSystem.DEFAULT);
    assert ret != null;
  } catch (CalciteContextException e) {
    throw new RuntimeException("while parsing day-to-second interval "
        + literal, e);
  }
  long l = 0;
  long[] conv = new long[5];
  conv[4] = 1; // millisecond
  conv[3] = conv[4] * 1000; // second
  conv[2] = conv[3] * 60; // minute
  conv[1] = conv[2] * 60; // hour
  conv[0] = conv[1] * 24; // day
  for (int i = 1; i < ret.length; i++) {
    l += conv[i - 1] * ret[i];
  }
  return ret[0] * l;
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
public static long intervalToMonths(
    String literal,
    SqlIntervalQualifier intervalQualifier) {
  Preconditions.checkArgument(intervalQualifier.isYearMonth(),
      "interval must be year month");
  int[] ret;
  try {
    ret = intervalQualifier.evaluateIntervalLiteral(literal,
        intervalQualifier.getParserPosition(), RelDataTypeSystem.DEFAULT);
    assert ret != null;
  } catch (CalciteContextException e) {
    throw new RuntimeException("Error while parsing year-to-month interval "
        + literal, e);
  }

  long l = 0;
  long[] conv = new long[2];
  conv[1] = 1; // months
  conv[0] = conv[1] * 12; // years
  for (int i = 1; i < ret.length; i++) {
    l += conv[i - 1] * ret[i];
  }
  return ret[0] * l;
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
/**
 * Given a {@link SqlTypeName} and nullability, create a RelDataType from the RelDataTypeFactory
 *
 * @param typeFactory RelDataTypeFactory used to create the RelDataType
 * @param sqlTypeName the given SqlTypeName
 * @param isNullable  the nullability of the created RelDataType
 * @return RelDataType Type of call
 */
public static RelDataType createCalciteTypeWithNullability(RelDataTypeFactory typeFactory,
                                                           SqlTypeName sqlTypeName,
                                                           boolean isNullable) {
  RelDataType type;
  switch (sqlTypeName) {
    case INTERVAL_YEAR:
    case INTERVAL_YEAR_MONTH:
    case INTERVAL_MONTH:
      type = typeFactory.createSqlIntervalType(
        new SqlIntervalQualifier(
          TimeUnit.YEAR,
          TimeUnit.MONTH,
          SqlParserPos.ZERO));
      break;
    case INTERVAL_DAY:
    case INTERVAL_DAY_HOUR:
    case INTERVAL_DAY_MINUTE:
    case INTERVAL_DAY_SECOND:
    case INTERVAL_HOUR:
    case INTERVAL_HOUR_MINUTE:
    case INTERVAL_HOUR_SECOND:
    case INTERVAL_MINUTE:
    case INTERVAL_MINUTE_SECOND:
    case INTERVAL_SECOND:
      type = typeFactory.createSqlIntervalType(
        new SqlIntervalQualifier(
          TimeUnit.DAY,
          TimeUnit.MINUTE,
          SqlParserPos.ZERO));
      break;
    case VARCHAR:
      type = typeFactory.createSqlType(sqlTypeName, TypeHelper.VARCHAR_DEFAULT_CAST_LEN);
    default:
      type = typeFactory.createSqlType(sqlTypeName);
  }
  return typeFactory.createTypeWithNullability(type, isNullable);
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
@Override
public RexNode convertCall(SqlRexContext cx, SqlCall call) {
  final RexBuilder rexBuilder = cx.getRexBuilder();
  final List<SqlNode> operands = call.getOperandList();
  final List<RexNode> exprs = new LinkedList<>();

  String timeUnit = ((SqlIntervalQualifier) operands.get(0)).timeUnitRange.toString();

  RelDataTypeFactory typeFactory = cx.getTypeFactory();

  //RelDataType nullableReturnType =

  for (SqlNode node: operands) {
     exprs.add(cx.convertExpression(node));
  }

  final RelDataType returnType;
  if(call.getOperator() == SqlStdOperatorTable.EXTRACT) {
    // Legacy code:
    // The return type is wrong!
    // Legacy code choose SqlTypeName.BIGINT simply to avoid conflicting against Calcite's inference mechanism
    // (, which chose BIGINT in validation phase already)
    // Determine NULL-able using 2nd argument's Null-able.
    returnType = typeFactory.createTypeWithNullability(typeFactory.createSqlType(SqlTypeName.BIGINT), exprs.get(1).getType().isNullable());
  } else {
    // Determine NULL-able using 2nd argument's Null-able.
    returnType = typeFactory.createTypeWithNullability(
        typeFactory.createSqlType(
            TypeInferenceUtils.getSqlTypeNameForTimeUnit(timeUnit)),
        exprs.get(1).getType().isNullable());
  }

  return rexBuilder.makeCall(returnType, call.getOperator(), exprs);
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
/**
 * Adds a field with an interval type.
 */
public Builder add(String name, TimeUnit startUnit, int startPrecision,
    TimeUnit endUnit, int fractionalSecondPrecision) {
  final SqlIntervalQualifier q =
      new SqlIntervalQualifier(startUnit, startPrecision, endUnit,
          fractionalSecondPrecision, SqlParserPos.ZERO);
  add(name, typeFactory.createSqlIntervalType(q));
  return this;
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
public RexLiteral convertInterval(
    SqlRexContext cx,
    SqlIntervalQualifier intervalQualifier) {
  RexBuilder rexBuilder = cx.getRexBuilder();

  return rexBuilder.makeIntervalLiteral(intervalQualifier);
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
public RexNode convertCall(SqlRexContext cx, SqlCall call) {
  // TIMESTAMPADD(unit, count, timestamp)
  //  => timestamp + count * INTERVAL '1' UNIT
  final RexBuilder rexBuilder = cx.getRexBuilder();
  final SqlLiteral unitLiteral = call.operand(0);
  final TimeUnit unit = unitLiteral.symbolValue(TimeUnit.class);
  return rexBuilder.makeCall(SqlStdOperatorTable.DATETIME_PLUS,
      cx.convertExpression(call.operand(2)),
      multiply(rexBuilder,
          rexBuilder.makeIntervalLiteral(unit.multiplier,
              new SqlIntervalQualifier(unit, null,
                  unitLiteral.getParserPosition())),
          cx.convertExpression(call.operand(1))));
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
public static SqlIntervalLiteral parseIntervalLiteral(SqlParserPos pos,
    int sign, String s, SqlIntervalQualifier intervalQualifier) {
  final String intervalStr = parseString(s);
  if (intervalStr.equals("")) {
    throw SqlUtil.newContextException(pos,
        RESOURCE.illegalIntervalLiteral(s + " "
            + intervalQualifier.toString(), pos.toString()));
  }
  return SqlLiteral.createInterval(sign, intervalStr, intervalQualifier, pos);
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
@Override public SqlNode rewriteCall(SqlValidator validator, SqlCall call) {
  final List<SqlNode> operands = call.getOperandList();
  final SqlParserPos pos = call.getParserPosition();
  return SqlStdOperatorTable.EXTRACT.createCall(pos,
      new SqlIntervalQualifier(timeUnit, null, SqlParserPos.ZERO),
      operands.get(0));
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
/**
 * Constructs an IntervalSqlType. This should only be called from a factory
 * method.
 */
public IntervalSqlType(RelDataTypeSystem typeSystem,
    SqlIntervalQualifier intervalQualifier,
    boolean isNullable) {
  super(intervalQualifier.typeName(), isNullable, null);
  this.typeSystem = Preconditions.checkNotNull(typeSystem);
  this.intervalQualifier = Preconditions.checkNotNull(intervalQualifier);
  computeDigest();
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
/**
 * Creates a literal representing an interval value, for example
 * {@code INTERVAL '3-7' YEAR TO MONTH}.
 */
public RexLiteral makeIntervalLiteral(
    BigDecimal v,
    SqlIntervalQualifier intervalQualifier) {
  return makeLiteral(
      v,
      typeFactory.createSqlIntervalType(intervalQualifier),
      intervalQualifier.typeName());
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
/**
 * Gets the interval type qualifier of the interval data type descriptor of
 * this field (<i>iff</i> interval type). */
@JsonIgnore
public SqlIntervalQualifier getIntervalQualifier() {
  return intervalQualifier;
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
@Override public Void visit(SqlIntervalQualifier intervalQualifier) {
  return format(intervalQualifier);
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
@Override
public T visit(SqlIntervalQualifier qualifier) {
  throw new UnsupportedOperationException("SqlIntervalQualifier " + qualifier);
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
@Override
public List<SqlIdentifier> visit(SqlIntervalQualifier intervalQualifier) {
  return Collections.emptyList();
}
 

import org.apache.calcite.sql.SqlIntervalQualifier; //导入依赖的package包/类
public RexNode convertInterval(SqlIntervalQualifier intervalQualifier) {
	return exprConverter.convertInterval(this, intervalQualifier);
}