public Boolean areColumnsUnique(ProjectRelBase rel, BitSet columns, boolean ignoreNulls) { // ProjectRel maps a set of rows to a different set; // Without knowledge of the mapping function(whether it // preserves uniqueness), it is only safe to derive uniqueness // info from the child of a project when the mapping is f(a) => a. // // Also need to map the input column set to the corresponding child // references List<RexNode> projExprs = rel.getProjects(); BitSet childColumns = new BitSet(); for (int bit : BitSets.toIter(columns)) { RexNode projExpr = projExprs.get(bit); if (projExpr instanceof RexInputRef) { childColumns.set(((RexInputRef) projExpr).getIndex()); } else if (projExpr instanceof RexCall && ignoreNulls) { // If the expression is a cast such that the types are the same // except for the nullability, then if we're ignoring nulls, // it doesn't matter whether the underlying column reference // is nullable. Check that the types are the same by making a // nullable copy of both types and then comparing them. RexCall call = (RexCall) projExpr; if (call.getOperator() != SqlStdOperatorTable.CAST) { continue; } RexNode castOperand = call.getOperands().get(0); if (!(castOperand instanceof RexInputRef)) { continue; } RelDataTypeFactory typeFactory = rel.getCluster().getTypeFactory(); RelDataType castType = typeFactory.createTypeWithNullability(projExpr.getType(), true); RelDataType origType = typeFactory.createTypeWithNullability(castOperand.getType(), true); if (castType.equals(origType)) { childColumns.set(((RexInputRef) castOperand).getIndex()); } } else { // If the expression will not influence uniqueness of the // projection, then skip it. continue; } } // If no columns can affect uniqueness, then return unknown if (childColumns.cardinality() == 0) { return null; } return RelMetadataQuery.areColumnsUnique(rel.getChild(), childColumns, ignoreNulls); }
/** * Creates a key for {@link RexNode} which is the same as another key of another RexNode only if * the two have both the same type and textual representation. For example, "10" integer and "10" * bigint result in different keys. */ public static String makeKey(RexNode expr) { String type = expr.getType().getFullTypeString(); String separator = ";"; String node = expr.toString(); StringBuilder keyBuilder = new StringBuilder(type.length() + separator.length() + node.length()); keyBuilder.append(type).append(separator).append(node); return keyBuilder.toString(); }
/** * Determines if a projection is simple. * * @param calcRel CalcRel containing the projection * @param projOrdinals if the projection is simple, returns the ordinals of the projection inputs * @return rowtype corresponding to the projection, provided it is simple; otherwise null is * returned */ private RelDataType isProjectSimple(CalcRel calcRel, List<Integer> projOrdinals) { // Loop through projection expressions. If we find a non-simple // projection expression, simply return. RexProgram program = calcRel.getProgram(); List<RexLocalRef> projList = program.getProjectList(); int nProjExprs = projList.size(); RelDataType[] types = new RelDataType[nProjExprs]; String[] fieldNames = new String[nProjExprs]; RelDataTypeField[] projFields = calcRel.getRowType().getFields(); for (int i = 0; i < nProjExprs; i++) { RexNode projExpr = program.expandLocalRef(projList.get(i)); if (projExpr instanceof RexInputRef) { projOrdinals.add(((RexInputRef) projExpr).getIndex()); types[i] = projExpr.getType(); fieldNames[i] = projFields[i].getName(); continue; } else if (!(projExpr instanceof RexCall)) { return null; } RexCall rexCall = (RexCall) projExpr; if (rexCall.getOperator() != SqlStdOperatorTable.castFunc) { return null; } RexNode castOperand = rexCall.getOperands()[0]; if (!(castOperand instanceof RexInputRef)) { return null; } RelDataType castType = projExpr.getType(); RelDataType origType = castOperand.getType(); if (isCastSimple(origType, castType)) { projOrdinals.add(((RexInputRef) castOperand).getIndex()); types[i] = castType; fieldNames[i] = projFields[i].getName(); } else { return null; } } // return the rowtype corresponding to the output of the projection return calcRel.getCluster().getTypeFactory().createStructType(types, fieldNames); }
// 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); } } } }