Java Util.needToImplement方法代码示例

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
public void rewriteRel(Sort rel) {
  RelCollation oldCollation = rel.getCollation();
  final RelNode oldChild = rel.getInput();
  final RelNode newChild = getNewForOldRel(oldChild);
  final Mappings.TargetMapping mapping =
      getNewForOldInputMapping(oldChild);

  // validate
  for (RelFieldCollation field : oldCollation.getFieldCollations()) {
    int oldInput = field.getFieldIndex();
    RelDataType sortFieldType =
        oldChild.getRowType().getFieldList().get(oldInput).getType();
    if (sortFieldType.isStruct()) {
      // TODO jvs 10-Feb-2005
      throw Util.needToImplement("sorting on structured types");
    }
  }
  RelCollation newCollation = RexUtil.apply(mapping, oldCollation);
  Sort newRel =
      LogicalSort.create(newChild, newCollation, rel.offset, rel.fetch);
  setNewForOldRel(rel, newRel);
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/**
 * Returns the type inferred for a dynamic parameter.
 *
 * @param index 0-based index of dynamic parameter
 * @return inferred type, never null
 */
public RelDataType getDynamicParamType(int index) {
	SqlNode sqlNode = dynamicParamSqlNodes.get(index);
	if (sqlNode == null) {
		throw Util.needToImplement("dynamic param type inference");
	}
	return validator.getValidatedNodeType(sqlNode);
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/**
 * Returns the type inferred for a dynamic parameter.
 *
 * @param index 0-based index of dynamic parameter
 * @return inferred type, never null
 */
public RelDataType getDynamicParamType(int index) {
  SqlNode sqlNode = dynamicParamSqlNodes.get(index);
  if (sqlNode == null) {
    throw Util.needToImplement("dynamic param type inference");
  }
  return validator.getValidatedNodeType(sqlNode);
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
public RexNode convertCall(SqlRexContext cx, SqlCall call) {
  final SqlRexConvertlet convertlet = convertletTable.get(call);
  if (convertlet != null) {
    return convertlet.convertCall(cx, call);
  }

  // No convertlet was suitable. (Unlikely, because the standard
  // convertlet table has a fall-back for all possible calls.)
  throw Util.needToImplement(call);
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
public RelDataType getValidatedNodeType(SqlNode node) {
  RelDataType type = getValidatedNodeTypeIfKnown(node);
  if (type == null) {
    throw Util.needToImplement(node);
  } else {
    return type;
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
public RelDataType visit(SqlNodeList nodeList) {
  // Operand is of a type that we can't derive a type for. If the
  // operand is of a peculiar type, such as a SqlNodeList, then you
  // should override the operator's validateCall() method so that it
  // doesn't try to validate that operand as an expression.
  throw Util.needToImplement(nodeList);
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/**
 * Returns a constraint on the number of operands expected by this operator.
 * Subclasses may override this method; when they don't, the range is
 * derived from the {@link SqlOperandTypeChecker} associated with this
 * operator.
 *
 * @return acceptable range
 */
public SqlOperandCountRange getOperandCountRange() {
  if (operandTypeChecker != null) {
    return operandTypeChecker.getOperandCountRange();
  }

  // If you see this error you need to override this method
  // or give operandTypeChecker a value.
  throw Util.needToImplement(this);
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/**
 * Infers the return type of an invocation of this operator; only called
 * after the number and types of operands have already been validated.
 * Subclasses must either override this method or supply an instance of
 * {@link SqlReturnTypeInference} to the constructor.
 *
 * @param opBinding description of invocation (not necessarily a
 * {@link SqlCall})
 * @return inferred return type
 */
public RelDataType inferReturnType(
    SqlOperatorBinding opBinding) {
  if (returnTypeInference != null) {
    return returnTypeInference.inferReturnType(opBinding);
  }

  // Derived type should have overridden this method, since it didn't
  // supply a type inference rule.
  throw Util.needToImplement(this);
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/**
 * Checks that the operand values in a {@link SqlCall} to this operator are
 * valid. Subclasses must either override this method or supply an instance
 * of {@link SqlOperandTypeChecker} to the constructor.
 *
 * @param callBinding    description of call
 * @param throwOnFailure whether to throw an exception if check fails
 *                       (otherwise returns false in that case)
 * @return whether check succeeded
 */
public boolean checkOperandTypes(
    SqlCallBinding callBinding,
    boolean throwOnFailure) {
  // Check that all of the operands are of the right type.
  if (null == operandTypeChecker) {
    // If you see this you must either give operandTypeChecker a value
    // or override this method.
    throw Util.needToImplement(this);
  }

  if (kind != SqlKind.ARGUMENT_ASSIGNMENT) {
    for (Ord<SqlNode> operand : Ord.zip(callBinding.operands())) {
      if (operand.e != null
          && operand.e.getKind() == SqlKind.DEFAULT
          && !operandTypeChecker.isOptional(operand.i)) {
        throw callBinding.getValidator().newValidationError(
            callBinding.getCall(),
            RESOURCE.defaultForOptionalParameter());
      }
    }
  }

  return operandTypeChecker.checkOperandTypes(
      callBinding,
      throwOnFailure);
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
public void addListener(RelOptListener newListener) {
  // TODO jvs 6-Apr-2006:  new superclass AbstractRelOptPlanner
  // now defines a multicast listener; just need to hook it in
  if (listener != null) {
    throw Util.needToImplement("multiple VolcanoPlanner listeners");
  }
  listener = newListener;
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
private RexNode flattenComparison(
    RexBuilder rexBuilder,
    SqlOperator op,
    List<RexNode> exprs) {
  final List<Pair<RexNode, String>> flattenedExps = Lists.newArrayList();
  flattenProjections(this, exprs, null, "", flattenedExps);
  int n = flattenedExps.size() / 2;
  boolean negate = false;
  if (op.getKind() == SqlKind.NOT_EQUALS) {
    negate = true;
    op = SqlStdOperatorTable.EQUALS;
  }
  if ((n > 1) && op.getKind() != SqlKind.EQUALS) {
    throw Util.needToImplement(
        "inequality comparison for row types");
  }
  RexNode conjunction = null;
  for (int i = 0; i < n; ++i) {
    RexNode comparison =
        rexBuilder.makeCall(
            op,
            flattenedExps.get(i).left,
            flattenedExps.get(i + n).left);
    if (conjunction == null) {
      conjunction = comparison;
    } else {
      conjunction =
          rexBuilder.makeCall(
              SqlStdOperatorTable.AND,
              conjunction,
              comparison);
    }
  }
  if (negate) {
    return rexBuilder.makeCall(
        SqlStdOperatorTable.NOT,
        conjunction);
  } else {
    return conjunction;
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
public RelDataType createSqlType(RelDataTypeFactory typeFactory) {
  BitString bitString;
  switch (typeName) {
  case NULL:
  case BOOLEAN:
    RelDataType ret = typeFactory.createSqlType(typeName);
    ret = typeFactory.createTypeWithNullability(ret, null == value);
    return ret;
  case BINARY:
    bitString = (BitString) value;
    int bitCount = bitString.getBitCount();
    return typeFactory.createSqlType(SqlTypeName.BINARY, bitCount / 8);
  case CHAR:
    NlsString string = (NlsString) value;
    Charset charset = string.getCharset();
    if (null == charset) {
      charset = typeFactory.getDefaultCharset();
    }
    SqlCollation collation = string.getCollation();
    if (null == collation) {
      collation = SqlCollation.COERCIBLE;
    }
    RelDataType type =
        typeFactory.createSqlType(
            SqlTypeName.CHAR,
            string.getValue().length());
    type =
        typeFactory.createTypeWithCharsetAndCollation(
            type,
            charset,
            collation);
    return type;

  case INTERVAL_YEAR:
  case INTERVAL_YEAR_MONTH:
  case INTERVAL_MONTH:
  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:
    SqlIntervalLiteral.IntervalValue intervalValue =
        (SqlIntervalLiteral.IntervalValue) value;
    return typeFactory.createSqlIntervalType(
        intervalValue.getIntervalQualifier());

  case SYMBOL:
    return typeFactory.createSqlType(SqlTypeName.SYMBOL);

  case INTEGER: // handled in derived class
  case TIME: // handled in derived class
  case VARCHAR: // should never happen
  case VARBINARY: // should never happen

  default:
    throw Util.needToImplement(toString() + ", operand=" + value);
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
public Iterator<IntPair> iterator() {
  throw Util.needToImplement(this);
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/**
 * Reduces a list of operators and arguments according to the rules of
 * precedence and associativity. Returns the ordinal of the node which
 * replaced the expression.
 *
 * <p>The default implementation throws
 * {@link UnsupportedOperationException}.
 *
 * @param ordinal indicating the ordinal of the current operator in the list
 *                on which a possible reduction can be made
 * @param list    List of alternating
 *     {@link org.apache.calcite.sql.parser.SqlParserUtil.ToTreeListItem} and
 *     {@link SqlNode}
 * @return ordinal of the node which replaced the expression
 */
public ReduceResult reduceExpr(
    int ordinal,
    TokenSequence list) {
  throw Util.needToImplement(this);
}