org.apache.calcite.rex.RexUtil Java Examples

protected RelBuilder(Context context, RelOptCluster cluster,
    RelOptSchema relOptSchema) {
  this.cluster = cluster;
  this.relOptSchema = relOptSchema;
  if (context == null) {
    context = Contexts.EMPTY_CONTEXT;
  }
  this.config = getConfig(context);
  this.viewExpander = getViewExpander(cluster, context);
  this.struct =
      Objects.requireNonNull(RelFactories.Struct.fromContext(context));
  final RexExecutor executor =
      Util.first(context.unwrap(RexExecutor.class),
          Util.first(cluster.getPlanner().getExecutor(), RexUtil.EXECUTOR));
  final RelOptPredicateList predicates = RelOptPredicateList.EMPTY;
  this.simplifier =
      new RexSimplify(cluster.getRexBuilder(), predicates, executor);
}
 

/**
 * Determine whether there is mapping between project input and output fields.
 * Bail out if sort relies on non-trivial expressions.
 */
private static boolean isCollationOnTrivialExpr(
    List<RexNode> projects, RelDataTypeFactory typeFactory,
    Mappings.TargetMapping map, RelFieldCollation fc, boolean passDown) {
  final int index = fc.getFieldIndex();
  int target = map.getTargetOpt(index);
  if (target < 0) {
    return false;
  }

  final RexNode node = passDown ? projects.get(index) : projects.get(target);
  if (node.isA(SqlKind.CAST)) {
    // Check whether it is a monotonic preserving cast
    final RexCall cast = (RexCall) node;
    RelFieldCollation newFieldCollation = Objects.requireNonNull(RexUtil.apply(map, fc));
    final RexCallBinding binding =
        RexCallBinding.create(typeFactory, cast,
            ImmutableList.of(RelCollations.of(newFieldCollation)));
    if (cast.getOperator().getMonotonicity(binding)
        == SqlMonotonicity.NOT_MONOTONIC) {
      return false;
    }
  }

  return true;
}
 

/**
 * Build a join condition based on the left/right keys
 *
 * @param leftRowType
 * @param rightRowType
 * @param leftKeys
 * @param rightKeys
 * @param filterNulls
 * @param builder
 * @return a conjunction of equi-join conditions
 */
static RexNode buildJoinCondition(RexBuilder builder, RelDataType leftRowType, RelDataType rightRowType, List<Integer> leftKeys, List<Integer> rightKeys, List<Boolean> filterNulls) {
  final List<RexNode> equijoinList = Lists.newArrayList();
  final int numLeftFields = leftRowType.getFieldCount();
  final List<RelDataTypeField> leftTypes = leftRowType.getFieldList();
  final List<RelDataTypeField> rightTypes = rightRowType.getFieldList();

  for (int i = 0; i < leftKeys.size(); i++) {
    int leftKeyOrdinal = leftKeys.get(i);
    int rightKeyOrdinal = rightKeys.get(i);

    SqlBinaryOperator operator = filterNulls.get(i) ? SqlStdOperatorTable.EQUALS : SqlStdOperatorTable.IS_NOT_DISTINCT_FROM;
    RexNode leftInput = builder.makeInputRef(leftTypes.get(leftKeyOrdinal).getType(), leftKeyOrdinal);
    RexNode rightInput = builder.makeInputRef(rightTypes.get(rightKeyOrdinal).getType(), rightKeyOrdinal + numLeftFields);
    equijoinList.add(builder.makeCall(operator, leftInput, rightInput));
  }

  return RexUtil.composeConjunction(builder, equijoinList, false);
}
 

public static RexNode splitCorrelatedFilterCondition(
    Filter filter,
    List<RexNode> joinKeys,
    List<RexNode> correlatedJoinKeys,
    boolean extractCorrelatedFieldAccess) {
  final List<RexNode> nonEquiList = new ArrayList<>();

  splitCorrelatedFilterCondition(
      filter,
      filter.getCondition(),
      joinKeys,
      correlatedJoinKeys,
      nonEquiList,
      extractCorrelatedFieldAccess);

  // Convert the remainders into a list that are AND'ed together.
  return RexUtil.composeConjunction(
      filter.getCluster().getRexBuilder(), nonEquiList, true);
}
 

