org.apache.calcite.rel.logical.LogicalCalc Java Examples

@Override
public void onMatch(RelOptRuleCall call) {
    LogicalCalc calc = call.rel(0);

    // Expand decimals in every expression in this program. If no
    // expression changes, don't apply the rule.
    final RexProgram program = calc.getProgram();
    if (!RexUtil.requiresDecimalExpansion(program, true)) {
        return;
    }

    final RexBuilder rexBuilder = calc.getCluster().getRexBuilder();
    final RexShuttle shuttle = new DecimalShuttle(rexBuilder);
    RexProgramBuilder programBuilder = RexProgramBuilder.create(rexBuilder, calc.getInput().getRowType(),
            program.getExprList(), program.getProjectList(), program.getCondition(), program.getOutputRowType(),
            shuttle, true);

    final RexProgram newProgram = programBuilder.getProgram();
    LogicalCalc newCalc = LogicalCalc.create(calc.getInput(), newProgram);
    call.transformTo(newCalc);
}
 

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

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

  return new SparkCalc(
      rel.getCluster(),
      rel.getTraitSet().replace(SparkRel.CONVENTION),
      convert(calc.getInput(),
          calc.getInput().getTraitSet().replace(SparkRel.CONVENTION)),
      program);
}
 

public RelNode convert(RelNode rel) {
        final LogicalCalc calc = (LogicalCalc) rel;
        final RelTraitSet traitSet = calc.getTraitSet().replace(getOutTrait());
//        return new ElasticsearchFilter(rel.getCluster(), traitSet,
//                convert(calc.getInput(), getOutTrait()),
//                calc.getCondition());
        return null;
    }
 

public void onMatch(RelOptRuleCall call) {
  LogicalCalc calc = call.rel(0);

  // Expand decimals in every expression in this program. If no
  // expression changes, don't apply the rule.
  final RexProgram program = calc.getProgram();
  if (!RexUtil.requiresDecimalExpansion(program, true)) {
    return;
  }

  final RexBuilder rexBuilder = calc.getCluster().getRexBuilder();
  final RexShuttle shuttle = new DecimalShuttle(rexBuilder);
  RexProgramBuilder programBuilder =
      RexProgramBuilder.create(
          rexBuilder,
          calc.getInput().getRowType(),
          program.getExprList(),
          program.getProjectList(),
          program.getCondition(),
          program.getOutputRowType(),
          shuttle,
          true);

  final RexProgram newProgram = programBuilder.getProgram();
  LogicalCalc newCalc = LogicalCalc.create(calc.getInput(), newProgram);
  call.transformTo(newCalc);
}
 

public void onMatch(RelOptRuleCall call) {
  final LogicalFilter filter = call.rel(0);
  final LogicalCalc calc = call.rel(1);

  // Don't merge a filter onto a calc which contains windowed aggregates.
  // That would effectively be pushing a multiset down through a filter.
  // We'll have chance to merge later, when the over is expanded.
  if (calc.getProgram().containsAggs()) {
    return;
  }

  // Create a program containing the filter.
  final RexBuilder rexBuilder = filter.getCluster().getRexBuilder();
  final RexProgramBuilder progBuilder =
      new RexProgramBuilder(
          calc.getRowType(),
          rexBuilder);
  progBuilder.addIdentity();
  progBuilder.addCondition(filter.getCondition());
  RexProgram topProgram = progBuilder.getProgram();
  RexProgram bottomProgram = calc.getProgram();

  // Merge the programs together.
  RexProgram mergedProgram =
      RexProgramBuilder.mergePrograms(
          topProgram,
          bottomProgram,
          rexBuilder);
  final LogicalCalc newCalc =
      LogicalCalc.create(calc.getInput(), mergedProgram);
  call.transformTo(newCalc);
}
 

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

public void onMatch(RelOptRuleCall call) {
  LogicalCalc calc = call.rel(0);
  RexProgram program = calc.getProgram();
  if (!program.isTrivial()) {
    return;
  }
  RelNode input = calc.getInput();
  input = call.getPlanner().register(input, calc);
  call.transformTo(
      convert(
          input,
          calc.getTraitSet()));
}
 

/**
 * Returns whether a relational expression can be implemented solely in a
 * given {@link RelType}.
 *
 * @param rel         Calculation relational expression
 * @param relTypeName Name of a {@link RelType}
 * @return Whether relational expression can be implemented
 */
