Java SqlMonotonicity类代码示例

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
/** Converts the direction to a
 * {@link org.apache.calcite.sql.validate.SqlMonotonicity}. */
public SqlMonotonicity monotonicity() {
  switch (this) {
  case ASCENDING:
    return SqlMonotonicity.INCREASING;
  case STRICTLY_ASCENDING:
    return SqlMonotonicity.STRICTLY_INCREASING;
  case DESCENDING:
    return SqlMonotonicity.DECREASING;
  case STRICTLY_DESCENDING:
    return SqlMonotonicity.STRICTLY_DECREASING;
  case CLUSTERED:
    return SqlMonotonicity.MONOTONIC;
  default:
    throw new AssertionError("unknown: " + this);
  }
}
 

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
/** Converts a {@link SqlMonotonicity} to a direction. */
public static Direction of(SqlMonotonicity monotonicity) {
  switch (monotonicity) {
  case INCREASING:
    return ASCENDING;
  case DECREASING:
    return DESCENDING;
  case STRICTLY_INCREASING:
    return STRICTLY_ASCENDING;
  case STRICTLY_DECREASING:
    return STRICTLY_DESCENDING;
  case MONOTONIC:
    return CLUSTERED;
  default:
    throw new AssertionError("unknown: " + monotonicity);
  }
}
 

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
public SqlMonotonicity getMonotonicity(SqlValidatorScope scope) {
  // for "star" column, whether it's static or dynamic return not_monotonic directly.
  if (Util.last(names).equals("") || DynamicRecordType.isDynamicStarColName(Util.last(names))) {
    return SqlMonotonicity.NOT_MONOTONIC;
  }

  // First check for builtin functions which don't have parentheses,
  // like "LOCALTIME".
  final SqlValidator validator = scope.getValidator();
  SqlCall call =
      SqlUtil.makeCall(
          validator.getOperatorTable(),
          this);
  if (call != null) {
    return call.getMonotonicity(scope);
  }
  final SqlQualified qualified = scope.fullyQualify(this);
  final SqlIdentifier fqId = qualified.identifier;
  return qualified.namespace.resolve().getMonotonicity(Util.last(fqId.names));
}
 

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
@Override public SqlMonotonicity getMonotonicity(SqlOperatorBinding call) {
  if (getName().equals("/")) {
    final SqlMonotonicity mono0 = call.getOperandMonotonicity(0);
    final SqlMonotonicity mono1 = call.getOperandMonotonicity(1);
    if (mono1 == SqlMonotonicity.CONSTANT) {
      if (call.isOperandLiteral(1, false)) {
        switch (call.getOperandLiteralValue(1, BigDecimal.class).signum()) {
        case -1:

          // mono / -ve constant --> reverse mono, unstrict
          return mono0.reverse().unstrict();
        case 0:

          // mono / zero --> constant (infinity!)
          return SqlMonotonicity.CONSTANT;
        default:

          // mono / +ve constant * mono1 --> mono, unstrict
          return mono0.unstrict();
        }
      }
    }
  }

  return super.getMonotonicity(call);
}
 

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
@Override public SqlMonotonicity getOperandMonotonicity(int ordinal) {
  RexNode operand = operands.get(ordinal);

  if (operand instanceof RexInputRef) {
    for (RelCollation ic : inputCollations) {
      if (ic.getFieldCollations().isEmpty()) {
        continue;
      }

      for (RelFieldCollation rfc : ic.getFieldCollations()) {
        if (rfc.getFieldIndex() == ((RexInputRef) operand).getIndex()) {
          return rfc.direction.monotonicity();
          // TODO: Is it possible to have more than one RelFieldCollation for a RexInputRef?
        }
      }
    }
  } else if (operand instanceof RexCall) {
    final RexCallBinding binding =
        RexCallBinding.create(typeFactory, (RexCall) operand, inputCollations);
    return ((RexCall) operand).getOperator().getMonotonicity(binding);
  }

  return SqlMonotonicity.NOT_MONOTONIC;
}
 

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
private List<RelCollation> deduceMonotonicity(SqlValidatorTable table) {
  final RelDataType rowType = table.getRowType();
  final List<RelCollation> collationList = new ArrayList<>();

  // Deduce which fields the table is sorted on.
  int i = -1;
  for (RelDataTypeField field : rowType.getFieldList()) {
    ++i;
    final SqlMonotonicity monotonicity =
        table.getMonotonicity(field.getName());
    if (monotonicity != SqlMonotonicity.NOT_MONOTONIC) {
      final RelFieldCollation.Direction direction =
          monotonicity.isDecreasing()
              ? RelFieldCollation.Direction.DESCENDING
              : RelFieldCollation.Direction.ASCENDING;
      collationList.add(
          RelCollations.of(new RelFieldCollation(i, direction)));
    }
  }
  return collationList;
}
 

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
private static List<RelCollation> deduceMonotonicity(
    Prepare.PreparingTable table) {
  final List<RelCollation> collationList = Lists.newArrayList();

  // Deduce which fields the table is sorted on.
  int i = -1;
  for (RelDataTypeField field : table.getRowType().getFieldList()) {
    ++i;
    final SqlMonotonicity monotonicity =
        table.getMonotonicity(field.getName());
    if (monotonicity != SqlMonotonicity.NOT_MONOTONIC) {
      final RelFieldCollation.Direction direction =
          monotonicity.isDecreasing()
              ? RelFieldCollation.Direction.DESCENDING
              : RelFieldCollation.Direction.ASCENDING;
      collationList.add(
          RelCollations.of(
              new RelFieldCollation(i, direction)));
    }
  }
  return collationList;
}
 

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
@Override public SqlMonotonicity getMonotonicity(SqlOperatorBinding call) {
  // Monotonic iff its first argument is, but not strict.
  //
  // Note: This strategy happens to works for all current group functions
  // (HOP, TUMBLE, SESSION). When there are exceptions to this rule, we'll
  // make the method abstract.
  return call.getOperandMonotonicity(0).unstrict();
}
 

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
public SqlMonotonicity getMonotonicity(String columnName) {
  final int i = rowType.getFieldNames().indexOf(columnName);
  if (i >= 0) {
    for (RelCollation collation : table.getStatistic().getCollations()) {
      final RelFieldCollation fieldCollation =
          collation.getFieldCollations().get(0);
      if (fieldCollation.getFieldIndex() == i) {
        return fieldCollation.direction.monotonicity();
      }
    }
  }
  return SqlMonotonicity.NOT_MONOTONIC;
}
 

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
@Override public SqlMonotonicity getMonotonicity(SqlOperatorBinding call) {
  // SUBSTRING(x FROM 0 FOR constant) has same monotonicity as x
  if (call.getOperandCount() == 3) {
    final SqlMonotonicity mono0 = call.getOperandMonotonicity(0);
    if ((mono0 != SqlMonotonicity.NOT_MONOTONIC)
        && call.getOperandMonotonicity(1) == SqlMonotonicity.CONSTANT
        && call.getOperandLiteralValue(1, BigDecimal.class)
            .equals(BigDecimal.ZERO)
        && call.getOperandMonotonicity(2) == SqlMonotonicity.CONSTANT) {
      return mono0.unstrict();
    }
  }
  return super.getMonotonicity(call);
}
 

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
@Override public SqlMonotonicity getMonotonicity(SqlOperatorBinding call) {
  switch (call.getOperandLiteralValue(0, TimeUnitRange.class)) {
  case YEAR:
    return call.getOperandMonotonicity(1).unstrict();
  default:
    return SqlMonotonicity.NOT_MONOTONIC;
  }
}
 

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
@Override public SqlMonotonicity getMonotonicity(SqlOperatorBinding call) {
  RelDataTypeFamily castFrom = call.getOperandType(0).getFamily();
  RelDataTypeFamily castTo = call.getOperandType(1).getFamily();
  if (castFrom instanceof SqlTypeFamily
      && castTo instanceof SqlTypeFamily
      && nonMonotonicCasts.containsEntry(castFrom, castTo)) {
    return SqlMonotonicity.NOT_MONOTONIC;
  } else {
    return call.getOperandMonotonicity(0);
  }
}
 

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
@Override public SqlMonotonicity getMonotonicity(SqlOperatorBinding call) {
  if (getName().equals("-")) {
    return call.getOperandMonotonicity(0).reverse();
  }

  return super.getMonotonicity(call);
}
 

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
public void checkMonotonic(String query,
    SqlMonotonicity expectedMonotonicity) {
  SqlValidator validator = getValidator();
  SqlNode n = parseAndValidate(validator, query);
  final RelDataType rowType = validator.getValidatedNodeType(n);
  final SqlValidatorNamespace selectNamespace = validator.getNamespace(n);
  final String field0 = rowType.getFieldList().get(0).getName();
  final SqlMonotonicity monotonicity =
      selectNamespace.getMonotonicity(field0);
  assertThat(monotonicity, equalTo(expectedMonotonicity));
}
 

import org.apache.calcite.sql.validate.SqlMonotonicity; //导入依赖的package包/类
public SqlMonotonicity getMonotonicity(String sql) {
  final SqlValidator validator = getValidator();
  final SqlNode node = parseAndValidate(validator, sql);
  final SqlSelect select = (SqlSelect) node;
  final SqlNode selectItem0 = select.getSelectList().get(0);
  final SqlValidatorScope scope = validator.getSelectScope(select);
  return selectItem0.getMonotonicity(scope);
}