聊聊flink Table的where及filter操作

go4it發表於2019-01-24

本文主要研究一下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

相關文章