@Override
public ParseTree visitChildInternal(RelNode child, int ordinal) {
final Convention convention = child.getConvention();
if (!(child instanceof JavaRel)) {
throw Util.newInternal(
"Relational expression '"
+ child
+ "' has '"
+ convention
+ "' calling convention, so must implement interface "
+ JavaRel.class);
}
JavaRel javaRel = (JavaRel) child;
final ParseTree p = javaRel.implement(this);
if ((convention == CallingConvention.JAVA) && (p != null)) {
throw Util.newInternal(
"Relational expression '"
+ child
+ "' returned '"
+ p
+ " on implement, but should have "
+ "returned null, because it has JAVA calling-convention. "
+ "(Note that similar calling-conventions, such as "
+ "Iterator, must return a value.)");
}
return p;
}
/**
* Creates a JavaRelImplementor
*
* @param rexBuilder Builder for {@link RexNode}s
* @param implementorTable Table of implementations of operators. Must not be null
*/
public JavaRelImplementor(RexBuilder rexBuilder, OJRexImplementorTable implementorTable) {
super(rexBuilder);
Util.pre(rexBuilder != null, "rexBuilder != null");
Util.pre(implementorTable != null, "implementorTable != null");
this.implementorTable = implementorTable;
nextVariableId = 0;
}
/** Variant of {@link #trimFields(RelNode, BitSet, Set)} for {@link TableModificationRel}. */
public TrimResult trimFields(
TableModificationRel modifier, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
// Ignore what consumer wants. We always project all columns.
Util.discard(fieldsUsed);
final RelDataType rowType = modifier.getRowType();
final int fieldCount = rowType.getFieldCount();
RelNode input = modifier.getChild();
// We want all fields from the child.
final int inputFieldCount = input.getRowType().getFieldCount();
BitSet inputFieldsUsed = Util.bitSetBetween(0, inputFieldCount);
// Create input with trimmed columns.
final Set<RelDataTypeField> inputExtraFields = Collections.emptySet();
TrimResult trimResult = trimChild(modifier, input, inputFieldsUsed, inputExtraFields);
RelNode newInput = trimResult.left;
final Mapping inputMapping = trimResult.right;
if (!inputMapping.isIdentity()) {
// We asked for all fields. Can't believe that the child decided
// to permute them!
throw Util.newInternal("Expected identity mapping, got " + inputMapping);
}
TableModificationRel newModifier = modifier;
if (newInput != input) {
newModifier = modifier.copy(modifier.getTraitSet(), Collections.singletonList(newInput));
}
assert newModifier.getClass() == modifier.getClass();
// Always project all fields.
Mapping mapping = Mappings.createIdentity(fieldCount);
return new TrimResult(newModifier, mapping);
}
/**
* Trims the fields of an input relational expression.
*
* @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 trimChild(
RelNode rel, RelNode input, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
Util.discard(rel);
if (input.getClass().getName().endsWith("MedMdrClassExtentRel")) {
// MedMdrJoinRule cannot handle Join of Project of
// MedMdrClassExtentRel, only naked MedMdrClassExtentRel.
// So, disable trimming.
fieldsUsed = Util.bitSetBetween(0, input.getRowType().getFieldCount());
}
return dispatchTrimFields(input, fieldsUsed, extraFields);
}
/**
* Resolves a multi-part identifier such as "SCHEMA.EMP.EMPNO" to a namespace. The returned
* namespace may represent a schema, table, column, etc.
*
* @pre names.size() > 0
* @post return != null
*/
public static SqlValidatorNamespace lookup(SqlValidatorScope scope, List<String> names) {
Util.pre(names.size() > 0, "names.size() > 0");
SqlValidatorNamespace namespace = null;
for (int i = 0; i < names.size(); i++) {
String name = names.get(i);
if (i == 0) {
namespace = scope.resolve(name, null, null);
} else {
namespace = namespace.lookupChild(name);
}
}
Util.permAssert(namespace != null, "post: namespace != null");
return namespace;
}
/** Variant of {@link #trimFields(RelNode, BitSet, Set)} for {@link TableFunctionRel}. */
public TrimResult trimFields(
TableFunctionRel tabFun, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
final RelDataType rowType = tabFun.getRowType();
final int fieldCount = rowType.getFieldCount();
List<RelNode> newInputs = new ArrayList<RelNode>();
for (RelNode input : tabFun.getInputs()) {
final int inputFieldCount = input.getRowType().getFieldCount();
BitSet inputFieldsUsed = Util.bitSetBetween(0, inputFieldCount);
// Create input with trimmed columns.
final Set<RelDataTypeField> inputExtraFields = Collections.emptySet();
TrimResult trimResult = trimChildRestore(tabFun, input, inputFieldsUsed, inputExtraFields);
assert trimResult.right.isIdentity();
newInputs.add(trimResult.left);
}
TableFunctionRel newTabFun = tabFun;
if (!tabFun.getInputs().equals(newInputs)) {
newTabFun = tabFun.copy(tabFun.getTraitSet(), newInputs);
}
assert newTabFun.getClass() == tabFun.getClass();
// Always project all fields.
Mapping mapping = Mappings.createIdentity(fieldCount);
return new TrimResult(newTabFun, mapping);
}
/**
* Creates an expression which references correlating variable <code>
* correlName</code> from the context of <code>rel</code>. For example, if <code>correlName</code>
* is set by the 1st child of <code>rel</code>'s 2nd child, then this method returns <code>
* $input2.$input1</code>.
*/
public Expression makeReference(String correlName, RelNode rel) {
JavaFrame frame = (JavaFrame) mapCorrel2Frame.get(correlName);
assert (frame != null);
assert Util.equal(frame.rel.getCorrelVariable(), correlName);
assert (frame.hasVariable());
return frame.getVariable();
}
private void bindDeferred(JavaFrame frame, final RelNode rel) {
final StatementList statementList = getStatementList();
if (frame.bind == null) {
// this relational expression has not bound itself, so we presume
// that we can call its implementSelf() method
if (!(rel instanceof JavaSelfRel)) {
throw Util.newInternal(
"In order to bind-deferred, a "
+ "relational expression must implement JavaSelfRel: "
+ rel);
}
final JavaSelfRel selfRel = (JavaSelfRel) rel;
LazyBind lazyBind =
new LazyBind(
newVariable(),
statementList,
getTypeFactory(),
rel.getRowType(),
new VariableInitializerThunk() {
public VariableInitializer getInitializer() {
return selfRel.implementSelf(JavaRelImplementor.this);
}
});
bind(rel, lazyBind);
} else if ((frame.bind instanceof LazyBind)
&& (((LazyBind) frame.bind).statementList != statementList)) {
// Frame is already bound, but to a variable declared in a different
// scope. Re-bind it.
final LazyBind lazyBind = (LazyBind) frame.bind;
lazyBind.statementList = statementList;
lazyBind.bound = false;
}
}
private Mapping createMapping(BitSet fieldsUsed, int fieldCount) {
final Mapping mapping =
Mappings.create(MappingType.InverseSurjection, fieldCount, fieldsUsed.cardinality());
int i = 0;
for (int field : Util.toIter(fieldsUsed)) {
mapping.set(field, i++);
}
return mapping;
}
/**
* Trims unused fields from a relational expression.
*
* <p>We presume that all fields of the relational expression are wanted by its consumer, so only
* trim fields that are not used within the tree.
*
* @param root Root node of relational expression
* @return Trimmed relational expression
*/
public RelNode trim(RelNode root) {
final int fieldCount = root.getRowType().getFieldCount();
final BitSet fieldsUsed = Util.bitSetBetween(0, fieldCount);
final Set<RelDataTypeField> extraFields = Collections.emptySet();
final TrimResult trimResult = dispatchTrimFields(root, fieldsUsed, extraFields);
if (!trimResult.right.isIdentity()) {
throw new IllegalArgumentException();
}
return trimResult.left;
}
public RelNode convertSqlToRel(String sql) {
Util.pre(sql != null, "sql != null");
final SqlNode sqlQuery;
try {
sqlQuery = parseQuery(sql);
} catch (Exception e) {
throw Util.newInternal(e); // todo: better handling
}
final RelDataTypeFactory typeFactory = getTypeFactory();
final Prepare.CatalogReader catalogReader = createCatalogReader(typeFactory);
final SqlValidator validator = createValidator(catalogReader, typeFactory);
final SqlToRelConverter converter =
createSqlToRelConverter(validator, catalogReader, typeFactory);
converter.setTrimUnusedFields(true);
final SqlNode validatedQuery = validator.validate(sqlQuery);
final RelNode rel = converter.convertQuery(validatedQuery, false, true);
Util.post(rel != null, "return != null");
return rel;
}
/**
* Records the fact that instances of <code>rel</code> are available via <code>bind</code> (which
* may be eager or lazy).
*/
private void bind(RelNode rel, Bind bind) {
tracer.log(Level.FINE, "Bind " + rel.toString() + " to " + bind);
JavaFrame frame = (JavaFrame) mapRel2Frame.get(rel);
frame.bind = bind;
boolean stupid = SaffronProperties.instance().stupid.get();
if (stupid) {
// trigger the declaration of the variable, even though it
// may not be used
Util.discard(bind.getVariable());
}
}
private static int find(StatementList list, Statement statement) {
if (statement == null) {
return 0;
} else {
for (int i = 0, n = list.size(); i < n; i++) {
if (list.get(i) == statement) {
return i + 1;
}
}
throw Util.newInternal("could not find statement " + statement + " in list " + list);
}
}
/**
* Variant of {@link #trimFields(RelNode, BitSet, Set)} for {@link
* org.eigenbase.rel.TableAccessRel}.
*/
public TrimResult trimFields(
final TableAccessRelBase tableAccessRel,
BitSet fieldsUsed,
Set<RelDataTypeField> extraFields) {
final int fieldCount = tableAccessRel.getRowType().getFieldCount();
if (fieldsUsed.equals(Util.bitSetBetween(0, fieldCount)) && extraFields.isEmpty()) {
return trimFields((RelNode) tableAccessRel, fieldsUsed, extraFields);
}
final RelNode newTableAccessRel = tableAccessRel.project(fieldsUsed, extraFields);
final Mapping mapping = createMapping(fieldsUsed, fieldCount);
return new TrimResult(newTableAccessRel, mapping);
}
/** Returns whether an array of expressions has any common sub-expressions. */
public static boolean containCommonExprs(RexNode[] exprs, boolean fail) {
final ExpressionNormalizer visitor = new ExpressionNormalizer(false);
for (int i = 0; i < exprs.length; i++) {
try {
exprs[i].accept(visitor);
} catch (ExpressionNormalizer.SubExprExistsException e) {
Util.swallow(e, null);
assert !fail;
}
}
return false;
}
/**
* Replaces the operands of a call. The new operands' types must match the old operands' types.
*/
public static RexCall replaceOperands(RexCall call, RexNode[] operands) {
if (call.operands == operands) {
return call;
}
for (int i = 0; i < operands.length; i++) {
RelDataType oldType = call.operands[i].getType();
RelDataType newType = operands[i].getType();
if (!oldType.isNullable() && newType.isNullable()) {
throw Util.newInternal("invalid nullability");
}
assert (oldType.toString().equals(newType.toString()));
}
return new RexCall(call.getType(), call.getOperator(), operands);
}
/**
* Returns whether a given tree contains any {link RexInputRef} nodes.
*
* @param node a RexNode tree
*/
public static boolean containsInputRef(RexNode node) {
try {
RexVisitor<Void> visitor =
new RexVisitorImpl<Void>(true) {
public Void visitInputRef(RexInputRef inputRef) {
throw new Util.FoundOne(inputRef);
}
};
node.accept(visitor);
return false;
} catch (Util.FoundOne e) {
Util.swallow(e, null);
return true;
}
}
public static void getSchemaObjectMonikers(
SqlValidatorCatalogReader catalogReader, List<String> names, List<SqlMoniker> hints) {
// Assume that the last name is 'dummy' or similar.
List<String> subNames = Util.skipLast(names);
hints.addAll(catalogReader.getAllSchemaObjectNames(subNames));
// If the name has length 0, try prepending the name of the default
// schema. So, the empty name would yield a list of tables in the
// default schema, as well as a list of schemas from the above code.
if (subNames.size() == 0) {
hints.addAll(
catalogReader.getAllSchemaObjectNames(
Collections.singletonList(catalogReader.getSchemaName())));
}
}
/**
* Returns whether a given tree contains any {@link org.eigenbase.rex.RexFieldAccess} nodes.
*
* @param node a RexNode tree
*/
public static boolean containsFieldAccess(RexNode node) {
try {
RexVisitor<Void> visitor =
new RexVisitorImpl<Void>(true) {
public Void visitFieldAccess(RexFieldAccess fieldAccess) {
throw new Util.FoundOne(fieldAccess);
}
};
node.accept(visitor);
return false;
} catch (Util.FoundOne e) {
Util.swallow(e, null);
return true;
}
}
/**
* Variant of {@link #trimFields(RelNode, BitSet, Set)} for {@link org.eigenbase.rel.ValuesRel}.
*/
public TrimResult trimFields(
ValuesRel values, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
final RelDataType rowType = values.getRowType();
final int fieldCount = rowType.getFieldCount();
// If they are asking for no fields, we can't give them what they want,
// because zero-column records are illegal. Give them the last field,
// which is unlikely to be a system field.
if (fieldsUsed.isEmpty()) {
fieldsUsed = Util.bitSetBetween(fieldCount - 1, fieldCount);
}
// If all fields are used, return unchanged.
if (fieldsUsed.equals(Util.bitSetBetween(0, fieldCount))) {
Mapping mapping = Mappings.createIdentity(fieldCount);
return new TrimResult(values, mapping);
}
List<List<RexLiteral>> newTuples = new ArrayList<List<RexLiteral>>();
for (List<RexLiteral> tuple : values.getTuples()) {
List<RexLiteral> newTuple = new ArrayList<RexLiteral>();
for (int field : Util.toIter(fieldsUsed)) {
newTuple.add(tuple.get(field));
}
newTuples.add(newTuple);
}
final Mapping mapping = createMapping(fieldsUsed, fieldCount);
RelDataType newRowType =
values
.getCluster()
.getTypeFactory()
.createStructType(Mappings.apply3(mapping, rowType.getFieldList()));
final ValuesRel newValues = new ValuesRel(values.getCluster(), newRowType, newTuples);
return new TrimResult(newValues, mapping);
}
/**
* Returns whether an array of expressions contains a forward reference. That is, if expression #i
* contains a {@link RexInputRef} referencing field i or greater.
*
* @param exprs Array of expressions
* @param inputRowType Input row type
* @param fail Whether to assert if there is a forward reference
* @return Whether there is a forward reference
*/
public static boolean containForwardRefs(
RexNode[] exprs, RelDataType inputRowType, boolean fail) {
final ForwardRefFinder visitor = new ForwardRefFinder(inputRowType);
for (int i = 0; i < exprs.length; i++) {
RexNode expr = exprs[i];
visitor.setLimit(i); // field cannot refer to self or later field
try {
expr.accept(visitor);
} catch (ForwardRefFinder.IllegalForwardRefException e) {
Util.swallow(e, null);
assert !fail : "illegal forward reference in " + expr;
return true;
}
}
return false;
}
// implement SargExpr
public SargIntervalSequence evaluate() {
if (setOp == SargSetOperator.COMPLEMENT) {
assert (children.size() == 1);
SargExpr child = children.get(0);
return child.evaluateComplemented();
}
List<SargIntervalSequence> list = evaluateChildren(this);
switch (setOp) {
case UNION:
return evaluateUnion(list);
case INTERSECTION:
return evaluateIntersection(list);
default:
throw Util.newInternal(setOp.toString());
}
}
/**
* Returns whether a given node contains a RexCall with a specified operator
*
* @param operator to look for
* @param node a RexNode tree
*/
public static RexCall findOperatorCall(final SqlOperator operator, RexNode node) {
try {
RexVisitor<Void> visitor =
new RexVisitorImpl<Void>(true) {
public Void visitCall(RexCall call) {
if (call.getOperator().equals(operator)) {
throw new Util.FoundOne(call);
}
return super.visitCall(call);
}
};
node.accept(visitor);
return null;
} catch (Util.FoundOne e) {
Util.swallow(e, null);
return (RexCall) e.getNode();
}
}
// implement SargExpr
public SargIntervalSequence evaluateComplemented() {
if (setOp == SargSetOperator.COMPLEMENT) {
// Double negation is a nop
return children.get(0).evaluate();
}
// Use DeMorgan's Law: complement of union is intersection of
// complements, and vice versa
List<SargIntervalSequence> list = new ArrayList<SargIntervalSequence>();
for (SargExpr child : children) {
SargIntervalSequence newSeq = child.evaluateComplemented();
list.add(newSeq);
}
switch (setOp) {
case INTERSECTION:
return evaluateUnion(list);
case UNION:
return evaluateIntersection(list);
default:
throw Util.newInternal(setOp.toString());
}
}
/**
* Derives an alias for a node, and invents a mangled identifier if it cannot.
*
* <p>Examples:
*
* <ul>
* <li>Alias: "1 + 2 as foo" yields "foo"
* <li>Identifier: "foo.bar.baz" yields "baz"
* <li>Anything else yields "expr$<i>ordinal</i>"
* </ul>
*
* @return An alias, if one can be derived; or a synthetic alias "expr$<i>ordinal</i>" if ordinal
* >= 0; otherwise null
*/
public static String getAlias(SqlNode node, int ordinal) {
switch (node.getKind()) {
case AS:
// E.g. "1 + 2 as foo" --> "foo"
return ((SqlCall) node).getOperands()[1].toString();
case OVER:
// E.g. "bids over w" --> "bids"
return getAlias(((SqlCall) node).getOperands()[0], ordinal);
case IDENTIFIER:
// E.g. "foo.bar" --> "bar"
return Util.last(((SqlIdentifier) node).names);
default:
if (ordinal < 0) {
return null;
} else {
return SqlUtil.deriveAliasFromOrdinal(ordinal);
}
}
}
SubExprExistsException(RexNode expr) {
Util.discard(expr);
}
/** Variant of {@link #trimFields(RelNode, BitSet, Set)} for {@link AggregateRel}. */
public TrimResult trimFields(
AggregateRel aggregate, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
// Fields:
//
// | sys fields | group fields | agg functions |
//
// Two kinds of trimming:
//
// 1. If agg rel has system fields but none of these are used, create an
// agg rel with no system fields.
//
// 2. If aggregate functions are not used, remove them.
//
// But grouping fields stay, even if they are not used.
final RelDataType rowType = aggregate.getRowType();
// Compute which input fields are used.
BitSet inputFieldsUsed = new BitSet();
// 1. group fields are always used
for (int i : Util.toIter(aggregate.getGroupSet())) {
inputFieldsUsed.set(i);
}
// 2. agg functions
for (AggregateCall aggCall : aggregate.getAggCallList()) {
for (int i : aggCall.getArgList()) {
inputFieldsUsed.set(i);
}
}
// Create input with trimmed columns.
final RelNode input = aggregate.getInput(0);
final Set<RelDataTypeField> inputExtraFields = Collections.emptySet();
final TrimResult trimResult = trimChild(aggregate, input, inputFieldsUsed, inputExtraFields);
final RelNode newInput = trimResult.left;
final Mapping inputMapping = trimResult.right;
// If the input is unchanged, and we need to project all columns,
// there's nothing to do.
if (input == newInput && fieldsUsed.equals(Util.bitSetBetween(0, rowType.getFieldCount()))) {
return new TrimResult(aggregate, Mappings.createIdentity(rowType.getFieldCount()));
}
// Which agg calls are used by our consumer?
final int groupCount = aggregate.getGroupSet().cardinality();
int j = groupCount;
int usedAggCallCount = 0;
for (int i = 0; i < aggregate.getAggCallList().size(); i++) {
if (fieldsUsed.get(j++)) {
++usedAggCallCount;
}
}
// Offset due to the number of system fields having changed.
Mapping mapping =
Mappings.create(
MappingType.InverseSurjection, rowType.getFieldCount(), groupCount + usedAggCallCount);
final BitSet newGroupSet = Mappings.apply(inputMapping, aggregate.getGroupSet());
// Populate mapping of where to find the fields. System and grouping
// fields first.
for (IntPair pair : inputMapping) {
if (pair.source < groupCount) {
mapping.set(pair.source, pair.target);
}
}
// Now create new agg calls, and populate mapping for them.
final List<AggregateCall> newAggCallList = new ArrayList<AggregateCall>();
j = groupCount;
for (AggregateCall aggCall : aggregate.getAggCallList()) {
if (fieldsUsed.get(j)) {
AggregateCall newAggCall =
new AggregateCall(
aggCall.getAggregation(),
aggCall.isDistinct(),
Mappings.apply2(inputMapping, aggCall.getArgList()),
aggCall.getType(),
aggCall.getName());
if (newAggCall.equals(aggCall)) {
newAggCall = aggCall; // immutable -> canonize to save space
}
mapping.set(j, groupCount + newAggCallList.size());
newAggCallList.add(newAggCall);
}
++j;
}
RelNode newAggregate =
new AggregateRel(aggregate.getCluster(), newInput, newGroupSet, newAggCallList);
assert newAggregate.getClass() == aggregate.getClass();
return new TrimResult(newAggregate, mapping);
}
/**
* Creates a RelFieldTrimmer.
*
* @param validator Validator
*/
public RelFieldTrimmer(SqlValidator validator) {
Util.discard(validator); // may be useful one day
this.trimFieldsDispatcher =
ReflectUtil.createMethodDispatcher(
TrimResult.class, this, "trimFields", RelNode.class, BitSet.class, Set.class);
}
public String apply(String original, int attempt, int size) {
return Util.first(original, "EXPR$") + attempt;
}
public String apply(String original, int attempt, int size) {
return Util.first(original, "$f") + size;
}