/**
 * {@inheritDoc}
 *
 * <p>{@code COUNT(*)}, and {@code COUNT} applied to all NOT NULL arguments,
 * become {@code 1}; otherwise
 * {@code CASE WHEN arg0 IS NOT NULL THEN 1 ELSE 0 END}.
 */
public RexNode singleton(RexBuilder rexBuilder, RelDataType inputRowType,
    AggregateCall aggregateCall) {
  final List<RexNode> predicates = new ArrayList<>();
  for (Integer arg : aggregateCall.getArgList()) {
    final RelDataType type = inputRowType.getFieldList().get(arg).getType();
    if (type.isNullable()) {
      predicates.add(
          rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL,
              rexBuilder.makeInputRef(type, arg)));
    }
  }
  final RexNode predicate =
      RexUtil.composeConjunction(rexBuilder, predicates, true);
  final RexNode rexOne = rexBuilder.makeExactLiteral(
      BigDecimal.ONE, aggregateCall.getType());
  if (predicate == null) {
    return rexOne;
  } else {
    return rexBuilder.makeCall(SqlStdOperatorTable.CASE, predicate, rexOne,
        rexBuilder.makeExactLiteral(BigDecimal.ZERO, aggregateCall.getType()));
  }
}
 

@Override
public void onMatch(RelOptRuleCall call) {
    Filter oldFilter = call.rel(0);
    RexNode oldFilterCond = oldFilter.getCondition();

    if (RexUtil.findOperatorCall(SqlStdOperatorTable.IS_NOT_DISTINCT_FROM, oldFilterCond) == null) {
        // no longer contains isNotDistinctFromOperator
        return;
    }

    // Now replace all the "a isNotDistinctFrom b"
    // with the RexNode given by RelOptUtil.isDistinctFrom() method

    RemoveIsNotDistinctFromRexShuttle rewriteShuttle = new RemoveIsNotDistinctFromRexShuttle(
            oldFilter.getCluster().getRexBuilder());

    final RelBuilder relBuilder = call.builder();
    final RelNode newFilterRel = relBuilder.push(oldFilter.getInput()).filter(oldFilterCond.accept(rewriteShuttle))
            .build();

    call.transformTo(newFilterRel);
}
 

private RelNode rename(RelNode input, List<RelDataTypeField> inputFields, List<String> outputFieldNames) {
  if (outputFieldNames.size() == 0) {
    return input;
  }
  List<RexNode> exprs = Lists.newArrayList();

  for (RelDataTypeField field : inputFields) {
    RexNode expr = input.getCluster().getRexBuilder().makeInputRef(field.getType(), field.getIndex());
    exprs.add(expr);
  }

  RelDataType rowType = RexUtil.createStructType(input.getCluster().getTypeFactory(),
      exprs, outputFieldNames, null);

  ProjectPrel proj = new ProjectPrel(input.getCluster(), input.getTraitSet(), input, exprs, rowType);

  return proj;
}
 

private static RexCall doCollapseExpandedIsNotDistinctFrom(final RexBuilder rexBuilder,
    final RexCall call, RexCall ifNull0Call, RexCall ifNull1Call, RexCall equalsCall) {
  final RexNode isNullInput0 = ifNull0Call.getOperands().get(0);
  final RexNode isNullInput1 = ifNull1Call.getOperands().get(0);

  final RexNode equalsInput0 = RexUtil
      .removeNullabilityCast(rexBuilder.getTypeFactory(), equalsCall.getOperands().get(0));
  final RexNode equalsInput1 = RexUtil
      .removeNullabilityCast(rexBuilder.getTypeFactory(), equalsCall.getOperands().get(1));

  if ((isNullInput0.equals(equalsInput0) && isNullInput1.equals(equalsInput1))
      || (isNullInput1.equals(equalsInput0) && isNullInput0.equals(equalsInput1))) {
    return (RexCall) rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_DISTINCT_FROM,
        ImmutableList.of(isNullInput0, isNullInput1));
  }

  return call;
}
 

