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

Class RecordQueryFilterPlan

java.lang.Object

com.apple.foundationdb.record.query.plan.plans.RecordQueryFilterPlan

All Implemented Interfaces:

PlanHashable, QueryPlan<FDBQueriedRecord<Message>>, RecordQueryPlan, RecordQueryPlanWithChild, RecordQueryPlanWithChildren, Bindable, Correlated<RelationalExpression>, PlannerGraphRewritable, RelationalExpressionWithChildren, RelationalExpression

@API(INTERNAL)
public class RecordQueryFilterPlan
extends Object

A query plan that filters out records from a child plan that do not satisfy a filter component.

Nested Class Summary

Nested classes/interfaces inherited from interface com.apple.foundationdb.record.query.plan.temp.Correlated

Correlated.BoundEquivalence

Nested classes/interfaces inherited from interface com.apple.foundationdb.record.PlanHashable

PlanHashable.PlanHashKind

Nested classes/interfaces inherited from interface com.apple.foundationdb.record.query.plan.temp.RelationalExpression

RelationalExpression.CombineFunction<R,S>, RelationalExpression.CombinePredicate

Field Summary

Fields

Modifier and Type	Field	Description
static org.slf4j.Logger	LOGGER

Fields inherited from interface com.apple.foundationdb.record.query.plan.plans.QueryPlan

UNKNOWN_MAX_CARDINALITY

Constructor Summary

Constructors

Constructor	Description
RecordQueryFilterPlan(RecordQueryPlan inner, QueryComponent filter)
RecordQueryFilterPlan(RecordQueryPlan inner, List<QueryComponent> filters)
RecordQueryFilterPlan(Quantifier.Physical inner, List<QueryComponent> filters)

Method Summary

