public Void visitInputRef(RexInputRef inputRef) {
super.visitInputRef(inputRef);
if (inputRef.getIndex() >= inputRowType.getFieldCount()) {
throw new IllegalForwardRefException();
}
return null;
}
public Void visitLocalRef(RexLocalRef inputRef) {
super.visitLocalRef(inputRef);
if (inputRef.getIndex() >= limit) {
throw new IllegalForwardRefException();
}
return null;
}
private void analyzeCall(RexCall call, Constancy callConstancy) {
parentCallTypeStack.add(call.getOperator());
// visit operands, pushing their states onto stack
super.visitCall(call);
// look for NON_CONSTANT operands
int nOperands = call.getOperands().length;
List<Constancy> operandStack = stack.subList(stack.size() - nOperands, stack.size());
for (Constancy operandConstancy : operandStack) {
if (operandConstancy == Constancy.NON_CONSTANT) {
callConstancy = Constancy.NON_CONSTANT;
}
}
// Even if all operands are constant, the call itself may
// be non-deterministic.
if (!call.getOperator().isDeterministic()) {
callConstancy = Constancy.NON_CONSTANT;
} else if (call.getOperator().isDynamicFunction()) {
// We can reduce the call to a constant, but we can't
// cache the plan if the function is dynamic
preparingStmt.disableStatementCaching();
}
// Row operator itself can't be reduced to a literal, but if
// the operands are constants, we still want to reduce those
if ((callConstancy == Constancy.REDUCIBLE_CONSTANT)
&& (call.getOperator() instanceof SqlRowOperator)) {
callConstancy = Constancy.NON_CONSTANT;
}
if (callConstancy == Constancy.NON_CONSTANT) {
// any REDUCIBLE_CONSTANT children are now known to be maximal
// reducible subtrees, so they can be added to the result
// list
for (int iOperand = 0; iOperand < nOperands; ++iOperand) {
Constancy constancy = operandStack.get(iOperand);
if (constancy == Constancy.REDUCIBLE_CONSTANT) {
addResult(call.getOperands()[iOperand]);
}
}
// if this cast expression can't be reduced to a literal,
// then see if we can remove the cast
if (call.getOperator() == SqlStdOperatorTable.castFunc) {
reduceCasts(call);
}
}
// pop operands off of the stack
operandStack.clear();
// pop this parent call operator off the stack
parentCallTypeStack.remove(parentCallTypeStack.size() - 1);
// push constancy result for this call onto stack
stack.add(callConstancy);
}