case AND: operands = Lists.newArrayList(RexUtil.flattenAnd(call.getOperands())); for (int i = 0; i < operands.size(); i++) { RexNode operand = operands.get(i); newOperands.addAll(operands); node = RexUtil.composeConjunction(rexBuilder, newOperands, false); break; case OR: operands = Lists.newArrayList(RexUtil.flattenOr(call.getOperands())); for (int i = 0; i < operands.size(); i++) { RexNode operand = operands.get(i); newOperands.addAll(operands); node = RexUtil.composeDisjunction(rexBuilder, newOperands, false); break; default:
RexNode newCondition = RexUtil.flatten(rexBuilder, RexUtil.composeConjunction(rexBuilder, newJoinCondition, false)); List<RelNode> newInputsArray = Lists.newArrayList(newInputs); JoinPredicateInfo joinPredInfo = null;
/** Equivalent to * {@link RelOptUtil#createProject(org.apache.calcite.rel.RelNode, java.util.List, java.util.List)} * for {@link MutableRel}. */ public static MutableRel of(MutableRel child, List<RexNode> exprList, List<String> fieldNameList) { final RelDataType rowType = RexUtil.createStructType(child.cluster.getTypeFactory(), exprList, fieldNameList, SqlValidatorUtil.F_SUGGESTER); return of(rowType, child, exprList); }
private static RexNode splitOr( final RexBuilder rexBuilder, RexNode condition, RexNode target) { List<RexNode> targets = RelOptUtil.disjunctions(target); for (RexNode e : RelOptUtil.disjunctions(condition)) { boolean found = removeAll(targets, e); if (!found) { return null; } } return RexUtil.composeConjunction(rexBuilder, Lists.transform(targets, RexUtil.notFn(rexBuilder)), false); }
finalResidualPreds.add(RexUtil.composeConjunction(rB, residualPreds, false)); finalResidualPreds.set(j, RexUtil.composeConjunction(rB, Lists.newArrayList( finalResidualPreds.get(j), e.getValue()), false)); RexNode disjPred = RexUtil.composeDisjunction(rB, finalResidualPreds, false); if (!disjPred.isAlwaysTrue()) { preds.add(disjPred);
ImmutableList<RexNode> operands = RexUtil.flattenOr(((RexCall) condition).getOperands()); for (int i = 0; i < operands.size(); i++) { final RexNode operand = operands.get(i); final RexNode operandCNF = RexUtil.toCnf(rexBuilder, maxCNFNodeCount, operand); final List<RexNode> conjunctions = RelOptUtil.conjunctions(operandCNF); for (String ref : refsInAllOperands) { commonOperands .add(RexUtil.composeDisjunction(rexBuilder, reductionCondition.get(ref), false));
RexNode compose(RexBuilder rexBuilder, Iterable<RexNode> exprs) { exprs = Linq4j.asEnumerable(exprs).where(new Predicate1<RexNode>() { public boolean apply(RexNode expr) { return expr != null; } }); return RexUtil.composeConjunction(rexBuilder, exprs, false); }
/** Creates an OR. */ public RexNode or(Iterable<? extends RexNode> operands) { return RexUtil.composeDisjunction(cluster.getRexBuilder(), operands, false); }
@Override public Double visitLiteral(RexLiteral literal) { if (literal.isAlwaysFalse() || RexUtil.isNull(literal)) { return 0.0; } else if (literal.isAlwaysTrue()) { return 1.0; } else { assert false; } return null; } }
@Override public RelBuilder filter(Iterable<? extends RexNode> predicates) { final RexNode x = RexUtil.simplify(cluster.getRexBuilder(), RexUtil.composeConjunction(cluster.getRexBuilder(), predicates, false)); if (!x.isAlwaysTrue()) { final RelNode input = build(); final RelNode filter = HiveRelFactories.HIVE_FILTER_FACTORY.createFilter(input, x); return this.push(filter); } return this; }
private static boolean isTrivial(Project project, Intersect intersect) { return RexUtil.isIdentity(project.getProjects(), intersect.getRowType()); }
final List<RexNode> predList = RelOptUtil.conjunctions(RexUtil.toCnf(filter.getCluster().getRexBuilder(), condition)); final RexNode qualifiedPred = RexUtil.composeConjunction(filter.getCluster().getRexBuilder(), qualifiedPredList, true); RexUtil.composeConjunction( filter.getCluster().getRexBuilder(), nonConvertedPredList, RexUtil.composeConjunction( filter.getCluster().getRexBuilder(), nonConvertedPredList,
whereFilter.getTraitSet(), whereFilter.getInput(), RexUtil.flatten( getCluster().getRexBuilder(), makeAnd(ImmutableList.of(whereFilter.getCondition(), makeOr(conditions)))
@Test public void testCBOMaxNumToCNF1() { // OR(=($0, 1), AND(=($0, 0), =($1, 8))) // transformation creates 7 nodes AND(OR(=($0, 1), =($0, 0)), OR(=($0, 1), =($1, 8))) // thus, it is triggered final RelDataTypeFactory typeFactory = new JavaTypeFactoryImpl(); final RexBuilder rexBuilder = new RexBuilder(typeFactory); final RexNode cond = rexBuilder.makeCall(SqlStdOperatorTable.OR, rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, rexBuilder.makeInputRef(typeFactory.createSqlType(SqlTypeName.INTEGER), 0), rexBuilder.makeLiteral(1, typeFactory.createSqlType(SqlTypeName.INTEGER), false)), rexBuilder.makeCall(SqlStdOperatorTable.AND, rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, rexBuilder.makeInputRef(typeFactory.createSqlType(SqlTypeName.INTEGER), 0), rexBuilder.makeLiteral(0, typeFactory.createSqlType(SqlTypeName.INTEGER), false)), rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, rexBuilder.makeInputRef(typeFactory.createSqlType(SqlTypeName.INTEGER), 1), rexBuilder.makeLiteral(8, typeFactory.createSqlType(SqlTypeName.INTEGER), false)))); final RexNode newCond = RexUtil.toCnf(rexBuilder, maxNumNodesCNF, cond); assertEquals(newCond.toString(), "AND(OR(=($0, 1), =($0, 0)), OR(=($0, 1), =($1, 8)))"); }
if (!force && RexUtil.isIdentity(exprList, inputRowType)) { if (names.equals(inputRowType.getFieldNames())) { RexUtil.createStructType(cluster.getTypeFactory(), exprList, names, SqlValidatorUtil.F_SUGGESTER); stack.push(
/** * Returns whether every expression in a list is a literal. * * @param expressionOperands list of expressions to check * @return true if every expression from the specified list is literal. */ public static boolean allLiterals(List<RexNode> expressionOperands) { for (RexNode rexNode : expressionOperands) { if (!isLiteral(rexNode, true)) { return false; } } return true; }
topChildExprs = ImmutableList.copyOf(RexUtil.apply(mapping, topChildExprs));
/** Flattens an expression. * * <p>Returns the same expression if it is already flat. */ public static RexNode flatten(RexBuilder rexBuilder, RexNode node) { if (node instanceof RexCall) { RexCall call = (RexCall) node; final SqlOperator op = call.getOperator(); final List<RexNode> flattenedOperands = flatten(call.getOperands(), op); if (!isFlat(call.getOperands(), op)) { return rexBuilder.makeCall(call.getType(), op, flattenedOperands); } } return node; }
case LESS_THAN_OR_EQUAL: case GREATER_THAN_OR_EQUAL: if (rexBuilder != null && RexUtil.isReferenceOrAccess(call.operands.get(1), true) && RexUtil.isLiteral(call.operands.get(0), true)) { return visitCall((RexCall) RexUtil.invert(rexBuilder, call)); } else { for (RexNode operand : call.operands) {
} else if (RexUtil.isReferenceOrAccess(childRexNodeLst.get(0), true)) { RexCall call = (RexCall) expr; expr = cluster.getRexBuilder().makeCall(retType, call.getOperator(), RexUtil.flatten(call.getOperands(), call.getOperator()));