private Prel visit(ExchangePrel hashPrel, List<DistributionTrait.DistributionField> fields, Prel child) {
  final List<String> childFields = child.getRowType().getFieldNames();


  // Insert Project SqlOperatorImpl with new column that will be a hash for HashToRandomExchange fields
  final ProjectPrel addColumnprojectPrel = HashPrelUtil.addHashProject(fields, child, null);
  final Prel newPrel = (Prel) hashPrel.copy(addColumnprojectPrel.getTraitSet(), Collections.<RelNode>singletonList(addColumnprojectPrel));

  int validRows = newPrel.getRowType().getFieldCount() - 1;
  final List<RelDataTypeField> all = newPrel.getRowType().getFieldList();
  final List<RexNode> keptExprs = new ArrayList<>(validRows);

  final RexBuilder rexBuilder = newPrel.getCluster().getRexBuilder();
  for(int i = 0; i < validRows; i++){
    RexNode rex = rexBuilder.makeInputRef(all.get(i).getType(), i);
    keptExprs.add(rex);
  }

  // remove earlier inserted Project SqlOperatorImpl - since it creates issues down the road in HashJoin
  RelDataType removeRowType = RexUtil.createStructType(newPrel.getCluster().getTypeFactory(), keptExprs, childFields);
  return ProjectPrel.create(newPrel.getCluster(), newPrel.getTraitSet(), newPrel, keptExprs, removeRowType);
}
 

public void rewriteRel(Sort rel) {
  RelCollation oldCollation = rel.getCollation();
  final RelNode oldChild = rel.getInput();
  final RelNode newChild = getNewForOldRel(oldChild);
  final Mappings.TargetMapping mapping =
      getNewForOldInputMapping(oldChild);

  // validate
  for (RelFieldCollation field : oldCollation.getFieldCollations()) {
    int oldInput = field.getFieldIndex();
    RelDataType sortFieldType =
        oldChild.getRowType().getFieldList().get(oldInput).getType();
    if (sortFieldType.isStruct()) {
      // TODO jvs 10-Feb-2005
      throw Util.needToImplement("sorting on structured types");
    }
  }
  RelCollation newCollation = RexUtil.apply(mapping, oldCollation);
  Sort newRel =
      LogicalSort.create(newChild, newCollation, rel.offset, rel.fetch);
  setNewForOldRel(rel, newRel);
}
 

private static List<RexNode> convertExpressionList(SqlRexContext cx,
    List<SqlNode> nodes, SqlOperandTypeChecker.Consistency consistency) {
  final List<RexNode> exprs = new ArrayList<>();
  for (SqlNode node : nodes) {
    exprs.add(cx.convertExpression(node));
  }
  if (exprs.size() > 1) {
    final RelDataType type =
        consistentType(cx, consistency, RexUtil.types(exprs));
    if (type != null) {
      final List<RexNode> oldExprs = Lists.newArrayList(exprs);
      exprs.clear();
      for (RexNode expr : oldExprs) {
        exprs.add(cx.getRexBuilder().ensureType(type, expr, true));
      }
    }
  }
  return exprs;
}
 

@Override
public boolean matches(RelOptRuleCall call) {
	FlinkLogicalCorrelate correlate = call.rel(0);
	RelNode right = ((HepRelVertex) correlate.getRight()).getCurrentRel();
	FlinkLogicalTableFunctionScan tableFuncScan;
	if (right instanceof FlinkLogicalTableFunctionScan) {
		tableFuncScan = (FlinkLogicalTableFunctionScan) right;
	} else if (right instanceof FlinkLogicalCalc) {
		Option<FlinkLogicalTableFunctionScan> scan = CorrelateUtil
			.getTableFunctionScan((FlinkLogicalCalc) right);
		if (scan.isEmpty()) {
			return false;
		}
		tableFuncScan = scan.get();
	} else {
		return false;
	}
	RexNode rexNode = tableFuncScan.getCall();
	if (rexNode instanceof RexCall) {
		return PythonUtil.isPythonCall(rexNode, null) && PythonUtil.containsNonPythonCall(rexNode)
			|| PythonUtil.isNonPythonCall(rexNode) && PythonUtil.containsPythonCall(rexNode, null)
			|| (PythonUtil.isPythonCall(rexNode, null) && RexUtil.containsFieldAccess(rexNode));
	}
	return false;
}
 

