private static int lookup(List<RelDataTypeField> fields, String name) {
for (int i = 0; i < fields.size(); i++) {
final RelDataTypeField field = fields.get(i);
if (field.getName().equals(name)) {
return i;
}
}
return -1;
}
private Expression translate0(RexNode expr) {
if (expr instanceof RexInputRef) {
// TODO: multiple inputs, e.g. joins
final Expression input = getInput(0);
final int index = ((RexInputRef) expr).getIndex();
final List<RelDataTypeField> fields = program.getInputRowType().getFieldList();
final RelDataTypeField field = fields.get(index);
if (fields.size() == 1) {
return input;
} else if (input.getType() == Object[].class) {
return Expressions.convert_(
Expressions.arrayIndex(input, Expressions.constant(field.getIndex())),
Types.box(JavaRules.EnumUtil.javaClass(typeFactory, field.getType())));
} else {
return Expressions.field(input, field.getName());
}
}
if (expr instanceof RexLocalRef) {
return translate(program.getExprList().get(((RexLocalRef) expr).getIndex()));
}
if (expr instanceof RexLiteral) {
return Expressions.constant(
((RexLiteral) expr).getValue(), typeFactory.getJavaClass(expr.getType()));
}
if (expr instanceof RexCall) {
final RexCall call = (RexCall) expr;
final SqlOperator operator = call.getOperator();
final ExpressionType expressionType = SQL_TO_LINQ_OPERATOR_MAP.get(operator);
if (expressionType != null) {
switch (operator.getSyntax()) {
case Binary:
return Expressions.makeBinary(
expressionType, translate(call.getOperands()[0]), translate(call.getOperands()[1]));
case Postfix:
case Prefix:
return Expressions.makeUnary(expressionType, translate(call.getOperands()[0]));
default:
throw new RuntimeException("unknown syntax " + operator.getSyntax());
}
}
Method method = SQL_OP_TO_JAVA_METHOD_MAP.get(operator);
if (method != null) {
List<Expression> exprs = translateList(Arrays.asList(call.operands));
return !Modifier.isStatic(method.getModifiers())
? Expressions.call(exprs.get(0), method, exprs.subList(1, exprs.size()))
: Expressions.call(method, exprs);
}
switch (expr.getKind()) {
default:
throw new RuntimeException("cannot translate expression " + expr);
}
}
throw new RuntimeException("cannot translate expression " + expr);
}
public RelDataType resolveColumn(String name, SqlNode ctx) {
final SqlValidatorNamespace selectNs = validator.getNamespace(select);
final RelDataType rowType = selectNs.getRowType();
final RelDataTypeField field = validator.catalogReader.field(rowType, name);
if (field != null) {
return field.getType();
}
final SqlValidatorScope selectScope = validator.getSelectScope(select);
return selectScope.resolveColumn(name, ctx);
}
/**
* Creates a relational expression which permutes the output fields of a relational expression
* according to a permutation.
*
* <p>Optimizations:
*
* <ul>
* <li>If the relational expression is a {@link CalcRel} or {@link ProjectRel} which is already
* acting as a permutation, combines the new permutation with the old;
* <li>If the permutation is the identity, returns the original relational expression.
* </ul>
*
* <p>If a permutation is combined with its inverse, these optimizations would combine to remove
* them both.
*
* @param rel Relational expression
* @param permutation Permutation to apply to fields
* @param fieldNames Field names; if null, or if a particular entry is null, the name of the
* permuted field is used
* @return relational expression which permutes its input fields
*/
public static RelNode permute(RelNode rel, Permutation permutation, List<String> fieldNames) {
if (permutation.isIdentity()) {
return rel;
}
if (rel instanceof CalcRel) {
CalcRel calcRel = (CalcRel) rel;
Permutation permutation1 = calcRel.getProgram().getPermutation();
if (permutation1 != null) {
Permutation permutation2 = permutation.product(permutation1);
return permute(rel, permutation2, null);
}
}
if (rel instanceof ProjectRel) {
Permutation permutation1 = ((ProjectRel) rel).getPermutation();
if (permutation1 != null) {
Permutation permutation2 = permutation.product(permutation1);
return permute(rel, permutation2, null);
}
}
final List<RelDataType> outputTypeList = new ArrayList<RelDataType>();
final List<String> outputNameList = new ArrayList<String>();
final List<RexNode> exprList = new ArrayList<RexNode>();
final List<RexLocalRef> projectRefList = new ArrayList<RexLocalRef>();
final List<RelDataTypeField> fields = rel.getRowType().getFieldList();
for (int i = 0; i < permutation.getTargetCount(); i++) {
int target = permutation.getTarget(i);
final RelDataTypeField targetField = fields.get(target);
outputTypeList.add(targetField.getType());
outputNameList.add(
((fieldNames == null) || (fieldNames.size() <= i) || (fieldNames.get(i) == null))
? targetField.getName()
: fieldNames.get(i));
exprList.add(rel.getCluster().getRexBuilder().makeInputRef(fields.get(i).getType(), i));
final int source = permutation.getSource(i);
projectRefList.add(new RexLocalRef(source, fields.get(source).getType()));
}
final RexProgram program =
new RexProgram(
rel.getRowType(),
exprList,
projectRefList,
null,
rel.getCluster().getTypeFactory().createStructType(outputTypeList, outputNameList));
return new CalcRel(
rel.getCluster(),
rel.getTraitSet(),
rel,
program.getOutputRowType(),
program,
Collections.<RelCollation>emptyList());
}
/**
* Looks up a field with a given name, returning null if not found.
*
* @param rowType Row type
* @param columnName Field name
* @return Field, or null if not found
*/
public static RelDataTypeField lookupField(
boolean caseSensitive, final RelDataType rowType, String columnName) {
RelDataTypeField field = rowType.getField(columnName, caseSensitive);
if (field != null) {
return field;
}
// If record type is flagged as having "any field you ask for",
// return a type. (TODO: Better way to mark accommodating types.)
RelDataTypeField extra = RelDataTypeImpl.extra(rowType);
if (extra != null) {
return new RelDataTypeFieldImpl(columnName, -1, extra.getType());
}
return null;
}
public static RelDataType createTypeFromProjection(
RelDataType type,
List<String> columnNameList,
RelDataTypeFactory typeFactory,
boolean caseSensitive) {
// If the names in columnNameList and type have case-sensitive differences,
// the resulting type will use those from type. These are presumably more
// canonical.
final List<RelDataTypeField> fields = new ArrayList<RelDataTypeField>(columnNameList.size());
for (String name : columnNameList) {
RelDataTypeField field = type.getField(name, caseSensitive);
fields.add(type.getFieldList().get(field.getIndex()));
}
return typeFactory.createStructType(fields);
}
public RelDataType inferReturnType(SqlOperatorBinding opBinding) {
assert opBinding.getOperandCount() == 1;
final RelDataType recordType = opBinding.getOperandType(0);
boolean isStruct = recordType.isStruct();
int fieldCount = recordType.getFieldCount();
assert isStruct && (fieldCount == 1);
RelDataTypeField fieldType = recordType.getFieldList().get(0);
assert fieldType != null : "expected a record type with one field: " + recordType;
final RelDataType firstColType = fieldType.getType();
return opBinding.getTypeFactory().createTypeWithNullability(firstColType, true);
}
public SqlNode field(int ordinal) {
for (Pair<String, RelDataType> alias : aliases) {
final List<RelDataTypeField> fields = alias.right.getFieldList();
if (ordinal < fields.size()) {
RelDataTypeField field = fields.get(ordinal);
return new SqlIdentifier(
!qualified
? ImmutableList.of(field.getName())
: ImmutableList.of(alias.left, field.getName()),
POS);
}
ordinal -= fields.size();
}
throw new AssertionError("field ordinal " + ordinal + " out of range " + aliases);
}
/**
* Generates a cast for a row type.
*
* @param rexBuilder RexBuilder to use for constructing casts
* @param lhsRowType target row type
* @param rhsExps expressions to be cast
* @return cast expressions
*/
public static RexNode[] generateCastExpressions(
RexBuilder rexBuilder, RelDataType lhsRowType, RexNode[] rhsExps) {
RelDataTypeField[] lhsFields = lhsRowType.getFields();
final int fieldCount = lhsFields.length;
RexNode[] castExps = new RexNode[fieldCount];
assert fieldCount == rhsExps.length;
for (int i = 0; i < fieldCount; ++i) {
RelDataTypeField lhsField = lhsFields[i];
RelDataType lhsType = lhsField.getType();
RelDataType rhsType = rhsExps[i].getType();
if (lhsType.equals(rhsType)) {
castExps[i] = rhsExps[i];
} else {
castExps[i] = rexBuilder.makeCast(lhsType, rhsExps[i]);
}
}
return castExps;
}
private static List<RelCollation> deduceMonotonicity(Prepare.PreparingTable table) {
final List<RelCollation> collationList = new ArrayList<RelCollation>();
// 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.NotMonotonic) {
final RelFieldCollation.Direction direction =
monotonicity.isDecreasing()
? RelFieldCollation.Direction.Descending
: RelFieldCollation.Direction.Ascending;
collationList.add(
RelCollationImpl.of(
new RelFieldCollation(i, direction, RelFieldCollation.NullDirection.UNSPECIFIED)));
}
}
return collationList;
}
private List<RelCollation> deduceMonotonicity(SqlValidatorTable table) {
final RelDataType rowType = table.getRowType();
final List<RelCollation> collationList = new ArrayList<RelCollation>();
// 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(
RelCollationImpl.of(
new RelFieldCollation(
i, direction, RelFieldCollation.NullDirection.UNSPECIFIED)));
}
}
return collationList;
}
/**
* Trims a child relational expression, then adds back a dummy project to restore the fields that
* were removed.
*
* <p>Sounds pointless? It causes unused fields to be removed further down the tree (towards the
* leaves), but it ensure that the consuming relational expression continues to see the same
* fields.
*
* @param rel Relational expression
* @param input Input relational expression, whose fields to trim
* @param fieldsUsed Bitmap of fields needed by the consumer
* @return New relational expression and its field mapping
*/
protected TrimResult trimChildRestore(
RelNode rel, RelNode input, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
TrimResult trimResult = trimChild(rel, input, fieldsUsed, extraFields);
if (trimResult.right.isIdentity()) {
return trimResult;
}
final RelDataType rowType = input.getRowType();
List<RelDataTypeField> fieldList = rowType.getFieldList();
final List<RexNode> exprList = new ArrayList<RexNode>();
final List<String> nameList = rowType.getFieldNames();
RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
assert trimResult.right.getSourceCount() == fieldList.size();
for (int i = 0; i < fieldList.size(); i++) {
int source = trimResult.right.getTargetOpt(i);
RelDataTypeField field = fieldList.get(i);
exprList.add(
source < 0
? rexBuilder.makeZeroLiteral(field.getType())
: rexBuilder.makeInputRef(field.getType(), source));
}
RelNode project = CalcRel.createProject(trimResult.left, exprList, nameList);
return new TrimResult(project, Mappings.createIdentity(fieldList.size()));
}
/**
* Creates a relational expression which projects the output fields of a relational expression
* according to a partial mapping.
*
* <p>A partial mapping is weaker than a permutation: every target has one source, but a source
* may have 0, 1 or more than one targets. Usually the result will have fewer fields than the
* source, unless some source fields are projected multiple times.
*
* <p>This method could optimize the result as {@link #permute} does, but does not at present.
*
* @param rel Relational expression
* @param mapping Mapping from source fields to target fields. The mapping type must obey the
* constaints {@link MappingType#isMandatorySource()} and {@link
* MappingType#isSingleSource()}, as does {@link MappingType#InverseFunction}.
* @param fieldNames Field names; if null, or if a particular entry is null, the name of the
* permuted field is used
* @return relational expression which projects a subset of the input fields
*/
public static RelNode projectMapping(RelNode rel, Mapping mapping, List<String> fieldNames) {
assert mapping.getMappingType().isSingleSource();
assert mapping.getMappingType().isMandatorySource();
if (mapping.isIdentity()) {
return rel;
}
final List<RelDataType> outputTypeList = new ArrayList<RelDataType>();
final List<String> outputNameList = new ArrayList<String>();
final List<RexNode> exprList = new ArrayList<RexNode>();
final List<RexLocalRef> projectRefList = new ArrayList<RexLocalRef>();
final List<RelDataTypeField> fields = rel.getRowType().getFieldList();
for (int i = 0; i < fields.size(); i++) {
final RelDataTypeField field = fields.get(i);
exprList.add(rel.getCluster().getRexBuilder().makeInputRef(field.getType(), i));
}
for (int i = 0; i < mapping.getTargetCount(); i++) {
int source = mapping.getSource(i);
final RelDataTypeField sourceField = fields.get(source);
outputTypeList.add(sourceField.getType());
outputNameList.add(
((fieldNames == null) || (fieldNames.size() <= i) || (fieldNames.get(i) == null))
? sourceField.getName()
: fieldNames.get(i));
projectRefList.add(new RexLocalRef(source, sourceField.getType()));
}
final RexProgram program =
new RexProgram(
rel.getRowType(),
exprList,
projectRefList,
null,
rel.getCluster().getTypeFactory().createStructType(outputTypeList, outputNameList));
return new CalcRel(
rel.getCluster(),
rel.getTraitSet(),
rel,
program.getOutputRowType(),
program,
Collections.<RelCollation>emptyList());
}
public int fieldOrdinal(RelDataType rowType, String alias) {
RelDataTypeField field = field(rowType, alias);
return field != null ? field.getIndex() : -1;
}
<T> PrepareResult<T> prepare_(
Context context, String sql, Queryable<T> queryable, Type elementType) {
final JavaTypeFactory typeFactory = context.getTypeFactory();
OptiqCatalogReader catalogReader = new OptiqCatalogReader(context.getRootSchema(), typeFactory);
final OptiqPreparingStmt preparingStmt =
new OptiqPreparingStmt(catalogReader, typeFactory, context.getRootSchema());
preparingStmt.setResultCallingConvention(CallingConvention.ENUMERABLE);
final RelDataType x;
final PreparedResult preparedResult;
if (sql != null) {
assert queryable == null;
SqlParser parser = new SqlParser(sql);
SqlNode sqlNode;
try {
sqlNode = parser.parseQuery();
} catch (SqlParseException e) {
throw new RuntimeException("parse failed", e);
}
final Schema rootSchema = context.getRootSchema();
SqlValidator validator =
new SqlValidatorImpl(
new ChainedSqlOperatorTable(
Arrays.<SqlOperatorTable>asList(
SqlStdOperatorTable.instance(),
new MySqlOperatorTable(rootSchema, typeFactory))),
catalogReader,
typeFactory,
SqlConformance.Default) {};
preparedResult = preparingStmt.prepareSql(sqlNode, Object.class, validator, true);
x = validator.getValidatedNodeType(sqlNode);
} else {
assert queryable != null;
x = context.getTypeFactory().createType(elementType);
preparedResult = preparingStmt.prepareQueryable(queryable, x);
}
// TODO: parameters
final List<Parameter> parameters = Collections.emptyList();
// TODO: column meta data
final List<ColumnMetaData> columns = new ArrayList<ColumnMetaData>();
RelDataType jdbcType = makeStruct(typeFactory, x);
for (RelDataTypeField field : jdbcType.getFields()) {
RelDataType type = field.getType();
SqlTypeName sqlTypeName = type.getSqlTypeName();
columns.add(
new ColumnMetaData(
columns.size(),
false,
true,
false,
false,
type.isNullable() ? 1 : 0,
true,
0,
field.getName(),
field.getName(),
null,
sqlTypeName.allowsPrec() && false ? type.getPrecision() : -1,
sqlTypeName.allowsScale() ? type.getScale() : -1,
null,
null,
sqlTypeName.getJdbcOrdinal(),
sqlTypeName.getName(),
true,
false,
false,
null));
}
return new PrepareResult<T>(sql, parameters, columns, (Enumerable<T>) preparedResult.execute());
}