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

@Override
public void onMatch(RelOptRuleCall call) {
  final Uncollect uncollect = call.rel(0);
  final LogicalProject project = call.rel(1);

  RexNode projectedNode = project.getProjects().iterator().next();
  if (projectedNode.getKind() != SqlKind.FIELD_ACCESS) {
    return;
  }
  final RelTraitSet traits = uncollect.getTraitSet().plus(DrillRel.DRILL_LOGICAL);
  DrillUnnestRel unnest = new DrillUnnestRel(uncollect.getCluster(),
      traits, uncollect.getRowType(), projectedNode);
  call.transformTo(unnest);
}
 

@Override
public RelNode visit(RelNode other) {
  if (other instanceof Uncollect) {
    return visit((Uncollect) other);
  }
  return super.visit(other);
}
 

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

/**
 * Flattens the top relation will all multiset columns. Call this method only if
 * the top relation contains multiset columns only.
 *
 * @return This builder.
 */
public RelBuilder multiSetFlatten() {
  // [CALCITE-3193] Add RelBuilder.uncollect method, and interface
  // UncollectFactory, to instantiate Uncollect
  Uncollect uncollect = Uncollect.create(
      cluster.traitSetOf(Convention.NONE),
      build(),
      false,
      Collections.emptyList());
  push(uncollect);
  return this;
}
 

public Result visit(Uncollect e) {
  final Result x = visitChild(0, e.getInput());
  final SqlNode unnestNode = SqlStdOperatorTable.UNNEST.createCall(POS, x.asStatement());
  final List<SqlNode> operands = createAsFullOperands(e.getRowType(), unnestNode, x.neededAlias);
  final SqlNode asNode = SqlStdOperatorTable.AS.createCall(POS, operands);
  return result(asNode, ImmutableList.of(Clause.FROM), e, null);
}
 

public RelNode convert(RelNode rel) {
  final Uncollect uncollect = (Uncollect) rel;
  final RelTraitSet traitSet =
      uncollect.getTraitSet().replace(EnumerableConvention.INSTANCE);
  final RelNode input = uncollect.getInput();
  final RelNode newInput = convert(input,
      input.getTraitSet().replace(EnumerableConvention.INSTANCE));
  return EnumerableUncollect.create(traitSet, newInput,
      uncollect.withOrdinality);
}
 

/**
 * Creates an {@link Uncollect} with given item aliases.
 *
 * @param itemAliases   Operand item aliases, never null
 * @param withOrdinality If {@code withOrdinality}, the output contains an extra
 * {@code ORDINALITY} column
 */
public RelBuilder uncollect(List<String> itemAliases, boolean withOrdinality) {
  Frame frame = stack.pop();
  stack.push(
      new Frame(
        new Uncollect(
          cluster,
          cluster.traitSetOf(Convention.NONE),
          frame.rel,
          withOrdinality,
          Objects.requireNonNull(itemAliases))));
  return this;
}
 

public void rewriteRel(Uncollect rel) {
    rewriteGeneric(rel);
}
 

private DrillUnnestRule() {
  super(RelOptHelper.some(Uncollect.class,
      RelOptHelper.some(LogicalProject.class, RelOptHelper.any(LogicalValues.class, Convention.NONE))),
      DrillRelFactories.LOGICAL_BUILDER, "DrillUnnestRule");
}
 

public RelNode visit(Uncollect uncollect) {
  RelBuilder builder = DrillRelFactories.LOGICAL_BUILDER.create(uncollect.getCluster(), null);
  RexBuilder rexBuilder = builder.getRexBuilder();

  assert uncollect.getInput() instanceof Project : "Uncollect should have Project input";

  Project project = (Project) uncollect.getInput();
  // If project below uncollect contains only field references, no need to rewrite it
  List<RexNode> projectChildExps = project.getChildExps();
  assert projectChildExps.size() == 1 : "Uncollect does not support multiple expressions";

  RexNode projectExpr = projectChildExps.iterator().next();
  if (projectExpr.getKind() == SqlKind.FIELD_ACCESS) {
    return uncollect;
  }

  // Collects CorrelationId instances used in current rel node
  RelOptUtil.VariableUsedVisitor variableUsedVisitor = new RelOptUtil.VariableUsedVisitor(null);
  project.accept(variableUsedVisitor);

  assert variableUsedVisitor.variables.size() == 1 : "Uncollect supports only single correlated reference";

  CorrelationId oldCorrId = variableUsedVisitor.variables.iterator().next();
  RelNode left = leftInputs.get(oldCorrId);

  // Creates new project to be placed on top of the left input of correlate
  List<RexNode> leftProjExprs = new ArrayList<>();

  List<String> fieldNames = new ArrayList<>();
  for (RelDataTypeField field : left.getRowType().getFieldList()) {
    leftProjExprs.add(rexBuilder.makeInputRef(left, field.getIndex()));
    fieldNames.add(field.getName());
  }
  fieldNames.add(COMPLEX_FIELD_NAME);

  builder.push(left);

  // Adds complex expression with replaced correlation
  // to the projected list from the left
  leftProjExprs.add(new RexFieldAccessReplacer(builder).apply(projectExpr));

  RelNode leftProject =
      builder.project(leftProjExprs, fieldNames)
          .build();
  leftInputs.put(oldCorrId, leftProject);

  builder.push(project.getInput());

  CorrelationId newCorrId = uncollect.getCluster().createCorrel();
  // stores new CorrelationId to be used during the creation of new Correlate
  updatedCorrelationIds.put(oldCorrId, newCorrId);

  RexNode rexCorrel = rexBuilder.makeCorrel(leftProject.getRowType(), newCorrId);

  // constructs Project below Uncollect with updated RexCorrelVariable
  builder.project(
      ImmutableList.of(rexBuilder.makeFieldAccess(rexCorrel, leftProjExprs.size() - 1)),
      ImmutableList.of(COMPLEX_FIELD_NAME));
  return uncollect.copy(uncollect.getTraitSet(), builder.build());
}
 

public T visitUncollect(Uncollect uncollect, List<T> inputStreams) throws Exception {
  return defaultValue(uncollect, inputStreams);
}
 

EnumerableUncollectRule() {
  super(Uncollect.class, Convention.NONE, EnumerableConvention.INSTANCE,
      "EnumerableUncollectRule");
}
 

public void rewriteRel(Uncollect rel) {
  rewriteGeneric(rel);
}
 

public UncollectNode(Compiler compiler, Uncollect uncollect) {
  super(compiler, uncollect);
}
 

public void visit(Uncollect uncollect) {
  node = new UncollectNode(this, uncollect);
}