/**
 * Lookup registered node
 */
private RexNode lookup(RexNode node) {
    Pair<RexNode, String> key = RexUtil.makeKey(node);
    if (irreducible.get(key) != null) {
        return node;
    }
    return results.get(key);
}
 

/**
 * Returns whether all types in a collection have the same family, as
 * determined by {@link #isSameFamily(RelDataType, RelDataType)}.
 *
 * @param types Types to check
 * @return true if all types are of the same family
 */
public static boolean areSameFamily(Iterable<RelDataType> types) {
  final List<RelDataType> typeList = ImmutableList.copyOf(types);
  if (Sets.newHashSet(RexUtil.families(typeList)).size() < 2) {
    return true;
  }
  for (Pair<RelDataType, RelDataType> adjacent : Pair.adjacents(typeList)) {
    if (!isSameFamily(adjacent.left, adjacent.right)) {
      return false;
    }
  }
  return true;
}
 

/**
 * First, the method takes the node expressions {@code nodeExprs} and swaps the table
 * and column references using the table mapping and the equivalence classes.
 * If {@code swapTableColumn} is true, it swaps the table reference and then the column reference,
 * otherwise it swaps the column reference and then the table reference.
 *
 * <p>Then, the method will rewrite the input expressions {@code exprsToRewrite}, replacing the
 * {@link RexTableInputRef} by references to the positions in {@code nodeExprs}.
 *
 * <p>The method will return the rewritten expressions. If any of the subexpressions in the input
 * expressions cannot be mapped, it will return null.
 */
protected List<RexNode> rewriteExpressions(
    RexBuilder rexBuilder,
    RelMetadataQuery mq,
    RelNode targetNode,
    RelNode node,
    List<RexNode> nodeExprs,
    BiMap<RelTableRef, RelTableRef> tableMapping,
    EquivalenceClasses ec,
    boolean swapTableColumn,
    List<RexNode> exprsToRewrite) {
  NodeLineage nodeLineage;
  if (swapTableColumn) {
    nodeLineage = generateSwapTableColumnReferencesLineage(rexBuilder, mq, node,
        tableMapping, ec, nodeExprs);
  } else {
    nodeLineage = generateSwapColumnTableReferencesLineage(rexBuilder, mq, node,
        tableMapping, ec, nodeExprs);
  }

  List<RexNode> rewrittenExprs = new ArrayList<>(exprsToRewrite.size());
  for (RexNode exprToRewrite : exprsToRewrite) {
    RexNode rewrittenExpr = replaceWithOriginalReferences(
        rexBuilder, targetNode, nodeLineage, exprToRewrite);
    if (RexUtil.containsTableInputRef(rewrittenExpr) != null) {
      // Some expressions were not present in view output
      return null;
    }
    rewrittenExprs.add(rewrittenExpr);
  }
  return rewrittenExprs;
}
 

@Override
public RelNode createProject(RelNode child,
                             List<? extends RexNode> childExprs, List<String> fieldNames) {
  final RelOptCluster cluster = child.getCluster();
  final RelDataType rowType = RexUtil.createStructType(cluster.getTypeFactory(), childExprs, fieldNames);
  final RelNode project = new ProjectPrel(cluster, child.getTraitSet().plus(Prel.DRILL_PHYSICAL),
      child, Lists.newArrayList(childExprs), rowType);

  return project;
}
 

@Override
public RexNode visitCall(final RexCall call) {
    final List<RexNode> clonedOperands = visitList(call.getOperands(), new boolean[] { true });
    final SqlOperator sqlOperator = DrillCalciteWrapperUtility
            .extractSqlOperatorFromWrapper(call.getOperator());
    return RexUtil.flatten(rexBuilder, rexBuilder.makeCall(call.getType(), sqlOperator, clonedOperands));
}
 

