org.apache.calcite.rel.core.Calc Java Examples

public Set<RelColumnOrigin> getColumnOrigins(Calc rel,
    final RelMetadataQuery mq, int iOutputColumn) {
  final RelNode input = rel.getInput();
  final RexShuttle rexShuttle = new RexShuttle() {
    @Override public RexNode visitLocalRef(RexLocalRef localRef) {
      return rel.getProgram().expandLocalRef(localRef);
    }
  };
  final List<RexNode> projects = new ArrayList<>();
  for (RexNode rex: rexShuttle.apply(rel.getProgram().getProjectList())) {
    projects.add(rex);
  }
  final RexNode rexNode = projects.get(iOutputColumn);
  if (rexNode instanceof RexInputRef) {
    // Direct reference:  no derivation added.
    RexInputRef inputRef = (RexInputRef) rexNode;
    return mq.getColumnOrigins(input, inputRef.getIndex());
  }
  // Anything else is a derivation, possibly from multiple columns.
  final Set<RelColumnOrigin> set = getMultipleColumns(rexNode, input, mq);
  return createDerivedColumnOrigins(set);
}
 

/**
 * Constructs a CalcRelSplitter.
 *
 * @param calc     Calc to split
 * @param relTypes Array of rel types, e.g. {Java, Fennel}. Must be
 *                 distinct.
 */
CalcRelSplitter(Calc calc, RelBuilder relBuilder, RelType[] relTypes) {
    this.relBuilder = relBuilder;
    for (int i = 0; i < relTypes.length; i++) {
        assert relTypes[i] != null;
        for (int j = 0; j < i; j++) {
            assert relTypes[i] != relTypes[j] : "Rel types must be distinct";
        }
    }
    this.program = calc.getProgram();
    this.cluster = calc.getCluster();
    this.traits = calc.getTraitSet();
    this.typeFactory = calc.getCluster().getTypeFactory();
    this.child = calc.getInput();
    this.relTypes = relTypes;
}
 

public Result visitCalc(Calc e) {
  Result x = visitChild(0, e.getInput());
  final RexProgram program = e.getProgram();
  Builder builder =
      program.getCondition() != null
          ? x.builder(e, Clause.WHERE)
          : x.builder(e);
  if (!isStar(program)) {
    final List<SqlNode> selectList = new ArrayList<>();
    for (RexLocalRef ref : program.getProjectList()) {
      SqlNode sqlExpr = builder.context.toSql(program, ref);
      addSelect(selectList, sqlExpr, e.getRowType());
    }
    builder.setSelect(new SqlNodeList(selectList, POS));
  }

  if (program.getCondition() != null) {
    builder.setWhere(
        builder.context.toSql(program, program.getCondition()));
  }
  return builder.result();
}
 

/** @see #dispatch */
public Result visit(Calc e) {
  Result x = visitChild(0, e.getInput());
  parseCorrelTable(e, x);
  final RexProgram program = e.getProgram();
  Builder builder =
      program.getCondition() != null
          ? x.builder(e, Clause.WHERE)
          : x.builder(e);
  if (!isStar(program)) {
    final List<SqlNode> selectList = new ArrayList<>(program.getProjectList().size());
    for (RexLocalRef ref : program.getProjectList()) {
      SqlNode sqlExpr = builder.context.toSql(program, ref);
      addSelect(selectList, sqlExpr, e.getRowType());
    }
    builder.setSelect(new SqlNodeList(selectList, POS));
  }

  if (program.getCondition() != null) {
    builder.setWhere(
        builder.context.toSql(program, program.getCondition()));
  }
  return builder.result();
}
 