protected boolean canImplement(LogicalCalc rel, String relTypeName) {
  for (RelType relType : relTypes) {
    if (relType.name.equals(relTypeName)) {
      return relType.canImplement(rel.getProgram());
    }
  }
  throw new AssertionError("unknown type " + relTypeName);
}
 

public void onMatch(RelOptRuleCall call) {
  final LogicalProject project = call.rel(0);
  final RelNode input = project.getInput();
  final RexProgram program =
      RexProgram.create(
          input.getRowType(),
          project.getProjects(),
          null,
          project.getRowType(),
          project.getCluster().getRexBuilder());
  final LogicalCalc calc = LogicalCalc.create(input, program);
  call.transformTo(calc);
}
 

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

private SparkCalcRule() {
  super(
      LogicalCalc.class,
      Convention.NONE,
      SparkRel.CONVENTION,
      "SparkCalcRule");
}
 

public RelNode convert(RelNode rel) {
        final LogicalCalc calc = (LogicalCalc) rel;
        final RelTraitSet traitSet = calc.getTraitSet().replace(getOutTrait());
//        return new ElasticsearchFilter(rel.getCluster(), traitSet,
//                convert(calc.getInput(), getOutTrait()),
//                calc.getCondition());
        return null;
    }
 

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");
}
 

public RelNode convert(RelNode rel) {
  final LogicalCalc calc = (LogicalCalc) rel;
  final RelNode input = calc.getInput();
  return EnumerableCalc.create(
      convert(input,
          input.getTraitSet().replace(EnumerableConvention.INSTANCE)),
      calc.getProgram());
}
 

public void rewriteRel(LogicalCalc rel) {
    // Translate the child.
    final RelNode newInput = getNewForOldRel(rel.getInput());

    final RelOptCluster cluster = rel.getCluster();
    RexProgramBuilder programBuilder = new RexProgramBuilder(newInput.getRowType(), cluster.getRexBuilder());

    // Convert the common expressions.
    final RexProgram program = rel.getProgram();
    final RewriteRexShuttle shuttle = new RewriteRexShuttle();
    for (RexNode expr : program.getExprList()) {
        programBuilder.registerInput(expr.accept(shuttle));
    }

    // Convert the projections.
    final List<Pair<RexNode, String>> flattenedExpList = new ArrayList<>();
    List<String> fieldNames = rel.getRowType().getFieldNames();
    flattenProjections(new RewriteRexShuttle(), program.getProjectList(), fieldNames, "", flattenedExpList);

    // Register each of the new projections.
    for (Pair<RexNode, String> flattenedExp : flattenedExpList) {
        programBuilder.addProject(flattenedExp.left, flattenedExp.right);
    }

    // Translate the condition.
    final RexLocalRef conditionRef = program.getCondition();
    if (conditionRef != null) {
        final Ord<RelDataType> newField = getNewFieldForOldInput(conditionRef.getIndex());
        programBuilder.addCondition(RexBuilder.getRexFactory().makeInputRef(newField.i, newField.e));
    }

    RexProgram newProgram = programBuilder.getProgram();

    // Create a new calc relational expression.
    LogicalCalc newRel = LogicalCalc.create(newInput, newProgram);
    setNewForOldRel(rel, newRel);
}
 

public void onMatch(RelOptRuleCall call) {
  LogicalCalc calc = call.rel(0);
  RexProgram program = calc.getProgram();
  if (!program.isTrivial()) {
    return;
  }
  RelNode input = calc.getInput();
  input = call.getPlanner().register(input, calc);
  call.transformTo(
      convert(
          input,
          calc.getTraitSet()));
}
 

@Nonnull
private Function<String, RelNode> convertProjectAsCalc() {
  return s -> {
    Project project = (Project) convertSql(s);
    RexProgram program = RexProgram.create(
        project.getInput().getRowType(),
        project.getProjects(),
        null,
        project.getRowType(),
        project.getCluster().getRexBuilder());
    return LogicalCalc.create(project.getInput(), program);
  };
}
 

