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