// override RexShuttle
public RexNode visitCall(final RexCall call) {
int i = reducibleExps.indexOf(call);
if (i == -1) {
return super.visitCall(call);
}
RexNode replacement = reducedValues.get(i);
if (addCasts.get(i) && (replacement.getType() != call.getType())) {
// Handle change from nullable to NOT NULL by claiming
// that the result is still nullable, even though
// we know it isn't.
//
// Also, we cannot reduce CAST('abc' AS VARCHAR(4)) to 'abc'.
// If we make 'abc' of type VARCHAR(4), we may later encounter
// the same expression in a ProjectRel's digest where it has
// type VARCHAR(3), and that's wrong.
replacement = rexBuilder.makeCast(call.getType(), replacement);
}
return replacement;
}
protected void executeImpl() throws Exception {
SqlCall call = (SqlCall) subq;
SqlSelect select = (SqlSelect) call.getOperands()[0];
// Convert the SqlNode tree to a RelNode tree; we need to do this
// here so the RelNode tree is associated with the new preparing
// stmt.
FarragoPreparingStmt preparingStmt = (FarragoPreparingStmt) getPreparingStmt();
SqlValidator validator = preparingStmt.getSqlValidator();
SqlToRelConverter sqlConverter = preparingStmt.getSqlToRelConverter(validator, preparingStmt);
preparingStmt.setParentStmt(FennelRelUtil.getPreparingStmt(parentConverter.getCluster()));
// Add to the new converter any subqueries that have already been
// converted by the parent so we can avoid re-executing them
sqlConverter.addConvertedNonCorrSubqs(parentConverter.getMapConvertedNonCorrSubqs());
RelNode plan = sqlConverter.convertQuery(select, true, true);
// The subquery cannot have dynamic parameters
if (sqlConverter.getDynamicParamCount() > 0) {
failed = true;
return;
}
List<RexNode> exprs = new ArrayList<RexNode>();
RelDataType resultType = null;
if (!isExists) {
// Non-EXISTS subqueries need to be converted to single-value
// subqueries
plan = sqlConverter.convertToSingleValueSubq(select, plan);
// Create a dummy expression to store the type of the result.
// When setting the type, derive the type based on what a
// scalar subquery should return and create the type from the
// type factory of the parent query.
resultType = call.getOperator().deriveType(validator, validator.getFromScope(select), call);
resultType = rexBuilder.getTypeFactory().copyType(resultType);
exprs.add(rexBuilder.makeInputRef(resultType, 0));
}
plan = sqlConverter.decorrelate(select, plan);
// If the subquery is part of an EXPLAIN PLAN statement, don't
// execute the subquery, but instead just return a dynamic parameter
// as a placeholder for the subquery result. Otherwise, execute
// the query to produce the constant expression. Cast the expression
// as needed so the type matches the expected result type.
RexNode constExpr;
if (isExplain) {
if (isExists) {
resultType = rexBuilder.getTypeFactory().createSqlType(SqlTypeName.BOOLEAN);
}
constExpr =
rexBuilder.makeDynamicParam(
resultType, parentConverter.getDynamicParamCountInExplain(true));
results.add(constExpr);
} else {
executePlan(plan, exprs, isExists, false);
if (!failed && !isExists) {
constExpr = results.get(0);
if (constExpr.getType() != resultType) {
constExpr = rexBuilder.makeCast(resultType, constExpr);
results.set(0, constExpr);
}
}
}
}