/** @see #dispatch */
public Result visit(Calc e) {
  Result x = visitChild(0, e.getInput());
  parseCorrelTable(e, x);
  final RexProgram program = e.getProgram();
  Builder builder =
      program.getCondition() != null
          ? x.builder(e, Clause.WHERE)
          : x.builder(e);
  if (!isStar(program)) {
    final List<SqlNode> selectList = new ArrayList<>();
    for (RexLocalRef ref : program.getProjectList()) {
      SqlNode sqlExpr = builder.context.toSql(program, ref);
      addSelect(selectList, sqlExpr, e.getRowType());
    }
    builder.setSelect(new SqlNodeList(selectList, POS));
  }

  if (program.getCondition() != null) {
    builder.setWhere(
        builder.context.toSql(program, program.getCondition()));
  }
  return builder.result();
}
 

/**
 * Constructs a CalcRelSplitter.
 *
 * @param calc     Calc to split
 * @param relTypes Array of rel types, e.g. {Java, Fennel}. Must be
 *                 distinct.
 */
CalcRelSplitter(Calc calc, RelBuilder relBuilder, RelType[] relTypes) {
  this.relBuilder = relBuilder;
  for (int i = 0; i < relTypes.length; i++) {
    assert relTypes[i] != null;
    for (int j = 0; j < i; j++) {
      assert relTypes[i] != relTypes[j]
          : "Rel types must be distinct";
    }
  }
  this.program = calc.getProgram();
  this.cluster = calc.getCluster();
  this.traits = calc.getTraitSet();
  this.typeFactory = calc.getCluster().getTypeFactory();
  this.child = calc.getInput();
  this.relTypes = relTypes;
}
 

/**
 * @see #dispatch
 */
public Result visit(Calc e) {
  Result x = visitChild(0, e.getInput());
  parseCorrelTable(e, x);
  final RexProgram program = e.getProgram();
  Builder builder =
    program.getCondition() != null
      ? x.builder(e, Clause.WHERE)
      : x.builder(e);
  if (!isStar(program)) {
    final List<SqlNode> selectList = new ArrayList<>();
    for (RexLocalRef ref : program.getProjectList()) {
      SqlNode sqlExpr = builder.context.toSql(program, ref);
      addSelect(selectList, sqlExpr, e.getRowType());
    }
    builder.setSelect(new SqlNodeList(selectList, POS));
  }

  if (program.getCondition() != null) {
    builder.setWhere(
      builder.context.toSql(program, program.getCondition()));
  }
  return builder.result();
}
 

@Override public void onMatch(RelOptRuleCall call) {
  final Calc calc = call.rel(0);
  final Pair<ImmutableList<RexNode>, ImmutableList<RexNode>> projectFilter =
      calc.getProgram().split();
  final RelBuilder relBuilder = call.builder();
  relBuilder.push(calc.getInput());
  relBuilder.filter(projectFilter.right);
  relBuilder.project(projectFilter.left, calc.getRowType().getFieldNames());
  call.transformTo(relBuilder.build());
}
 

public Double getMinRowCount(Calc rel, RelMetadataQuery mq) {
  if (rel.getProgram().getCondition() != null) {
    // no lower bound
    return 0d;
  } else {
    return mq.getMinRowCount(rel.getInput());
  }
}
 

public Boolean areColumnsUnique(Calc rel, RelMetadataQuery mq,
    ImmutableBitSet columns, boolean ignoreNulls) {
  columns = decorateWithConstantColumnsFromPredicates(columns, rel, mq);
  RexProgram program = rel.getProgram();

  return areProjectColumnsUnique(rel, mq, columns, ignoreNulls,
      Lists.transform(program.getProjectList(), program::expandLocalRef));
}
 

public Double getSelectivity(Calc rel, RelMetadataQuery mq, RexNode predicate) {
  final RexProgram rexProgram = rel.getProgram();
  final RexLocalRef programCondition = rexProgram.getCondition();
  if (programCondition == null) {
    return getSelectivity(rel.getInput(), mq, predicate);
  } else {
    return mq.getSelectivity(rel.getInput(),
        RelMdUtil.minusPreds(
            rel.getCluster().getRexBuilder(),
            predicate,
            rexProgram.expandLocalRef(programCondition)));
  }
}
 

