聊聊flink Table的where及filter操作

序

本文主要研究一下flink Table的where及filter操作

Table

flink-table_2.11-1.7.0-sources.jar!/org/apache/flink/table/api/table.scala

class Table(
    private[flink] val tableEnv: TableEnvironment,
    private[flink] val logicalPlan: LogicalNode) {

  //......

  def where(predicate: String): Table = {
    filter(predicate)
  }

  def where(predicate: Expression): Table = {
    filter(predicate)
  }

  def filter(predicate: String): Table = {
    val predicateExpr = ExpressionParser.parseExpression(predicate)
    filter(predicateExpr)
  }

  def filter(predicate: Expression): Table = {
    new Table(tableEnv, Filter(predicate, logicalPlan).validate(tableEnv))
  }

  //......
}

• Table的where及filter操作均有两中方法，一种是String参数，一种是Expression参数；而where方法内部是调用filter方法；filter方法使用Filter(predicate, logicalPlan).validate(tableEnv)创建了新的Table；String参数最后是通过ExpressionParser.parseExpression方法转换为Expression类型

Filter

flink-table_2.11-1.7.0-sources.jar!/org/apache/flink/table/plan/logical/operators.scala

case class Filter(condition: Expression, child: LogicalNode) extends UnaryNode {
  override def output: Seq[Attribute] = child.output

  override protected[logical] def construct(relBuilder: RelBuilder): RelBuilder = {
    child.construct(relBuilder)
    relBuilder.filter(condition.toRexNode(relBuilder))
  }

  override def validate(tableEnv: TableEnvironment): LogicalNode = {
    val resolvedFilter = super.validate(tableEnv).asInstanceOf[Filter]
    if (resolvedFilter.condition.resultType != BOOLEAN_TYPE_INFO) {
      failValidation(s"Filter operator requires a boolean expression as input," +
        s" but ${resolvedFilter.condition} is of type ${resolvedFilter.condition.resultType}")
    }
    resolvedFilter
  }
}

• Filter对象继承了UnaryNode，它覆盖了output、construct、validate等方法；construct方法先通过Expression.toRexNode将flink的Expression转换为Apache Calcite的RexNode，然后再执行Apache Calcite的RelBuilder的filter方法

RexNode

calcite-core-1.18.0-sources.jar!/org/apache/calcite/rex/RexNode.java

public abstract class RexNode {
  //~ Instance fields --------------------------------------------------------

  // Effectively final. Set in each sub-class constructor, and never re-set.
  protected String digest;

  //~ Methods ----------------------------------------------------------------

  public abstract RelDataType getType();

  public boolean isAlwaysTrue() {
    return false;
  }

  public boolean isAlwaysFalse() {
    return false;
  }

  public boolean isA(SqlKind kind) {
    return getKind() == kind;
  }

  public boolean isA(Collection<SqlKind> kinds) {
    return getKind().belongsTo(kinds);
  }

  public SqlKind getKind() {
    return SqlKind.OTHER;
  }

  public String toString() {
    return digest;
  }

  public abstract <R> R accept(RexVisitor<R> visitor);

  public abstract <R, P> R accept(RexBiVisitor<R, P> visitor, P arg);

  @Override public abstract boolean equals(Object obj);

  @Override public abstract int hashCode();
}

• RexNode是Row expression，可以通过RexBuilder来创建；它有很多子类，比如RexCall、RexVariable、RexFieldAccess等

RelBuilder.filter

calcite-core-1.18.0-sources.jar!/org/apache/calcite/tools/RelBuilder.java

public class RelBuilder {
  protected final RelOptCluster cluster;
  protected final RelOptSchema relOptSchema;
  private final RelFactories.FilterFactory filterFactory;
  private final RelFactories.ProjectFactory projectFactory;
  private final RelFactories.AggregateFactory aggregateFactory;
  private final RelFactories.SortFactory sortFactory;
  private final RelFactories.ExchangeFactory exchangeFactory;
  private final RelFactories.SortExchangeFactory sortExchangeFactory;
  private final RelFactories.SetOpFactory setOpFactory;
  private final RelFactories.JoinFactory joinFactory;
  private final RelFactories.SemiJoinFactory semiJoinFactory;
  private final RelFactories.CorrelateFactory correlateFactory;
  private final RelFactories.ValuesFactory valuesFactory;
  private final RelFactories.TableScanFactory scanFactory;
  private final RelFactories.MatchFactory matchFactory;
  private final Deque<Frame> stack = new ArrayDeque<>();
  private final boolean simplify;
  private final RexSimplify simplifier;

