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); }
private void reduceCasts(RexCall outerCast) { RexNode[] operands = outerCast.getOperands(); if (operands.length != 1) { return; } RelDataType outerCastType = outerCast.getType(); RelDataType operandType = operands[0].getType(); if (operandType.equals(outerCastType)) { removableCasts.add(outerCast); return; } // See if the reduction // CAST((CAST x AS type) AS type NOT NULL) // -> CAST(x AS type NOT NULL) // applies. TODO jvs 15-Dec-2008: consider // similar cases for precision changes. if (!(operands[0] instanceof RexCall)) { return; } RexCall innerCast = (RexCall) operands[0]; if (innerCast.getOperator() != SqlStdOperatorTable.castFunc) { return; } if (innerCast.getOperands().length != 1) { return; } RelDataTypeFactory typeFactory = preparingStmt.getFarragoTypeFactory(); RelDataType outerTypeNullable = typeFactory.createTypeWithNullability(outerCastType, true); RelDataType innerTypeNullable = typeFactory.createTypeWithNullability(operandType, true); if (outerTypeNullable != innerTypeNullable) { return; } if (operandType.isNullable()) { removableCasts.add(innerCast); } }
static FarragoSession getSession(RelNode rel) { FarragoSessionPlanner planner = (FarragoSessionPlanner) rel.getCluster().getPlanner(); FarragoSessionPreparingStmt preparingStmt = planner.getPreparingStmt(); return preparingStmt.getSession(); }
/** * Reduces a list of expressions. * * @param rel Relational expression * @param expList List of expressions, modified in place * @return whether reduction found something to change, and succeeded */ static boolean reduceExpressions(RelNode rel, List<RexNode> expList) { RexBuilder rexBuilder = rel.getCluster().getRexBuilder(); // Find reducible expressions. FarragoSessionPlanner planner = (FarragoSessionPlanner) rel.getCluster().getPlanner(); FarragoSessionPreparingStmt preparingStmt = planner.getPreparingStmt(); List<RexNode> constExps = new ArrayList<RexNode>(); List<Boolean> addCasts = new ArrayList<Boolean>(); List<RexNode> removableCasts = new ArrayList<RexNode>(); findReducibleExps(preparingStmt, expList, constExps, addCasts, removableCasts); if (constExps.isEmpty() && removableCasts.isEmpty()) { return false; } // Remove redundant casts before reducing constant expressions. // If the argument to the redundant cast is a reducible constant, // reducing that argument to a constant first will result in not being // able to locate the original cast expression. if (!removableCasts.isEmpty()) { List<RexNode> reducedExprs = new ArrayList<RexNode>(); List<Boolean> noCasts = new ArrayList<Boolean>(); for (RexNode exp : removableCasts) { RexCall call = (RexCall) exp; reducedExprs.add(call.getOperands()[0]); noCasts.add(false); } RexReplacer replacer = new RexReplacer(rexBuilder, removableCasts, reducedExprs, noCasts); replacer.apply(expList); } if (constExps.isEmpty()) { return true; } // Compute the values they reduce to. List<RexNode> reducedValues = new ArrayList<RexNode>(); ReentrantValuesStmt reentrantStmt = new ReentrantValuesStmt( preparingStmt.getRootStmtContext(), rexBuilder, constExps, reducedValues); FarragoSession session = getSession(rel); reentrantStmt.execute(session, true); if (reentrantStmt.failed) { return false; } // For ProjectRel, we have to be sure to preserve the result // types, so always cast regardless of the expression type. // For other RelNodes like FilterRel, in general, this isn't necessary, // and the presence of casts could hinder other rules such as sarg // analysis, which require bare literals. But there are special cases, // like when the expression is a UDR argument, that need to be // handled as special cases. if (rel instanceof ProjectRel) { for (int i = 0; i < reducedValues.size(); i++) { addCasts.set(i, true); } } RexReplacer replacer = new RexReplacer(rexBuilder, constExps, reducedValues, addCasts); replacer.apply(expList); return true; }