public SubstitutionVisitor(RelNode target_, RelNode query_,
    ImmutableList<UnifyRule> rules, RelBuilderFactory relBuilderFactory) {
  this.cluster = target_.getCluster();
  final RexExecutor executor =
      Util.first(cluster.getPlanner().getExecutor(), RexUtil.EXECUTOR);
  final RelOptPredicateList predicates = RelOptPredicateList.EMPTY;
  this.simplify =
      new RexSimplify(cluster.getRexBuilder(), predicates, executor);
  this.rules = rules;
  this.query = Holder.of(MutableRels.toMutable(query_));
  this.target = MutableRels.toMutable(target_);
  this.relBuilder = relBuilderFactory.create(cluster, null);
  final Set<MutableRel> parents = Sets.newIdentityHashSet();
  final List<MutableRel> allNodes = new ArrayList<>();
  final MutableRelVisitor visitor =
      new MutableRelVisitor() {
        public void visit(MutableRel node) {
          parents.add(node.getParent());
          allNodes.add(node);
          super.visit(node);
        }
      };
  visitor.go(target);

  // Populate the list of leaves in the tree under "target".
  // Leaves are all nodes that are not parents.
  // For determinism, it is important that the list is in scan order.
  allNodes.removeAll(parents);
  targetLeaves = ImmutableList.copyOf(allNodes);

  allNodes.clear();
  parents.clear();
  visitor.go(query);
  allNodes.removeAll(parents);
  queryLeaves = ImmutableList.copyOf(allNodes);
}
 

/**
 * Transform a datetime plus operation to timestampadd if the dialect requires this.
 */
protected RexNode simplifyDatetimePlus(RexNode node, RexBuilder builder) {
  if (dialect.useTimestampAddInsteadOfDatetimePlus()) {
    final RexNode converted = RexUtil.convertDatetimePlusToTimestampAdd(builder, node);
    return converted != null
      ? converted
      : node;
  }
  return node;
}
 

public Double getDistinctRowCount(Aggregate rel, RelMetadataQuery mq,
    ImmutableBitSet groupKey, RexNode predicate) {
  if (predicate == null || predicate.isAlwaysTrue()) {
    if (groupKey.isEmpty()) {
      return 1D;
    }
  }
  // determine which predicates can be applied on the child of the
  // aggregate
  final List<RexNode> notPushable = new ArrayList<>();
  final List<RexNode> pushable = new ArrayList<>();
  RelOptUtil.splitFilters(
      rel.getGroupSet(),
      predicate,
      pushable,
      notPushable);
  final RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
  RexNode childPreds =
      RexUtil.composeConjunction(rexBuilder, pushable, true);

  // set the bits as they correspond to the child input
  ImmutableBitSet.Builder childKey = ImmutableBitSet.builder();
  RelMdUtil.setAggChildKeys(groupKey, rel, childKey);

  Double distinctRowCount =
      mq.getDistinctRowCount(rel.getInput(), childKey.build(), childPreds);
  if (distinctRowCount == null) {
    return null;
  } else if (notPushable.isEmpty()) {
    return distinctRowCount;
  } else {
    RexNode preds =
        RexUtil.composeConjunction(rexBuilder, notPushable, true);
    return distinctRowCount * RelMdUtil.guessSelectivity(preds);
  }
}
 

public static RexNode getTotalRemainderFilter(RexNode indexColsRemFilter, RexNode incColsRemFilter, RexBuilder rexBuilder) {
  if (indexColsRemFilter != null && incColsRemFilter != null) {
    List<RexNode> operands = Lists.newArrayList();
    operands.add(indexColsRemFilter);
    operands.add(incColsRemFilter);
    RexNode totalRemainder = RexUtil.composeConjunction(rexBuilder, operands, false);
    return totalRemainder;
  } else if (indexColsRemFilter != null) {
    return indexColsRemFilter;
  } else {
    return incColsRemFilter;
  }
}
 

/**
 * Given a list of Index Expressions(usually indexed fields/functions from one or a set of indexes),
 * separate a filter condition into
 *     1), relevant subset of conditions (by relevant, it means at least one given index Expression was found) and,
 *     2), the rest in remainderCondition
 * @param relevantPaths
 * @param condition
 * @return
 */