  protected RelBuilder(Context context, RelOptCluster cluster,
      RelOptSchema relOptSchema) {
    this.cluster = cluster;
    this.relOptSchema = relOptSchema;
    if (context == null) {
      context = Contexts.EMPTY_CONTEXT;
    }
    this.simplify = Hook.REL_BUILDER_SIMPLIFY.get(true);
    this.aggregateFactory =
        Util.first(context.unwrap(RelFactories.AggregateFactory.class),
            RelFactories.DEFAULT_AGGREGATE_FACTORY);
    this.filterFactory =
        Util.first(context.unwrap(RelFactories.FilterFactory.class),
            RelFactories.DEFAULT_FILTER_FACTORY);
    this.projectFactory =
        Util.first(context.unwrap(RelFactories.ProjectFactory.class),
            RelFactories.DEFAULT_PROJECT_FACTORY);
    this.sortFactory =
        Util.first(context.unwrap(RelFactories.SortFactory.class),
            RelFactories.DEFAULT_SORT_FACTORY);
    this.exchangeFactory =
        Util.first(context.unwrap(RelFactories.ExchangeFactory.class),
            RelFactories.DEFAULT_EXCHANGE_FACTORY);
    this.sortExchangeFactory =
        Util.first(context.unwrap(RelFactories.SortExchangeFactory.class),
            RelFactories.DEFAULT_SORT_EXCHANGE_FACTORY);
    this.setOpFactory =
        Util.first(context.unwrap(RelFactories.SetOpFactory.class),
            RelFactories.DEFAULT_SET_OP_FACTORY);
    this.joinFactory =
        Util.first(context.unwrap(RelFactories.JoinFactory.class),
            RelFactories.DEFAULT_JOIN_FACTORY);
    this.semiJoinFactory =
        Util.first(context.unwrap(RelFactories.SemiJoinFactory.class),
            RelFactories.DEFAULT_SEMI_JOIN_FACTORY);
    this.correlateFactory =
        Util.first(context.unwrap(RelFactories.CorrelateFactory.class),
            RelFactories.DEFAULT_CORRELATE_FACTORY);
    this.valuesFactory =
        Util.first(context.unwrap(RelFactories.ValuesFactory.class),
            RelFactories.DEFAULT_VALUES_FACTORY);
    this.scanFactory =
        Util.first(context.unwrap(RelFactories.TableScanFactory.class),
            RelFactories.DEFAULT_TABLE_SCAN_FACTORY);
    this.matchFactory =
        Util.first(context.unwrap(RelFactories.MatchFactory.class),
            RelFactories.DEFAULT_MATCH_FACTORY);
    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);
  }

  public RelBuilder filter(RexNode... predicates) {
    return filter(ImmutableList.copyOf(predicates));
  }

  public RelBuilder filter(Iterable<? extends RexNode> predicates) {
    final RexNode simplifiedPredicates =
        simplifier.simplifyFilterPredicates(predicates);
    if (simplifiedPredicates == null) {
      return empty();
    }

    if (!simplifiedPredicates.isAlwaysTrue()) {
      final Frame frame = stack.pop();
      final RelNode filter = filterFactory.createFilter(frame.rel, simplifiedPredicates);
      stack.push(new Frame(filter, frame.fields));
    }
    return this;
  }

  //......

}

• RelBuilder在构造器里头创建了RelFactories.FilterFactory，它提供了两个filter方法，一个是RexNode变长数组参数，一个是RexNode类型的Iterable参数；filter方法首先使用simplifier.simplifyFilterPredicates将RexNode类型的Iterable转为simplifiedPredicates(RexNode)，之后只要simplifiedPredicates.isAlwaysTrue()为false，则取出deque中队首的Frame(LIFO (Last-In-First-Out) stacks)，调用filterFactory.createFilter创建RelNode构造新的Frame，然后重新放入deque的队首

Frame

calcite-core-1.18.0-sources.jar!/org/apache/calcite/tools/RelBuilder.java

  private static class Frame {
    final RelNode rel;
    final ImmutableList<Field> fields;

    private Frame(RelNode rel, ImmutableList<Field> fields) {
      this.rel = rel;
      this.fields = fields;
    }

    private Frame(RelNode rel) {
      String tableAlias = deriveAlias(rel);
      ImmutableList.Builder<Field> builder = ImmutableList.builder();
      ImmutableSet<String> aliases = tableAlias == null
          ? ImmutableSet.of()
          : ImmutableSet.of(tableAlias);
      for (RelDataTypeField field : rel.getRowType().getFieldList()) {
        builder.add(new Field(aliases, field));
      }
      this.rel = rel;
      this.fields = builder.build();
    }

    private static String deriveAlias(RelNode rel) {
      if (rel instanceof TableScan) {
        final List<String> names = rel.getTable().getQualifiedName();
        if (!names.isEmpty()) {
          return Util.last(names);
        }
      }
      return null;
    }

    List<RelDataTypeField> fields() {
      return Pair.right(fields);
    }
  }

