java.lang.Object
- com.apple.foundationdb.record.query.plan.temp.matchers.TypeMatcher<T>

Type Parameters:

T - the planner expression type that this matcher binds to

All Implemented Interfaces:

ExpressionMatcher<T>

Direct Known Subclasses:

MatchPartitionMatcher, PartialMatchMatcher, QuantifierMatcher, TypeWithPredicateMatcher
```
@API(EXPERIMENTAL)
public class TypeMatcher<T extends Bindable>
extends Object
implements ExpressionMatcher<T>
```
A matcher that is specified by the class of its expression: to match any of several types of expressions, they must all implement a common interface (which itself extends PlannerExpression). The bindings produced by this matcher provide access to a single expression only, and allow it to be accessed by the rule.

Nested Class Summary
- Nested classes/interfaces inherited from interface com.apple.foundationdb.record.query.plan.temp.matchers.ExpressionMatcher
  ExpressionMatcher.DefaultMatcher<T extends Bindable>

Constructor Summary

Constructors
Modifier Constructor Description

protected TypeMatcher(Class<? extends T> bindableClass, ExpressionChildrenMatcher childrenMatcher)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`ExpressionChildrenMatcher`	`getChildrenMatcher()`
`Class<? extends Bindable>`	`getRootClass()`	Get a class or interface extending `RelationalExpression` that is a super class of every planner expression that this matcher can match.
`Stream<PlannerBindings>`	`matchWith(PlannerBindings outerBindings, ExpressionRef<? extends RelationalExpression> ref, List<? extends Bindable> children)`	Attempt to match this matcher against the given expression reference.
`Stream<PlannerBindings>`	`matchWith(PlannerBindings outerBindings, MatchPartition matchPartition, List<? extends Bindable> children)`	Attempt to match this matcher against the given `MatchPartition`.
`Stream<PlannerBindings>`	`matchWith(PlannerBindings outerBindings, PartialMatch partialMatch, List<? extends Bindable> children)`	Attempt to match this matcher against the given `PartialMatch`.
`Stream<PlannerBindings>`	`matchWith(PlannerBindings outerBindings, Quantifier quantifier, List<? extends Bindable> children)`	Attempt to match this matcher against the given `Quantifier`.
`Stream<PlannerBindings>`	`matchWith(PlannerBindings outerBindings, RelationalExpression expression, List<? extends Bindable> children)`	Attempt to match this matcher against the given `ExpressionMatcher`.
`Stream<PlannerBindings>`	`matchWith(PlannerBindings outerBindings, QueryPredicate predicate, List<? extends Bindable> children)`	Attempt to match this matcher against the given `QueryPredicate`.
`static <U extends Bindable> TypeMatcher<U>`	`of(Class<? extends U> expressionClass)`
`static <U extends Bindable> TypeMatcher<U>`	`of(Class<? extends U> expressionClass, ExpressionChildrenMatcher childrenMatcher)`
`static <U extends Bindable> TypeMatcher<U>`	`of(Class<? extends U> expressionClass, ExpressionMatcher<? extends Bindable>... children)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

TypeMatcher

protected TypeMatcher(@Nonnull
                      Class<? extends T> bindableClass,
                      @Nonnull
                      ExpressionChildrenMatcher childrenMatcher)

Method Detail

getRootClass
```
@Nonnull
public Class<? extends Bindable> getRootClass()
```
Description copied from interface: ExpressionMatcher

Get a class or interface extending RelationalExpression that is a super class of every planner expression that this matcher can match. Ideally, it should be the lowest such class but it may not be. A planner will generally use this method to quickly determine a set of rules that could match an expression, without considering each rule and trying to apply it. A good implementation of this method helps the planner match rules efficiently.

Specified by:

getRootClass in interface ExpressionMatcher<T extends Bindable>

Returns:

a class object for a class that is a super class of every planner expression this matcher can match

getChildrenMatcher

@Nonnull
public ExpressionChildrenMatcher getChildrenMatcher()

of

public static <U extends Bindable> TypeMatcher<U> of(@Nonnull
                                                     Class<? extends U> expressionClass)

of

@SafeVarargs
public static <U extends Bindable> TypeMatcher<U> of(@Nonnull
                                                     Class<? extends U> expressionClass,
                                                     @Nonnull
                                                     ExpressionMatcher<? extends Bindable>... children)

of

public static <U extends Bindable> TypeMatcher<U> of(@Nonnull
                                                     Class<? extends U> expressionClass,
                                                     @Nonnull
                                                     ExpressionChildrenMatcher childrenMatcher)

matchWith
```
@Nonnull
public Stream<PlannerBindings> matchWith(@Nonnull
                                         PlannerBindings outerBindings,
                                         @Nonnull
                                         ExpressionRef<? extends RelationalExpression> ref,
                                         @Nonnull
                                         List<? extends Bindable> children)
```
Description copied from interface: ExpressionMatcher

Attempt to match this matcher against the given expression reference. Note that implementations of matchWith() should only attempt to match the given root with this planner expression or attempt to access the members of the given reference.

Specified by:

matchWith in interface ExpressionMatcher<T extends Bindable>

Parameters:

outerBindings - preexisting bindings to be used by the matcher

ref - a reference to match with

children - the conceptual children of ref, i.e. the memmbers of the group reference.

Returns:

a stream of PlannerBindings containing the matched bindings, or an empty stream is no match was found