public void onMatch(RelOptRuleCall call) {
  final LogicalFilter filter = call.rel(0);
  final LogicalCalc calc = call.rel(1);

  // Don't merge a filter onto a calc which contains windowed aggregates.
  // That would effectively be pushing a multiset down through a filter.
  // We'll have chance to merge later, when the over is expanded.
  if (calc.getProgram().containsAggs()) {
    return;
  }

  // Create a program containing the filter.
  final RexBuilder rexBuilder = filter.getCluster().getRexBuilder();
  final RexProgramBuilder progBuilder =
      new RexProgramBuilder(
          calc.getRowType(),
          rexBuilder);
  progBuilder.addIdentity();
  progBuilder.addCondition(filter.getCondition());
  RexProgram topProgram = progBuilder.getProgram();
  RexProgram bottomProgram = calc.getProgram();

  // Merge the programs together.
  RexProgram mergedProgram =
      RexProgramBuilder.mergePrograms(
          topProgram,
          bottomProgram,
          rexBuilder);
  final LogicalCalc newCalc =
      LogicalCalc.create(calc.getInput(), mergedProgram);
  call.transformTo(newCalc);
}
 

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

@Test void testCalc() {
  final FrameworkConfig config = RelBuilderTest.config().build();
  final RelBuilder builder = RelBuilder.create(config);
  final RexBuilder rexBuilder = builder.getRexBuilder();
  final LogicalTableScan scan = (LogicalTableScan) builder.scan("EMP").build();
  final RexProgramBuilder programBuilder =
      new RexProgramBuilder(scan.getRowType(), rexBuilder);
  final RelDataTypeField field = scan.getRowType().getField("SAL", false, false);
  programBuilder.addIdentity();
  programBuilder.addCondition(
      rexBuilder.makeCall(SqlStdOperatorTable.GREATER_THAN,
          new RexInputRef(field.getIndex(), field.getType()),
          builder.literal(10)));
  final LogicalCalc calc = LogicalCalc.create(scan, programBuilder.getProgram());
  String relJson = RelOptUtil.dumpPlan("", calc,
      SqlExplainFormat.JSON, SqlExplainLevel.EXPPLAN_ATTRIBUTES);
  String s =
      Frameworks.withPlanner((cluster, relOptSchema, rootSchema) -> {
        final RelJsonReader reader = new RelJsonReader(
            cluster, getSchema(calc), rootSchema);
        RelNode node;
        try {
          node = reader.read(relJson);
        } catch (IOException e) {
          throw TestUtil.rethrow(e);
        }
        return RelOptUtil.dumpPlan("", node, SqlExplainFormat.TEXT,
            SqlExplainLevel.EXPPLAN_ATTRIBUTES);
      });
  final String expected =
      "LogicalCalc(expr#0..7=[{inputs}], expr#8=[10], expr#9=[>($t5, $t8)],"
          + " proj#0..7=[{exprs}], $condition=[$t9])\n"
          + "  LogicalTableScan(table=[[scott, EMP]])\n";
  assertThat(s, isLinux(expected));
}
 

/**
 * Returns whether a relational expression can be implemented solely in a
 * given {@link RelType}.
 *
 * @param rel         Calculation relational expression
 * @param relTypeName Name of a {@link RelType}
 * @return Whether relational expression can be implemented
 */
protected boolean canImplement(LogicalCalc rel, String relTypeName) {
    for (RelType relType : relTypes) {
        if (relType.name.equals(relTypeName)) {
            return relType.canImplement(rel.getProgram());
        }
    }
    throw new AssertionError("unknown type " + relTypeName);
}
 

public void onMatch(RelOptRuleCall call) {
  final LogicalProject project = call.rel(0);
  final RelNode input = project.getInput();
  final RexProgram program =
      RexProgram.create(
          input.getRowType(),
          project.getProjects(),
          null,
          project.getRowType(),
          project.getCluster().getRexBuilder());
  final LogicalCalc calc = LogicalCalc.create(input, program);
  call.transformTo(calc);
}
 

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

public void onMatch(RelOptRuleCall call) {
  final LogicalProject project = call.rel(0);
  final LogicalCalc calc = call.rel(1);

  // Don't merge a project which contains windowed aggregates onto a
  // calc. That would effectively be pushing a windowed aggregate down
  // through a filter. Transform the project into an identical calc,
  // which we'll have chance to merge later, after the over is
  // expanded.
  final RelOptCluster cluster = project.getCluster();
  RexProgram program =
      RexProgram.create(
          calc.getRowType(),
          project.getProjects(),
          null,
          project.getRowType(),
          cluster.getRexBuilder());
  if (RexOver.containsOver(program)) {
    LogicalCalc projectAsCalc = LogicalCalc.create(calc, program);
    call.transformTo(projectAsCalc);
    return;
  }

  // Create a program containing the project node's expressions.
  final RexBuilder rexBuilder = cluster.getRexBuilder();
  final RexProgramBuilder progBuilder =
      new RexProgramBuilder(
          calc.getRowType(),
          rexBuilder);
  for (Pair<RexNode, String> field : project.getNamedProjects()) {
    progBuilder.addProject(field.left, field.right);
  }
  RexProgram topProgram = progBuilder.getProgram();
  RexProgram bottomProgram = calc.getProgram();

  // Merge the programs together.
  RexProgram mergedProgram =
      RexProgramBuilder.mergePrograms(
          topProgram,
          bottomProgram,
          rexBuilder);
  final LogicalCalc newCalc =
      LogicalCalc.create(calc.getInput(), mergedProgram);
  call.transformTo(newCalc);
}
 