public Set<ImmutableBitSet> getUniqueKeys(Calc rel, RelMetadataQuery mq,
    boolean ignoreNulls) {
  RexProgram program = rel.getProgram();
  Permutation permutation = program.getPermutation();
  return getProjectUniqueKeys(rel, mq, ignoreNulls,
      Lists.transform(program.getProjectList(), program::expandLocalRef));
}
 

public List<Double> averageColumnSizes(Calc rel, RelMetadataQuery mq) {
  final List<Double> inputColumnSizes =
      mq.getAverageColumnSizesNotNull(rel.getInput());
  final ImmutableNullableList.Builder<Double> sizes =
      ImmutableNullableList.builder();
  rel.getProgram().split().left.forEach(
      exp -> sizes.add(averageRexSize(exp, inputColumnSizes)));
  return sizes.build();
}
 

public Result visitChild(int i, RelNode e) {
  if (e instanceof Union) {
    return visitUnion((Union) e);
  } else if (e instanceof Join) {
    return visitJoin((Join) e);
  } else if (e instanceof Filter) {
    return visitFilter((Filter) e);
  } else if (e instanceof Project) {
    return visitProject((Project) e);
  } else if (e instanceof Aggregate) {
    return visitAggregate((Aggregate) e);
  } else if (e instanceof TableScan) {
    return visitTableScan((TableScan) e);
  } else if (e instanceof Intersect) {
    return visitIntersect((Intersect) e);
  } else if (e instanceof Minus) {
    return visitMinus((Minus) e);
  } else if (e instanceof Calc) {
    return visitCalc((Calc) e);
  } else if (e instanceof Sort) {
    return visitSort((Sort) e);
  } else if (e instanceof TableModify) {
    return visitTableModify((TableModify) e);
  } else if (e instanceof Limit) {
    return visitLimit((Limit) e);
  } else {
    throw new AssertionError("Need to Implement for " + e.getClass().getName()); // TODO:
  }
}
 