public IndexConditionInfo indexConditionRelatedToFields(List<LogicalExpression> relevantPaths, RexNode condition) {
  // Use the same filter analyzer that is used for partitioning columns
  RewriteCombineBinaryOperators reverseVisitor =
      new RewriteCombineBinaryOperators(true, builder);

  condition = condition.accept(reverseVisitor);

  RexSeparator separator = new RexSeparator(relevantPaths, scan, builder);
  RexNode indexCondition = separator.getSeparatedCondition(condition);

  if (indexCondition == null) {
    return new IndexConditionInfo(null, null, false);
  }

  List<RexNode> conjuncts = RelOptUtil.conjunctions(condition);
  List<RexNode> indexConjuncts = RelOptUtil.conjunctions(indexCondition);
  for (RexNode indexConjunction: indexConjuncts) {
    RexUtil.removeAll(conjuncts, indexConjunction);
  }

  RexNode remainderCondition = RexUtil.composeConjunction(builder, conjuncts, false);

  indexCondition = indexCondition.accept(reverseVisitor);

  return new IndexConditionInfo(indexCondition, remainderCondition, true);
}
 

public Double getSelectivity(Project rel, RelMetadataQuery mq,
    RexNode predicate) {
  final List<RexNode> notPushable = new ArrayList<>();
  final List<RexNode> pushable = new ArrayList<>();
  RelOptUtil.splitFilters(
      ImmutableBitSet.range(rel.getRowType().getFieldCount()),
      predicate,
      pushable,
      notPushable);
  final RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
  RexNode childPred =
      RexUtil.composeConjunction(rexBuilder, pushable, true);

  RexNode modifiedPred;
  if (childPred == null) {
    modifiedPred = null;
  } else {
    modifiedPred = RelOptUtil.pushPastProject(childPred, rel);
  }
  Double selectivity = mq.getSelectivity(rel.getInput(), modifiedPred);
  if (selectivity == null) {
    return null;
  } else {
    RexNode pred =
        RexUtil.composeConjunction(rexBuilder, notPushable, true);
    return selectivity * RelMdUtil.guessSelectivity(pred);
  }
}
 

/**
 * AND's two predicates together, either of which may be null, removing
 * redundant filters.
 *
 * @param rexBuilder rexBuilder used to construct AND'd RexNode
 * @param pred1      first predicate
 * @param pred2      second predicate
 * @return AND'd predicate or individual predicates if one is null
 */
public static RexNode unionPreds(
    RexBuilder rexBuilder,
    RexNode pred1,
    RexNode pred2) {
  final Set<RexNode> unionList = new LinkedHashSet<>();
  unionList.addAll(RelOptUtil.conjunctions(pred1));
  unionList.addAll(RelOptUtil.conjunctions(pred2));
  return RexUtil.composeConjunction(rexBuilder, unionList, true);
}
 

@Deprecated // to be removed before 2.0
public FilterProjectTransposeRule(
    Class<? extends Filter> filterClass,
    RelFactories.FilterFactory filterFactory,
    Class<? extends Project> projectClass,
    RelFactories.ProjectFactory projectFactory) {
  this(filterClass, filter -> !RexUtil.containsCorrelation(filter.getCondition()),
      projectClass, project -> true,
      filterFactory == null,
      projectFactory == null,
      RelBuilder.proto(filterFactory, projectFactory));
}
 

@Override public RexNode visitLiteral(RexLiteral literal) {
  // Use nullIndicator to decide whether to project null.
  // Do nothing if the literal is null.
  if (!RexUtil.isNull(literal)
      && projectPulledAboveLeftCorrelator
      && (nullIndicator != null)) {
    return createCaseExpression(nullIndicator, null, literal);
  }
  return literal;
}
 

/**
 * AND's two predicates together, either of which may be null, removing
 * redundant filters.
 *
 * @param rexBuilder rexBuilder used to construct AND'd RexNode
 * @param pred1      first predicate
 * @param pred2      second predicate
 * @return AND'd predicate or individual predicates if one is null
 */
