Refine search
private void flattenPredicates(RexNode r) { if (r instanceof RexCall && ((RexCall) r).getOperator() == SqlStdOperatorTable.AND) { for (RexNode c : ((RexCall) r).getOperands()) { flattenPredicates(c); } } else { pruningPredicates.add(r); } }
private void flattenPredicates(RexNode r) { if (r instanceof RexCall && ((RexCall) r).getOperator() == SqlStdOperatorTable.AND) { for (RexNode c : ((RexCall) r).getOperands()) { flattenPredicates(c); } } else { pruningPredicates.add(r); } }
@Override public Void visitCall(RexCall call) { if (call.getOperator().getKind() == SqlKind.EQUALS) { int lPos = pos(call.getOperands().get(0)); int rPos = pos(call.getOperands().get(1)); if (lPos != -1 && rPos != -1) { JoinConditionBasedPredicateInference.this.equivalent(lPos, rPos); JoinConditionBasedPredicateInference.this.equalityPredicates .add(call.toString()); } } return null; } }
private boolean isRexLiteral(final RexNode rexNode) { if(rexNode instanceof RexLiteral) { return true; } else if(rexNode instanceof RexCall && ((RexCall)rexNode).getOperator().getKind() == SqlKind.CAST){ return isRexLiteral(((RexCall)(rexNode)).getOperands().get(0)); } else { return false; } }
@Override public Void visitCall(RexCall call) { if (call.getOperator().getKind() == SqlKind.EQUALS) { int lPos = pos(call.getOperands().get(0)); int rPos = pos(call.getOperands().get(1)); if (lPos != -1 && rPos != -1) { JoinConditionBasedPredicateInference.this.equivalent(lPos, rPos); JoinConditionBasedPredicateInference.this.equalityPredicates .add(call.toString()); } } return null; } }
@Override public Boolean visitCall(RexCall call) { // Constant if operator is deterministic and all operands are // constant. return call.getOperator().isDeterministic() && RexVisitorImpl.visitArrayAnd(this, call.getOperands()); }
@Override public Boolean visitCall(RexCall call) { // Constant if operator is deterministic and all operands are // constant. return call.getOperator().isDeterministic() && RexVisitorImpl.visitArrayAnd(this, call.getOperands()); }
private boolean validRexCall(RexCall call) { if (call instanceof RexOver) { LOG.debug("RexOver operator push down is not supported for now with the following operator:" + call); return false; } final SqlOperator operator = call.getOperator(); List <RexNode> operands = call.getOperands(); RelDataType resType = call.getType(); ArrayList<RelDataType> paramsListType = new ArrayList<RelDataType>(); for (RexNode currNode : operands) { paramsListType.add(currNode.getType()); } return dialect.supportsFunction(operator, resType, paramsListType); }
private boolean isAlwaysTrue(RexNode predicate) { if (predicate instanceof RexCall) { RexCall c = (RexCall) predicate; if (c.getOperator().getKind() == SqlKind.EQUALS) { int lPos = pos(c.getOperands().get(0)); int rPos = pos(c.getOperands().get(1)); return lPos != -1 && lPos == rPos; } } return predicate.isAlwaysTrue(); } }
private boolean hasCastExpression(RexNode condition) { if (condition instanceof RexCall) { if (((RexCall) condition).getOperator().getKind() == SqlKind.CAST) { return true; } for (RexNode op : ((RexCall) condition).getOperands()) { if (hasCastExpression(op)) { return true; } } } return false; } /*
private boolean isAlwaysTrue(RexNode predicate) { if (predicate instanceof RexCall) { RexCall c = (RexCall) predicate; if (c.getOperator().getKind() == SqlKind.EQUALS) { int lPos = pos(c.getOperands().get(0)); int rPos = pos(c.getOperands().get(1)); return lPos != -1 && lPos == rPos; } } return predicate.isAlwaysTrue(); } }
private boolean isSqlCountCheck(final HiveFilter filter) { // look at hivesubqueryremoverule to see how is this filter created if(filter.getCondition() instanceof RexCall) { final RexCall condition = (RexCall)filter.getCondition(); if(condition.getKind() == SqlKind.LESS_THAN_OR_EQUAL) { final List<RexNode> operands = condition.getOperands(); if(operands.get(0) instanceof RexCall) { final RexCall op = (RexCall)operands.get(0); if(op.getOperator().getName().equals("sq_count_check")) { return true; } } } } return false; }
@Override public Void visitCall(RexCall call) { if(AnnotationUtils.getAnnotation(GenericUDFOPNotNull.class, Description.class).name().equals(call.getOperator().getName())) { if(call.getOperands().get(0) instanceof RexInputRef && !types.get(((RexInputRef)call.getOperands().get(0)).getIndex()).getType().isNullable()) { // No need to add not null filter for a constant. throw new Util.FoundOne(call); } } return super.visitCall(call); }
@Override public Void visitCall(RexCall call) { if(AnnotationUtils.getAnnotation(GenericUDFOPNotNull.class, Description.class).name().equals(call.getOperator().getName())) { if(call.getOperands().get(0) instanceof RexInputRef && !types.get(((RexInputRef)call.getOperands().get(0)).getIndex()).getType().isNullable()) { // No need to add not null filter for a constant. throw new Util.FoundOne(call); } } return super.visitCall(call); } }
boolean validHiveJoinFilter = false; if ((c.getOperator().getKind() == SqlKind.EQUALS)) { validHiveJoinFilter = true; for (RexNode rn : c.getOperands()) { } else if ((c.getOperator().getKind() == SqlKind.LESS_THAN) || (c.getOperator().getKind() == SqlKind.GREATER_THAN) || (c.getOperator().getKind() == SqlKind.LESS_THAN_OR_EQUAL) || (c.getOperator().getKind() == SqlKind.GREATER_THAN_OR_EQUAL)) { validHiveJoinFilter = true;
private RexNode getTypeSafePred(RelOptCluster cluster, RexNode rex, RelDataType rType) { RexNode typeSafeRex = rex; if ((typeSafeRex instanceof RexCall) && HiveCalciteUtil.isComparisonOp((RexCall) typeSafeRex)) { RexBuilder rb = cluster.getRexBuilder(); List<RexNode> fixedPredElems = new ArrayList<RexNode>(); RelDataType commonType = cluster.getTypeFactory().leastRestrictive( RexUtil.types(((RexCall) rex).getOperands())); for (RexNode rn : ((RexCall) rex).getOperands()) { fixedPredElems.add(rb.ensureType(commonType, rn, true)); } typeSafeRex = rb.makeCall(((RexCall) typeSafeRex).getOperator(), fixedPredElems); } return typeSafeRex; }
@Override public RexNode visitCall(final RexCall call) { if(!valueGenerator) { if(call.getOperands().size() == 2) { final List<RexNode> operands = new ArrayList<>(call.operands); RexNode o0 = operands.get(0); RexNode o1 = operands.get(1); boolean isCorrelated = false; if (o0 instanceof RexFieldAccess && (cm.mapFieldAccessToCorRef.get(o0) != null)) { o0 = decorrFieldAccess((RexFieldAccess) o0); isCorrelated = true; } if (o1 instanceof RexFieldAccess && (cm.mapFieldAccessToCorRef.get(o1) != null)) { o1 = decorrFieldAccess((RexFieldAccess) o1); isCorrelated = true; } if (isCorrelated && RexUtil.eq(o0, o1)) { return rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, o0); } final List<RexNode> newOperands = new ArrayList<>(); newOperands.add(o0); newOperands.add(o1); boolean[] update = {false}; List<RexNode> clonedOperands = visitList(newOperands, update); return relBuilder.call(call.getOperator(), clonedOperands); } } return super.visitCall(call); }
public static RexNode getTypeSafePred(RelOptCluster cluster, RexNode rex, RelDataType rType) { RexNode typeSafeRex = rex; if ((typeSafeRex instanceof RexCall) && HiveCalciteUtil.isComparisonOp((RexCall) typeSafeRex)) { RexBuilder rb = cluster.getRexBuilder(); List<RexNode> fixedPredElems = new ArrayList<RexNode>(); RelDataType commonType = cluster.getTypeFactory().leastRestrictive( RexUtil.types(((RexCall) rex).getOperands())); for (RexNode rn : ((RexCall) rex).getOperands()) { fixedPredElems.add(rb.ensureType(commonType, rn, true)); } typeSafeRex = rb.makeCall(((RexCall) typeSafeRex).getOperator(), fixedPredElems); } return typeSafeRex; }
void translateJoinColumn(RexCall condition, Map<TblColRef, TblColRef> joinColumns) { SqlKind kind = condition.getOperator().getKind(); if (kind == SqlKind.AND) { for (RexNode operand : condition.getOperands()) { RexCall subCond = (RexCall) operand; translateJoinColumn(subCond, joinColumns); } } else if (kind == SqlKind.EQUALS) { List<RexNode> operands = condition.getOperands(); RexInputRef op0 = (RexInputRef) operands.get(0); TblColRef col0 = columnRowType.getColumnByIndex(op0.getIndex()); RexInputRef op1 = (RexInputRef) operands.get(1); TblColRef col1 = columnRowType.getColumnByIndex(op1.getIndex()); // map left => right if (op0.getIndex() < columnRowTypeLeftRightCut) joinColumns.put(col0, col1); else joinColumns.put(col1, col0); } }
if (condition instanceof RexCall) { RexCall call = (RexCall) condition; if (call.getOperator().getKind() == SqlKind.AND) { for (RexNode operand : call.getOperands()) { splitCorrelatedFilterCondition( filter, if (call.getOperator().getKind() == SqlKind.EQUALS) { final List<RexNode> operands = call.getOperands(); RexNode op0 = operands.get(0); RexNode op1 = operands.get(1);