/**
 * Creates a CalcMergeRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public CalcMergeRule(RelBuilderFactory relBuilderFactory) {
  super(
      operand(
          Calc.class,
          operand(Calc.class, any())),
      relBuilderFactory, null);
}
 

public final T traverse(RelNode n) throws Exception {
  List<T> inputStreams = new ArrayList<>();
  for (RelNode input : n.getInputs()) {
    inputStreams.add(traverse(input));
  }

  if (n instanceof Aggregate) {
    return visitAggregate((Aggregate) n, inputStreams);
  } else if (n instanceof Calc) {
    return visitCalc((Calc) n, inputStreams);
  } else if (n instanceof Collect) {
    return visitCollect((Collect) n, inputStreams);
  } else if (n instanceof Correlate) {
    return visitCorrelate((Correlate) n, inputStreams);
  } else if (n instanceof Delta) {
    return visitDelta((Delta) n, inputStreams);
  } else if (n instanceof Exchange) {
    return visitExchange((Exchange) n, inputStreams);
  } else if (n instanceof Project) {
    return visitProject((Project) n, inputStreams);
  } else if (n instanceof Filter) {
    return visitFilter((Filter) n, inputStreams);
  } else if (n instanceof Sample) {
    return visitSample((Sample) n, inputStreams);
  } else if (n instanceof Sort) {
    return visitSort((Sort) n, inputStreams);
  } else if (n instanceof TableModify) {
    return visitTableModify((TableModify) n, inputStreams);
  } else if (n instanceof TableScan) {
    return visitTableScan((TableScan) n, inputStreams);
  } else if (n instanceof Uncollect) {
    return visitUncollect((Uncollect) n, inputStreams);
  } else if (n instanceof Window) {
    return visitWindow((Window) n, inputStreams);
  } else if (n instanceof Join) {
    return visitJoin((Join) n, inputStreams);
  } else {
    return defaultValue(n, inputStreams);
  }
}
 

/**
 * Creates a CalcToWindowRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public CalcToWindowRule(RelBuilderFactory relBuilderFactory) {
  super(
      operandJ(Calc.class, null,
          calc -> RexOver.containsOver(calc.getProgram()), any()),
      relBuilderFactory, "ProjectToWindowRule");
}
 

/**
 * Creates a CalcToWindowRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public CalcToWindowRule(RelBuilderFactory relBuilderFactory) {
  super(
      operandJ(Calc.class, null,
          calc -> RexOver.containsOver(calc.getProgram()), any()),
      relBuilderFactory, "ProjectToWindowRule");
}
 

@Override public void onMatch(RelOptRuleCall call) {
  final Calc calc = call.rel(0);
  final Pair<ImmutableList<RexNode>, ImmutableList<RexNode>> projectFilter =
      calc.getProgram().split();
  final RelBuilder relBuilder = call.builder();
  relBuilder.push(calc.getInput());
  relBuilder.filter(projectFilter.right);
  relBuilder.project(projectFilter.left, calc.getRowType().getFieldNames());
  call.transformTo(relBuilder.build());
}
 

/**
 * Creates a CalcMergeRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public CalcMergeRule(RelBuilderFactory relBuilderFactory) {
  super(
      operand(
          Calc.class,
          operand(Calc.class, any())),
      relBuilderFactory, null);
}
 

public RelNode convert(RelNode rel) {
  final Calc calc = (Calc) rel;

  // If there's a multiset, let FarragoMultisetSplitter work on it
  // first.
  if (RexMultisetUtil.containsMultiset(calc.getProgram())) {
    return null;
  }

  return new JdbcCalc(rel.getCluster(), rel.getTraitSet().replace(out),
      convert(calc.getInput(), calc.getTraitSet().replace(out)),
      calc.getProgram());
}
 

EnumerableCalcRule() {
  // The predicate ensures that if there's a multiset, FarragoMultisetSplitter
  // will work on it first.
  super(LogicalCalc.class,
      (Predicate<Calc>) RelOptUtil::notContainsWindowedAgg,
      Convention.NONE, EnumerableConvention.INSTANCE,
      RelFactories.LOGICAL_BUILDER, "EnumerableCalcRule");
}
 

@Test void testHintsForCalc() {
  final String sql = "select /*+ resource(mem='1024MB')*/ ename, sal, deptno from emp";
  final RelNode rel = tester.convertSqlToRel(sql).rel;
  final RelHint hint = RelHint.builder("RESOURCE")
      .hintOption("MEM", "1024MB")
      .build();
  // planner rule to convert Project to Calc.
  HepProgram program = new HepProgramBuilder()
      .addRuleInstance(ProjectToCalcRule.INSTANCE)
      .build();
  HepPlanner planner = new HepPlanner(program);
  planner.setRoot(rel);
  RelNode newRel = planner.findBestExp();
  new ValidateHintVisitor(hint, Calc.class).go(newRel);
}
 

public Multimap<Class<? extends RelNode>, RelNode> getNodeTypes(Calc rel,
    RelMetadataQuery mq) {
  return getNodeTypes(rel, Calc.class, mq);
}
 

WindowedAggRelSplitter(Calc calc, RelBuilder relBuilder) {
  super(calc, relBuilder, REL_TYPES);
}
 

/** Creates a JdbcCalcRule. */
private JdbcCalcRule(JdbcConvention out,
    RelBuilderFactory relBuilderFactory) {
  super(Calc.class, (Predicate<RelNode>) r -> true, Convention.NONE,
      out, relBuilderFactory, "JdbcCalcRule");
}
 

public CalcReduceExpressionsRule(Class<? extends Calc> calcClass,
    boolean matchNullability, RelBuilderFactory relBuilderFactory) {
  super(calcClass, matchNullability, relBuilderFactory,
      "ReduceExpressionsRule(Calc)");
}
 