public static RexNode unionPreds(
    RexBuilder rexBuilder,
    RexNode pred1,
    RexNode pred2) {
  final Set<RexNode> unionList = new LinkedHashSet<>();
  unionList.addAll(RelOptUtil.conjunctions(pred1));
  unionList.addAll(RelOptUtil.conjunctions(pred2));
  return RexUtil.composeConjunction(rexBuilder, unionList, true);
}
 

/** Returns whether an expression is definitely null.
 *
 * <p>The answer is based on calls to {@link #isNull} for its constituent
 * expressions, and you may override methods to test hypotheses such as
 * "if {@code x} is null, is {@code x + y} null? */
public boolean isNull(RexNode node) {
  final Policy policy = policy(node.getKind());
  switch (policy) {
  case NOT_NULL:
    return false;
  case ANY:
    return anyNull(((RexCall) node).getOperands());
  default:
    break;
  }

  switch (node.getKind()) {
  case LITERAL:
    return ((RexLiteral) node).isNull();
  // We can only guarantee AND to return NULL if both inputs are NULL  (similar for OR)
  // AND(NULL, FALSE) = FALSE
  case AND:
  case OR:
  case COALESCE:
    return allNull(((RexCall) node).getOperands());
  case NULLIF:
    // NULLIF(null, X) where X can be NULL, returns NULL
    // NULLIF(X, Y) where X is not NULL, then this may return NULL if X = Y, otherwise X.
    return allNull(ImmutableList.of(((RexCall) node).getOperands().get(0)));
  case INPUT_REF:
    return isNull((RexInputRef) node);
  case CASE:
    final RexCall caseCall = (RexCall) node;
    final List<RexNode> caseValues = new ArrayList<>();
    for (int i = 0; i < caseCall.getOperands().size(); i++) {
      if (!RexUtil.isCasePredicate(caseCall, i)) {
        caseValues.add(caseCall.getOperands().get(i));
      }
    }
    return allNull(caseValues);
  default:
    return false;
  }
}
 

private double estimateCpuCost(RelMetadataQuery relMetadataQuery) {
  RelNode child = this.getInput();
  final double rows = relMetadataQuery.getRowCount(child);
  double compNum = rows;
  double rowCompNum = child.getRowType().getFieldCount() * rows ;


  for (int i = 0; i< numConjuncts; i++) {
    RexNode conjFilter = RexUtil.composeConjunction(this.getCluster().getRexBuilder(), conjunctions.subList(0, i + 1), false);
    compNum += RelMdUtil.estimateFilteredRows(child, conjFilter, relMetadataQuery);
  }

  return compNum * DremioCost.COMPARE_CPU_COST + rowCompNum * DremioCost.COPY_COST;
}
 

@Override
public Prel visitProject(ProjectPrel prel, Void value) throws RuntimeException {
  // Require prefix rename : there exists other expression, in addition to a star column.
  if (!prefixedForStar  // not set yet.
      && StarColumnHelper.containsStarColumnInProject(prel.getInput().getRowType(), prel.getProjects())
      && prel.getRowType().getFieldNames().size() > 1) {
    prefixedForStar = true;
  }

  // For project, we need make sure that the project's field name is same as the input,
  // when the project expression is RexInPutRef, since we may insert a PAS which will
  // rename the projected fields.

  RelNode child = ((Prel) prel.getInput(0)).accept(this, null);

  List<String> fieldNames = Lists.newArrayList();

  for (Pair<String, RexNode> pair : Pair.zip(prel.getRowType().getFieldNames(), prel.getProjects())) {
    if (pair.right instanceof RexInputRef) {
      String name = child.getRowType().getFieldNames().get(((RexInputRef) pair.right).getIndex());
      fieldNames.add(name);
    } else {
      fieldNames.add(pair.left);
    }
  }

  // Make sure the field names are unique : no allow of duplicate field names in a rowType.
  fieldNames = makeUniqueNames(fieldNames);

  RelDataType rowType = RexUtil.createStructType(prel.getCluster().getTypeFactory(),
      prel.getProjects(), fieldNames, null);

  ProjectPrel newProj = (ProjectPrel) prel.copy(prel.getTraitSet(), child, prel.getProjects(), rowType);

  if (ProjectRemoveRule.isTrivial(newProj)) {
    return (Prel) child;
  } else {
    return newProj;
  }
}