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

Interface ExpressionRef<T extends RelationalExpression>

Type Parameters:

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

All Superinterfaces:

Bindable

All Known Implementing Classes:

GroupExpressionRef

@API(EXPERIMENTAL)
public interface ExpressionRef<T extends RelationalExpression>
extends Bindable

This interface is used mostly as an (admittedly surmountable) barrier to rules mutating bound references directly, which is undefined behavior.

Nested Class Summary

Nested Classes

Modifier and Type	Interface	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	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 RelationalExpression> otherRef)
<U extends RelationalExpression> ExpressionRef<U>	flatMapNullable(Function<T,ExpressionRef<U>> nullableFunc)
T	get()	Return the expression contained in this reference.
RelationalExpressionPointerSet<T>	getMembers()
ExpressionRef<T>	getNewRefWith(T expression)
void	insert(T newValue)
<U extends RelationalExpression> ExpressionRef<U>	map(Function<T,U> func)

Method Detail

insert

void insert(@Nonnull
            T newValue)

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

@Nullable
<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 RelationalExpression 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 RelationalExpression> ExpressionRef<U> map(@Nonnull
                                                      Function<T,U> func)

flatMapNullable

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

getNewRefWith

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

containsAllInMemo

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

getMembers

RelationalExpressionPointerSet<T> getMembers()