com.apple.foundationdb.record.query.plan.temp

Interface ExpressionRef<T extends PlannerExpression>

Type Parameters:

T - the type of planner expression that is contained in this reference

All Superinterfaces:

Bindable

All Known Subinterfaces:

MutableExpressionRef<T>

All Known Implementing Classes:

GroupExpressionRef, SingleExpressionRef

@API(value=EXPERIMENTAL)
public interface ExpressionRef<T extends PlannerExpression>
extends Bindable

This interface is used mostly as an (admittedly surmountable) barrier to rules mutating bound references directly, which is undefined behavior. Unlike MutableExpressionRef, it does not provide an insert() method, so the rule would need to cast the reference back to MutableExpressionRef before modifying it.

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	ExpressionRef.UngettableReferenceException An exception thrown when get() is called on a reference that does not support it, such as a group reference.

Method Summary

Modifier and Type	Method and Description
<U> U	acceptPropertyVisitor(PlannerProperty<U> property)
default Stream<PlannerBindings>	bindTo(ExpressionMatcher<? extends Bindable> matcher) Try to bind the given matcher to this reference.
Stream<PlannerBindings>	bindWithin(ExpressionMatcher<? extends Bindable> matcher) Try to bind the given matcher to the members of this reference.
boolean	containsAllInMemo(ExpressionRef<? extends PlannerExpression> otherRef)
<U extends PlannerExpression> ExpressionRef<U>	flatMapNullable(Function<T,ExpressionRef<U>> nullableFunc)
T	get() Return the expression contained in this reference.
PlannerExpressionPointerSet<T>	getMembers()
ExpressionRef<T>	getNewRefWith(T expression)
<U extends PlannerExpression> ExpressionRef<U>	map(Function<T,U> func)

Method Detail

get

@Nonnull
T get()

Return the expression contained in this reference. If the reference does not support getting its expresssion (for example, because it holds more than one expression, or none at all), this should throw an exception.

Returns:

the expression contained in this reference

Throws:

ExpressionRef.UngettableReferenceException - if the reference does not support retrieving its expression

acceptPropertyVisitor

<U> U acceptPropertyVisitor(@Nonnull
                            PlannerProperty<U> property)

bindTo

@Nonnull
default Stream<PlannerBindings> bindTo(@Nonnull
                                                ExpressionMatcher<? extends Bindable> matcher)

Try to bind the given matcher to this reference. It should not try to match to the members of the reference; if the given matcher needs to match to a PlannerExpression rather than an ExpressionRef, it will call bindWithin(ExpressionMatcher) instead.

Binding to references can be a bit subtle: some matchers (such as ReferenceMatcher) can bind to references directly while others (such as TypeMatcher) can't, since they need access to the underlying operator which might not even be well defined. This method implements binding to the reference, rather than to its member(s).

Specified by:

bindTo in interface Bindable

Parameters:

matcher - a matcher to match with

Returns:

a stream of bindings if the match succeeded or an empty stream if it failed

bindWithin

@Nonnull
Stream<PlannerBindings> bindWithin(@Nonnull
                                            ExpressionMatcher<? extends Bindable> matcher)

Try to bind the given matcher to the members of this reference. If this reference has more than one member, it should try to match to any of them and produce a stream of bindings covering all possible combinations. If possible, this should be done in a lazy fashion using the Stream API, so as to minimize unnecessary work.

Parameters:

matcher - an expression matcher to match the member(s) of this reference with

Returns:

a stream of bindings if the match succeeded or an empty stream if it failed

map

@Nonnull
<U extends PlannerExpression> ExpressionRef<U> map(@Nonnull
                                                            Function<T,U> func)

flatMapNullable

@Nullable
<U extends PlannerExpression> ExpressionRef<U> flatMapNullable(@Nonnull
                                                                         Function<T,ExpressionRef<U>> nullableFunc)

getNewRefWith

@Nonnull
ExpressionRef<T> getNewRefWith(@Nonnull
                                        T expression)

containsAllInMemo

boolean containsAllInMemo(@Nonnull
                          ExpressionRef<? extends PlannerExpression> otherRef)

getMembers

PlannerExpressionPointerSet<T> getMembers()