聊聊flink Table的where及filter操做

時間 2020-01-01

標籤聊聊 flink table filter 简体版

原文原文鏈接

序

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

Table

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

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.scalaexpress

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.javaapache

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.javaapi

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.javaide

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.javaui

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

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。