@Deprecated // to be removed before 2.0
public CalcReduceExpressionsRule(Class<? extends Calc> calcClass,
    RelBuilderFactory relBuilderFactory) {
  this(calcClass, true, relBuilderFactory);
}
 

public Double getRowCount(Calc rel, RelMetadataQuery mq) {
  return RelMdUtil.estimateFilteredRows(rel.getInput(), rel.getProgram(), mq);
}
 

/**
 * Variant of {@link #trimFields(RelNode, ImmutableBitSet, Set)} for
 * {@link org.apache.calcite.rel.logical.LogicalCalc}.
 */
public TrimResult trimFields(
    Calc calc,
    ImmutableBitSet fieldsUsed,
    Set<RelDataTypeField> extraFields) {
  final RexProgram rexProgram = calc.getProgram();
  final List<RexNode> projs = Lists.transform(rexProgram.getProjectList(),
      rexProgram::expandLocalRef);

  final RelDataType rowType = calc.getRowType();
  final int fieldCount = rowType.getFieldCount();
  final RelNode input = calc.getInput();

  final Set<RelDataTypeField> inputExtraFields =
      new HashSet<>(extraFields);
  RelOptUtil.InputFinder inputFinder =
      new RelOptUtil.InputFinder(inputExtraFields);
  for (Ord<RexNode> ord : Ord.zip(projs)) {
    if (fieldsUsed.get(ord.i)) {
      ord.e.accept(inputFinder);
    }
  }
  ImmutableBitSet inputFieldsUsed = inputFinder.build();

  // Create input with trimmed columns.
  TrimResult trimResult =
      trimChild(calc, input, inputFieldsUsed, inputExtraFields);
  RelNode newInput = trimResult.left;
  final Mapping inputMapping = trimResult.right;

  // If the input is unchanged, and we need to project all columns,
  // there's nothing we can do.
  if (newInput == input
      && fieldsUsed.cardinality() == fieldCount) {
    return result(calc, Mappings.createIdentity(fieldCount));
  }

  // Some parts of the system can't handle rows with zero fields, so
  // pretend that one field is used.
  if (fieldsUsed.cardinality() == 0) {
    return dummyProject(fieldCount, newInput);
  }

  // Build new project expressions, and populate the mapping.
  final List<RexNode> newProjects = new ArrayList<>();
  final RexVisitor<RexNode> shuttle =
      new RexPermuteInputsShuttle(
          inputMapping, newInput);
  final Mapping mapping =
      Mappings.create(
          MappingType.INVERSE_SURJECTION,
          fieldCount,
          fieldsUsed.cardinality());
  for (Ord<RexNode> ord : Ord.zip(projs)) {
    if (fieldsUsed.get(ord.i)) {
      mapping.set(ord.i, newProjects.size());
      RexNode newProjectExpr = ord.e.accept(shuttle);
      newProjects.add(newProjectExpr);
    }
  }

  final RelDataType newRowType =
      RelOptUtil.permute(calc.getCluster().getTypeFactory(), rowType,
          mapping);

  final RelNode newInputRelNode = relBuilder.push(newInput).build();
  RexNode newConditionExpr = null;
  if (rexProgram.getCondition() != null) {
    final List<RexNode> filter = Lists.transform(
        ImmutableList.of(
            rexProgram.getCondition()), rexProgram::expandLocalRef);
    assert filter.size() == 1;
    final RexNode conditionExpr = filter.get(0);
    newConditionExpr = conditionExpr.accept(shuttle);
  }
  final RexProgram newRexProgram = RexProgram.create(newInputRelNode.getRowType(),
      newProjects, newConditionExpr, newRowType.getFieldNames(),
      newInputRelNode.getCluster().getRexBuilder());
  final Calc newCalc = calc.copy(calc.getTraitSet(), newInputRelNode, newRexProgram);
  return result(newCalc, mapping);
}