Modifier and Type	Method	Description
boolean	equals(Object other)
boolean	equalsWithoutChildren(RelationalExpression otherExpression, AliasMap equivalencesMap)
protected <M extends Message> Boolean	evalFilter(FDBRecordStoreBase<M> store, EvaluationContext context, FDBRecord<M> record)
protected <M extends Message> CompletableFuture<Boolean>	evalFilterAsync(FDBRecordStoreBase<M> store, EvaluationContext context, FDBRecord<M> record)
<M extends Message> RecordCursor<FDBQueriedRecord<M>>	execute(FDBRecordStoreBase<M> store, EvaluationContext context, byte[] continuation, ExecuteProperties executeProperties)	Execute this query plan.
RecordQueryPlan	getChild()
int	getComplexity()	Returns an integer representing the "complexity" of the generated plan.
Set<CorrelationIdentifier>	getCorrelatedToWithoutChildren()
QueryComponent	getFilter()
List<QueryComponent>	getFilters()
Quantifier.Physical	getInner()
RecordQueryPlan	getInnerPlan()
List<? extends Quantifier>	getQuantifiers()	Return an iterator of references to the children of this planner expression.
Set<String>	getUsedIndexes()	Returns a set of names of the indexes used by this plan (and its sub-plans).
protected boolean	hasAsyncFilter()
boolean	hasFullRecordScan()	Indicates whether this plan (or one of its components) must perform a scan over all records in the store directly rather than going through a secondary index.
int	hashCode()
int	hashCodeWithoutChildren()
boolean	hasIndexScan(String indexName)	Indicates whether this plan scans the given index.
boolean	hasRecordScan()	Indicates whether this plan (or one of its components) scans at least a subset of the record range directly rather than going through a secondary index.
boolean	isReverse()	Indicates whether this plan will return values in "reverse" order from the natural order of results of this plan.
void	logPlanStructure(StoreTimer timer)	Adds one to an appropriate StoreTimer counter for each plan and subplan of this plan, allowing tracking of which plans are being chosen (e.g.
int	planHash(PlanHashable.PlanHashKind hashKind)	Return a hash similar to hashCode, but with the additional guarantee that is is stable across JVMs.
RecordQueryFilterPlan	rebaseWithRebasedQuantifiers(AliasMap translationMap, List<Quantifier> rebasedQuantifiers)
PlannerGraph	rewritePlannerGraph(List<? extends PlannerGraph> childGraphs)	Method to rewrite the planner graph.
String	toString()
RecordQueryPlanWithChild	withChild(RecordQueryPlan child)

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.apple.foundationdb.record.PlanHashable

planHash

Methods inherited from interface com.apple.foundationdb.record.query.plan.plans.QueryPlan

execute, execute

Methods inherited from interface com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan

accept, execute, execute, execute, getQueryPlanChildren, structuralEquals, structuralEquals, structuralHashCode

Methods inherited from interface com.apple.foundationdb.record.query.plan.plans.RecordQueryPlanWithChild

getAvailableFields, getChildren, getRelationalChildCount, hasLoadBykeys, isStrictlySorted, maxCardinality, strictlySorted

Methods inherited from interface com.apple.foundationdb.record.query.plan.temp.RelationalExpression

acceptPropertyVisitor, adjustMatch, bindIdentities, bindTo, canCorrelate, compensate, enumerateUnboundCorrelatedTo, exactlySubsumedBy, findMatches, getResultValues, hasIncompatibleBoundQuantifiers, hasUnboundQuantifiers, match, match, semanticEquals, semanticEquals, semanticHashCode, show, subsumedBy

Methods inherited from interface com.apple.foundationdb.record.query.plan.temp.expressions.RelationalExpressionWithChildren

getCorrelatedTo, rebase

Field Detail

LOGGER

public static final org.slf4j.Logger LOGGER

Constructor Detail

RecordQueryFilterPlan

public RecordQueryFilterPlan(@Nonnull
                             RecordQueryPlan inner,
                             @Nonnull
                             List<QueryComponent> filters)

RecordQueryFilterPlan

public RecordQueryFilterPlan(@Nonnull
                             RecordQueryPlan inner,
                             @Nonnull
                             QueryComponent filter)

RecordQueryFilterPlan

public RecordQueryFilterPlan(@Nonnull
                             Quantifier.Physical inner,
                             @Nonnull
                             List<QueryComponent> filters)

Method Detail

hasAsyncFilter

protected boolean hasAsyncFilter()

evalFilter

@Nullable
protected <M extends Message> Boolean evalFilter(@Nonnull
                                                 FDBRecordStoreBase<M> store,
                                                 @Nonnull
                                                 EvaluationContext context,
                                                 @Nullable
                                                 FDBRecord<M> record)

evalFilterAsync

@Nullable
protected <M extends Message> CompletableFuture<Boolean> evalFilterAsync(@Nonnull
                                                                         FDBRecordStoreBase<M> store,
                                                                         @Nonnull
                                                                         EvaluationContext context,
                                                                         @Nullable
                                                                         FDBRecord<M> record)

isReverse

public boolean isReverse()

Description copied from interface: QueryPlan

Indicates whether this plan will return values in "reverse" order from the natural order of results of this plan. The return value is true if the plan returns elements in descending order and false if the elements are returned in ascending order.

Specified by:

isReverse in interface QueryPlan<FDBQueriedRecord<Message>>

Returns:

true if this plan returns elements in reverse order

toString

@Nonnull
public String toString()

Overrides:

toString in class Object

getCorrelatedToWithoutChildren

@Nonnull
public Set<CorrelationIdentifier> getCorrelatedToWithoutChildren()

rebaseWithRebasedQuantifiers

@Nonnull
public RecordQueryFilterPlan rebaseWithRebasedQuantifiers(@Nonnull
                                                          AliasMap translationMap,
                                                          @Nonnull
                                                          List<Quantifier> rebasedQuantifiers)

withChild

@Nonnull
public RecordQueryPlanWithChild withChild(@Nonnull
                                          RecordQueryPlan child)

equalsWithoutChildren

public boolean equalsWithoutChildren(@Nonnull
                                     RelationalExpression otherExpression,
                                     @Nonnull
                                     AliasMap equivalencesMap)

equals

public boolean equals(Object other)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

hashCodeWithoutChildren

public int hashCodeWithoutChildren()

planHash

public int planHash(@Nonnull
                    PlanHashable.PlanHashKind hashKind)

Description copied from interface: PlanHashable

Return a hash similar to hashCode, but with the additional guarantee that is is stable across JVMs.

Parameters:

hashKind - the "kind" of hash to calculate. Each kind of hash has a particular logic with regards to included and excluded items.

Returns:

a stable hash code

getFilters

@Nonnull
public List<QueryComponent> getFilters()

getFilter

@Nonnull
public QueryComponent getFilter()

rewritePlannerGraph

@Nonnull
public PlannerGraph rewritePlannerGraph(@Nonnull
                                        List<? extends PlannerGraph> childGraphs)

Description copied from interface: PlannerGraphRewritable

Method to rewrite the planner graph.

Parameters:

childGraphs - planner graphs of children expression that already have been computed

Returns:

a new planner graph that can combine the childGraphs in a meaningful way. Note that there is no obligation to use the childGraphs at all, this method can create a new independent planner graph completely from scratch.

execute

@Nonnull
public <M extends Message> RecordCursor<FDBQueriedRecord<M>> execute(@Nonnull
                                                                     FDBRecordStoreBase<M> store,
                                                                     @Nonnull
                                                                     EvaluationContext context,
                                                                     @Nullable
                                                                     byte[] continuation,
                                                                     @Nonnull
                                                                     ExecuteProperties executeProperties)

Description copied from interface: RecordQueryPlan

Execute this query plan.

Specified by:

execute in interface RecordQueryPlan

Type Parameters:

M - type used to represent stored records

Parameters:

store - record store from which to fetch records

context - evaluation context containing parameter bindings

continuation - continuation from a previous execution of this same plan

executeProperties - limits on execution

Returns:

a cursor of records that match the query criteria

getInner

@Nonnull
public Quantifier.Physical getInner()

getInnerPlan

@Nonnull
public RecordQueryPlan getInnerPlan()

getQuantifiers

@Nonnull
public List<? extends Quantifier> getQuantifiers()

Description copied from interface: RelationalExpression

Return an iterator of references to the children of this planner expression. The iterators returned by different calls are guaranteed to be independent (i.e., advancing one will not advance another). However, they might point to the same object, as when Collections.emptyIterator() is returned. The returned iterator should be treated as an immutable object and may throw an exception if Iterator.remove() is called. The iterator must return its elements in a consistent order.

Specified by:

getQuantifiers in interface RelationalExpression

Returns:

an iterator of references to the children of this planner expression

hasRecordScan

public boolean hasRecordScan()

Description copied from interface: QueryPlan

Indicates whether this plan (or one of its components) scans at least a subset of the record range directly rather than going through a secondary index. A plan may only scan over a subset of all records. Someone might not use any secondary indexes explicitly, but they might make use of the primary key index. For example, if they had a compound primary key, and they issued a query for all records that had some value for the first element of their primary key, the planner will produce a plan which scans over a subset of all records.

Specified by:

hasRecordScan in interface QueryPlan<FDBQueriedRecord<Message>>

Specified by:

hasRecordScan in interface RecordQueryPlanWithChild

Specified by:

hasRecordScan in interface RecordQueryPlanWithChildren

Returns:

true if this plan (or one of its components) scans at least a subset of the records directly

hasFullRecordScan

public boolean hasFullRecordScan()

Description copied from interface: QueryPlan

Indicates whether this plan (or one of its components) must perform a scan over all records in the store directly rather than going through a secondary index. See hasRecordScan for the comparison between two methods.

Specified by:

hasFullRecordScan in interface QueryPlan<FDBQueriedRecord<Message>>

Specified by:

hasFullRecordScan in interface RecordQueryPlanWithChild

Specified by:

hasFullRecordScan in interface RecordQueryPlanWithChildren

Returns:

true if this plan (or one of its components) must perform a scan over all records in the store directly

hasIndexScan

public boolean hasIndexScan(@Nonnull
                            String indexName)

Description copied from interface: QueryPlan

Indicates whether this plan scans the given index.

Specified by:

hasIndexScan in interface QueryPlan<FDBQueriedRecord<Message>>

Specified by:

hasIndexScan in interface RecordQueryPlanWithChild

Specified by:

hasIndexScan in interface RecordQueryPlanWithChildren

Parameters:

indexName - the name of the index to check for

Returns:

true if this plan (or one of its children) scans the given index

getUsedIndexes

@Nonnull
public Set<String> getUsedIndexes()

Description copied from interface: QueryPlan

Returns a set of names of the indexes used by this plan (and its sub-plans).

Specified by:

getUsedIndexes in interface QueryPlan<FDBQueriedRecord<Message>>

Specified by:

getUsedIndexes in interface RecordQueryPlanWithChild

Specified by:

getUsedIndexes in interface RecordQueryPlanWithChildren

Returns:

an set of indexes used by this plan

getChild

@Nonnull
public RecordQueryPlan getChild()

Specified by:

getChild in interface RecordQueryPlanWithChild

logPlanStructure

public void logPlanStructure(StoreTimer timer)

Description copied from interface: QueryPlan

Adds one to an appropriate StoreTimer counter for each plan and subplan of this plan, allowing tracking of which plans are being chosen (e.g. index scan vs. full scan).

Specified by:

logPlanStructure in interface QueryPlan<FDBQueriedRecord<Message>>

Parameters:

timer - the counters to increment

getComplexity

public int getComplexity()

Description copied from interface: QueryPlan

Returns an integer representing the "complexity" of the generated plan. Currently, this should simply be the number of plans in the plan tree with this plan as the root (i.e. the number of descendants of this plan, including itself).

Specified by:

getComplexity in interface QueryPlan<FDBQueriedRecord<Message>>

Returns:

the complexity of this plan