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); }
} else if (condition.getKind() == SqlKind.OR) { boolean first = true; for(RexNode pred : RelOptUtil.disjunctions(condition)) { if (first) { sb.append(convertRexToString(pred, rowType));
private boolean addBaseConditions(RexNode condition, StatisticsPayload payload, boolean redundant, Map<String, Double> baseConditionMap, RelDataType rowType) { boolean res = redundant; if (condition.getKind() == SqlKind.AND) { for(RexNode pred : RelOptUtil.conjunctions(condition)) { res = addBaseConditions(pred, payload, res, baseConditionMap, rowType); } } else if (condition.getKind() == SqlKind.OR) { for(RexNode pred : RelOptUtil.disjunctions(condition)) { res = addBaseConditions(pred, payload, res, baseConditionMap, rowType); } } else { // base condition String conditionAsStr = convertRexToString(condition, rowType); if (!redundant) { baseConditionMap.put(conditionAsStr, payload.getRowCount()); return true; } else { baseConditionMap.put(conditionAsStr, -1.0); return false; } } return res; } /*
for (RexNode pred : RelOptUtil.disjunctions(condition)) { Pair<Double, Boolean> selPayload = computeSelectivity(pred, idx, totalRows, scanRel, baseConditionMap); if (selPayload.left > 0.0) {
private RexNode convertToStatsCondition(RexNode condition, IndexDescriptor index, IndexCallContext context, RelNode scanRel, List<SqlKind>typesToProcess) { RexBuilder builder = scanRel.getCluster().getRexBuilder(); if (condition.getKind() == SqlKind.AND) { final List<RexNode> conditions = Lists.newArrayList(); for(RexNode pred : RelOptUtil.conjunctions(condition)) { conditions.add(convertToStatsCondition(pred, index, context, scanRel, typesToProcess)); } return RexUtil.composeConjunction(builder, conditions, false); } else if (condition.getKind() == SqlKind.OR) { final List<RexNode> conditions = Lists.newArrayList(); for(RexNode pred : RelOptUtil.disjunctions(condition)) { conditions.add(convertToStatsCondition(pred, index, context, scanRel, typesToProcess)); } return RexUtil.composeDisjunction(builder, conditions, false); } else if (condition instanceof RexCall) { // LIKE operator - convert to a RANGE predicate, if possible if (typesToProcess.contains(SqlKind.LIKE) && ((RexCall) condition).getOperator().getKind() == SqlKind.LIKE) { return convertLikeToRange((RexCall)condition, builder); } else if (typesToProcess.contains(SqlKind.CAST) && hasCastExpression(condition)) { return convertCastForFIdx(((RexCall) condition), index, context, scanRel); } else { return condition; } } return condition; }
private static RexNode splitOr( final RexBuilder rexBuilder, RexNode condition, RexNode target) { List<RexNode> conditions = RelOptUtil.disjunctions(condition); int conditionsLength = conditions.size(); int targetsLength = 0; for (RexNode e : RelOptUtil.disjunctions(target)) { removeAll(conditions, e); targetsLength++; } if (conditions.isEmpty() && conditionsLength == targetsLength) { return rexBuilder.makeLiteral(true); } else if (conditions.isEmpty()) { return condition; } return null; }
private static RexNode splitOr( final RexBuilder rexBuilder, RexNode condition, RexNode target) { List<RexNode> conditions = RelOptUtil.disjunctions(condition); int conditionsLength = conditions.size(); int targetsLength = 0; for (RexNode e : RelOptUtil.disjunctions(target)) { removeAll(conditions, e); targetsLength++; } if (conditions.isEmpty() && conditionsLength == targetsLength) { return rexBuilder.makeLiteral(true); } else if (conditions.isEmpty()) { return condition; } return null; }
private Object translateOr(RexNode condition) { final List<Object> list = new ArrayList<>(); final List<RexNode> orNodes = RelOptUtil.disjunctions(condition); for (RexNode node : orNodes) { List<Map<String, Object>> andNodes = translateAnd(node); if (andNodes.size() > 0) { Map<String, Object> andClause = new HashMap<>(); andClause.put("must", andNodes); // boolean filters LinkedHashMap<String, Object> filterEvaluator = new LinkedHashMap<>(); filterEvaluator.put("bool", andClause); list.add(filterEvaluator); } else { list.add(andNodes.get(0)); } } if (orNodes.size() > 1) { Map<String, Object> map = builder.map(); map.put("should", list); // boolean filters LinkedHashMap<String, Object> filterEvaluator = new LinkedHashMap<>(); filterEvaluator.put("bool", map); return filterEvaluator; } else { return list.get(0); } }
private GraphTraversal translateOr(RexNode condition) { List<GraphTraversal> list = new ArrayList<>(); for (RexNode node : RelOptUtil.disjunctions(condition)) { list.addAll(translateAnd(node)); } switch (list.size()) { case 1: return list.get(0); default: Map<String, Object> map = builder.map(); map.put("$or", list); return __.__().or(list.toArray(new GraphTraversal[list.size()])); } }
private RexNode simplifyOr(RexCall call, RexUnknownAs unknownAs) { assert call.getKind() == SqlKind.OR; final List<RexNode> terms = RelOptUtil.disjunctions(call); if (predicateElimination) { simplifyOrTerms(terms); } return simplifyOrs(terms, unknownAs); }
private RexNode simplifyOr(RexCall call, RexUnknownAs unknownAs) { assert call.getKind() == SqlKind.OR; final List<RexNode> terms = RelOptUtil.disjunctions(call); if (predicateElimination) { simplifyOrTerms(terms); } return simplifyOrs(terms, unknownAs); }
} else if (condition.getKind() == SqlKind.OR) { boolean first = true; for(RexNode pred : RelOptUtil.disjunctions(condition)) { if (first) { sb.append(convertRexToString(pred, rowType));
private boolean addBaseConditions(RexNode condition, StatisticsPayload payload, boolean redundant, Map<String, Double> baseConditionMap, RelDataType rowType) { boolean res = redundant; if (condition.getKind() == SqlKind.AND) { for(RexNode pred : RelOptUtil.conjunctions(condition)) { res = addBaseConditions(pred, payload, res, baseConditionMap, rowType); } } else if (condition.getKind() == SqlKind.OR) { for(RexNode pred : RelOptUtil.disjunctions(condition)) { res = addBaseConditions(pred, payload, res, baseConditionMap, rowType); } } else { // base condition String conditionAsStr = convertRexToString(condition, rowType); if (!redundant) { baseConditionMap.put(conditionAsStr, payload.getRowCount()); return true; } else { baseConditionMap.put(conditionAsStr, -1.0); return false; } } return res; } /*
@Override public RexNode visitCall(RexCall call) { SqlOperator op = call.getOperator(); SqlKind kind = op.getKind(); RelDataType type = call.getType(); if (kind == SqlKind.AND) { List<RexNode> conjuncts = Lists.newArrayList(); for (RexNode child : call.getOperands()) { conjuncts.addAll(RelOptUtil.conjunctions(child.accept(this))); } return RexUtil.composeConjunction(builder, conjuncts, true); } if (kind == SqlKind.OR) { List<RexNode> disjuncts = Lists.newArrayList(); for (RexNode child : call.getOperands()) { disjuncts.addAll(RelOptUtil.disjunctions(child.accept(this))); } return RexUtil.composeDisjunction(builder, disjuncts, true); } return builder.makeCall(type, op, visitChildren(call)); }
final RexNode head = operands.get(0); final RexNode headDnf = toDnf(head); final List<RexNode> headDnfs = RelOptUtil.disjunctions(headDnf); final RexNode tail = and(Util.skip(operands)); final RexNode tailDnf = toDnf(tail); final List<RexNode> tailDnfs = RelOptUtil.disjunctions(tailDnf); final List<RexNode> list = new ArrayList<>(); for (RexNode h : headDnfs) {
final RexNode head = operands.get(0); final RexNode headDnf = toDnf(head); final List<RexNode> headDnfs = RelOptUtil.disjunctions(headDnf); final RexNode tail = and(Util.skip(operands)); final RexNode tailDnf = toDnf(tail); final List<RexNode> tailDnfs = RelOptUtil.disjunctions(tailDnf); final List<RexNode> list = new ArrayList<>(); for (RexNode h : headDnfs) {
private RexNode convertToStatsCondition(RexNode condition, IndexDescriptor index, IndexCallContext context, RelNode scanRel, List<SqlKind>typesToProcess) { RexBuilder builder = scanRel.getCluster().getRexBuilder(); if (condition.getKind() == SqlKind.AND) { final List<RexNode> conditions = Lists.newArrayList(); for(RexNode pred : RelOptUtil.conjunctions(condition)) { conditions.add(convertToStatsCondition(pred, index, context, scanRel, typesToProcess)); } return RexUtil.composeConjunction(builder, conditions, false); } else if (condition.getKind() == SqlKind.OR) { final List<RexNode> conditions = Lists.newArrayList(); for(RexNode pred : RelOptUtil.disjunctions(condition)) { conditions.add(convertToStatsCondition(pred, index, context, scanRel, typesToProcess)); } return RexUtil.composeDisjunction(builder, conditions, false); } else if (condition instanceof RexCall) { // LIKE operator - convert to a RANGE predicate, if possible if (typesToProcess.contains(SqlKind.LIKE) && ((RexCall) condition).getOperator().getKind() == SqlKind.LIKE) { return convertLikeToRange((RexCall)condition, builder); } else if (typesToProcess.contains(SqlKind.CAST) && hasCastExpression(condition)) { return convertCastForFIdx(((RexCall) condition), index, context, scanRel); } else { return condition; } } return condition; }
List<RexNode> firsts = RelOptUtil.disjunctions(firstDnf); List<RexNode> seconds = RelOptUtil.disjunctions(secondDnf);
@Override public RexNode visitCall(RexCall call) { SqlOperator op = call.getOperator(); SqlKind kind = op.getKind(); RelDataType type = call.getType(); if (kind == SqlKind.AND) { List<RexNode> conjuncts = Lists.newArrayList(); for (RexNode child : call.getOperands()) { conjuncts.addAll(RelOptUtil.conjunctions(child.accept(this))); } return RexUtil.composeConjunction(builder, conjuncts, true); } if (kind == SqlKind.OR) { List<RexNode> disjuncts = Lists.newArrayList(); for (RexNode child : call.getOperands()) { disjuncts.addAll(RelOptUtil.disjunctions(child.accept(this))); } return RexUtil.composeDisjunction(builder, disjuncts, true); } return builder.makeCall(type, op, visitChildren(call)); }
@Override public RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery mq) { if (PrelUtil.getSettings(getCluster()).useDefaultCosting()) { return super.computeSelfCost(planner, mq).multiplyBy(.1); } double leftRowCount = mq.getRowCount(this.getLeft()); double rightRowCount = mq.getRowCount(this.getRight()); double nljFactor = PrelUtil.getSettings(getCluster()).getNestedLoopJoinFactor(); // cpu cost of evaluating each expression in join condition int exprNum = RelOptUtil.conjunctions(getCondition()).size() + RelOptUtil.disjunctions(getCondition()).size(); double joinConditionCost = DrillCostBase.COMPARE_CPU_COST * exprNum; double cpuCost = joinConditionCost * (leftRowCount * rightRowCount) * nljFactor; DrillCostFactory costFactory = (DrillCostFactory) planner.getCostFactory(); return costFactory.makeCost(leftRowCount * rightRowCount, cpuCost, 0, 0, 0); }