• Frame被存放于ArrayDeque中，实际是用于描述上一个操作的关系表达式以及table的别名怎么映射到row type中

RelFactories.FilterFactory.createFilter

calcite-core-1.18.0-sources.jar!/org/apache/calcite/rel/core/RelFactories.java

  public interface FilterFactory {
    /** Creates a filter. */
    RelNode createFilter(RelNode input, RexNode condition);
  }

  private static class FilterFactoryImpl implements FilterFactory {
    public RelNode createFilter(RelNode input, RexNode condition) {
      return LogicalFilter.create(input, condition);
    }
  }

• FilterFactoryImpl实现了FilterFactory接口，createFilter方法执行的是LogicalFilter.create(input, condition)，这里input是RelNode类型(RelNode取的是Frame的rel)，condition是RexNode类型

LogicalFilter

calcite-core-1.18.0-sources.jar!/org/apache/calcite/rel/logical/LogicalFilter.java

public final class LogicalFilter extends Filter {
  private final ImmutableSet<CorrelationId> variablesSet;

  /** Creates a LogicalFilter. */
  public static LogicalFilter create(final RelNode input, RexNode condition) {
    return create(input, condition, ImmutableSet.of());
  }

  /** Creates a LogicalFilter. */
  public static LogicalFilter create(final RelNode input, RexNode condition,
      ImmutableSet<CorrelationId> variablesSet) {
    final RelOptCluster cluster = input.getCluster();
    final RelMetadataQuery mq = cluster.getMetadataQuery();
    final RelTraitSet traitSet = cluster.traitSetOf(Convention.NONE)
        .replaceIfs(RelCollationTraitDef.INSTANCE,
            () -> RelMdCollation.filter(mq, input))
        .replaceIf(RelDistributionTraitDef.INSTANCE,
            () -> RelMdDistribution.filter(mq, input));
    return new LogicalFilter(cluster, traitSet, input, condition, variablesSet);
  }

  //......
}

• LogicalFilter继承了抽象类Filter，Filter继承了SingleRel，SingleRel继承了AbstractRelNode，AbstractRelNode实现了RelNode接口

小结

• Table的where及filter操作均有两中方法，一种是String参数，一种是Expression参数；而where方法内部是调用filter方法；filter方法使用Filter(predicate, logicalPlan).validate(tableEnv)创建了新的Table；String参数最后是通过ExpressionParser.parseExpression方法转换为Expression类型
• Filter对象继承了UnaryNode，它覆盖了output、construct、validate等方法；construct方法先通过Expression.toRexNode将flink的Expression转换为Apache Calcite的RexNode(RexNode是Row expression，可以通过RexBuilder来创建；它有很多子类，比如RexCall、RexVariable、RexFieldAccess等)，然后再执行Apache Calcite的RelBuilder的filter方法
• RelBuilder在构造器里头创建了RelFactories.FilterFactory，它提供了两个filter方法，一个是RexNode变长数组参数，一个是RexNode类型的Iterable参数；filter方法首先使用simplifier.simplifyFilterPredicates将RexNode类型的Iterable转为simplifiedPredicates(RexNode)，之后只要simplifiedPredicates.isAlwaysTrue()为false，则取出deque中队首的Frame(LIFO (Last-In-First-Out) stacks，Frame被存放于ArrayDeque中，实际是用于描述上一个操作的关系表达式以及table的别名怎么映射到row type中)，调用filterFactory.createFilter创建RelNode构造新的Frame，然后重新放入deque的队首；FilterFactoryImpl实现了FilterFactory接口，createFilter方法执行的是LogicalFilter.create(input, condition)，这里input是RelNode类型(RelNode取的是Frame的rel)，condition是RexNode类型(RexNode是Row expression，可以通过RexBuilder来创建；它有很多子类，比如RexCall、RexVariable、RexFieldAccess等)；LogicalFilter继承了抽象类Filter，Filter继承了SingleRel，SingleRel继承了AbstractRelNode，AbstractRelNode实现了RelNode接口

doc

• Operations