public void rewriteRel(LogicalCalc rel) {
  // Translate the child.
  final RelNode newInput = getNewForOldRel(rel.getInput());

  final RelOptCluster cluster = rel.getCluster();
  RexProgramBuilder programBuilder =
      new RexProgramBuilder(
          newInput.getRowType(),
          cluster.getRexBuilder());

  // Convert the common expressions.
  final RexProgram program = rel.getProgram();
  final RewriteRexShuttle shuttle = new RewriteRexShuttle();
  for (RexNode expr : program.getExprList()) {
    programBuilder.registerInput(expr.accept(shuttle));
  }

  // Convert the projections.
  final List<Pair<RexNode, String>> flattenedExpList = new ArrayList<>();
  List<String> fieldNames = rel.getRowType().getFieldNames();
  flattenProjections(new RewriteRexShuttle(),
      program.getProjectList(),
      fieldNames,
      "",
      flattenedExpList);

  // Register each of the new projections.
  for (Pair<RexNode, String> flattenedExp : flattenedExpList) {
    programBuilder.addProject(flattenedExp.left, flattenedExp.right);
  }

  // Translate the condition.
  final RexLocalRef conditionRef = program.getCondition();
  if (conditionRef != null) {
    final Ord<RelDataType> newField =
        getNewFieldForOldInput(conditionRef.getIndex());
    programBuilder.addCondition(new RexLocalRef(newField.i, newField.e));
  }

  RexProgram newProgram = programBuilder.getProgram();

  // Create a new calc relational expression.
  LogicalCalc newRel = LogicalCalc.create(newInput, newProgram);
  setNewForOldRel(rel, newRel);
}
 

public RelNode visit(LogicalCalc calc) {
  return calc;
}
 

public RelNode visit(LogicalCalc calc) {
  return visitChildren(calc);
}
 

/**
 * Creates a ReduceDecimalsRule.
 */
public ReduceDecimalsRule(RelBuilderFactory relBuilderFactory) {
  super(operand(LogicalCalc.class, any()), relBuilderFactory, null);
}
 

protected RelNode makeRel(RelOptCluster cluster,
    RelTraitSet traitSet, RelBuilder relBuilder, RelNode input,
    RexProgram program) {
  return LogicalCalc.create(input, program);
}
 

public void onMatch(RelOptRuleCall call) {
  final LogicalProject project = call.rel(0);
  final LogicalCalc calc = call.rel(1);

  // Don't merge a project which contains windowed aggregates onto a
  // calc. That would effectively be pushing a windowed aggregate down
  // through a filter. Transform the project into an identical calc,
  // which we'll have chance to merge later, after the over is
  // expanded.
  final RelOptCluster cluster = project.getCluster();
  RexProgram program =
      RexProgram.create(
          calc.getRowType(),
          project.getProjects(),
          null,
          project.getRowType(),
          cluster.getRexBuilder());
  if (RexOver.containsOver(program)) {
    LogicalCalc projectAsCalc = LogicalCalc.create(calc, program);
    call.transformTo(projectAsCalc);
    return;
  }

  // Create a program containing the project node's expressions.
  final RexBuilder rexBuilder = cluster.getRexBuilder();
  final RexProgramBuilder progBuilder =
      new RexProgramBuilder(
          calc.getRowType(),
          rexBuilder);
  for (Pair<RexNode, String> field : project.getNamedProjects()) {
    progBuilder.addProject(field.left, field.right);
  }
  RexProgram topProgram = progBuilder.getProgram();
  RexProgram bottomProgram = calc.getProgram();

  // Merge the programs together.
  RexProgram mergedProgram =
      RexProgramBuilder.mergePrograms(
          topProgram,
          bottomProgram,
          rexBuilder);
  final LogicalCalc newCalc =
      LogicalCalc.create(calc.getInput(), mergedProgram);
  call.transformTo(newCalc);
}