Package com.apple.foundationdb.record.provider.foundationdb

Class IndexFunctionHelper

java.lang.Object

com.apple.foundationdb.record.provider.foundationdb.IndexFunctionHelper

@API(INTERNAL)
public class IndexFunctionHelper
extends Object

Helper class for finding appropriate indexes for IndexRecordFunction and IndexAggregateFunction.

Method Summary

Modifier and Type	Method	Description
static Optional<IndexAggregateFunction>	bindAggregateFunction(FDBRecordStore store, IndexAggregateFunction function, List<String> recordTypeNames)
static Optional<IndexAggregateFunction>	bindAggregateFunctionCall(FDBRecordStore store, IndexAggregateFunctionCall functionCall, List<String> recordTypeNames)	(Public) method to bind an IndexAggregateFunctionCall to an index resulting in an IndexAggregateFunction if successful.
protected static Optional<org.apache.commons.lang3.tuple.Pair<IndexAggregateFunction,IndexMaintainer>>	bindIndexForPermutableAggregateFunctionCall(FDBRecordStore store, IndexAggregateFunctionCall functionCall, List<String> recordTypeNames)	Bind a IndexAggregateFunctionCall to an index and return a resulting IndexAggregateFunction and IndexMaintainer.
static IndexAggregateFunction	count(KeyExpression by)
static IndexAggregateFunction	countUpdates(KeyExpression by)
static KeyExpression	getGroupedKey(KeyExpression key)
static KeyExpression	getGroupingKey(KeyExpression key)
protected static KeyExpression	getSubKey(KeyExpression key, int start, int end)
protected static KeyExpression	getThenSubKey(ThenKeyExpression then, int columnStart, int columnEnd)
protected static KeyExpression	groupKey(KeyExpression key)
static Stream<Index>	indexesForRecordTypes(FDBRecordStore store, List<String> recordTypeNames)	The indexes that apply to exactly the given types, no more, no less.
static Stream<Index>	indexesForRecordTypes(RecordMetaData metaData, Collection<String> recordTypeNames)	The indexes that apply to exactly the given types, no more, no less.
static Optional<IndexMaintainer>	indexMaintainerForAggregateFunction(FDBRecordStore store, IndexAggregateFunction function, List<String> recordTypeNames)
static Optional<IndexMaintainer>	indexMaintainerForRecordFunction(FDBRecordStore store, IndexRecordFunction<?> function, FDBRecord<?> record)	Find an index that can evaluate the given function against the given record.
static Optional<IndexMaintainer>	indexMaintainerForRecordFunction(FDBRecordStore store, IndexRecordFunction<?> function, List<String> recordTypeNames)	Find an index that can evaluate the given function against all of the given record types.
static boolean	isGroupPrefix(KeyExpression functionOperand, KeyExpression indexRoot)	Is the operand for this function compatible with this index? The grouped part must match.
static Key.Evaluated	recordFunctionIndexEntry(FDBRecordStore store, Index index, EvaluationContext context, IndexRecordFunction<?> recordFunction, FDBRecord<?> record, int groupSize)	Get the index entry for use by the given index to evaluate the given record function.
static <T> IndexRecordFunction<T>	recordFunctionWithSubrecordCondition(FDBRecordStore store, IndexRecordFunction<T> recordFunction, FDBRecord<?> record, QueryComponent condition)	Given an index record function and condition on repeated fields (such as a key for a map-like field), return a function suitable for use with recordFunctionIndexEntry(com.apple.foundationdb.record.provider.foundationdb.FDBRecordStore, com.apple.foundationdb.record.metadata.Index, com.apple.foundationdb.record.EvaluationContext, com.apple.foundationdb.record.metadata.IndexRecordFunction<?>, com.apple.foundationdb.record.provider.foundationdb.FDBRecord<?>, int) to get the matching index entry.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

indexMaintainerForRecordFunction

public static Optional<IndexMaintainer> indexMaintainerForRecordFunction(@Nonnull
                                                                         FDBRecordStore store,
                                                                         @Nonnull
                                                                         IndexRecordFunction<?> function,
                                                                         @Nonnull
                                                                         FDBRecord<?> record)

Find an index that can evaluate the given function against the given record.

Parameters:

store - the record store containing the record

function - the function to evaluate

record - the record to evaluate against

Returns:

an index maintainer that can evaluate the function or Optional.empty()

indexMaintainerForRecordFunction

public static Optional<IndexMaintainer> indexMaintainerForRecordFunction(@Nonnull
                                                                         FDBRecordStore store,
                                                                         @Nonnull
                                                                         IndexRecordFunction<?> function,
                                                                         @Nonnull
                                                                         List<String> recordTypeNames)

Find an index that can evaluate the given function against all of the given record types.

Parameters:

store - the record store containing the record types

function - the function to evaluate

recordTypeNames - the names of all the record types for which the function will be evaluated

Returns:

an index maintainer that can evaluate the function or Optional.empty()

indexMaintainerForAggregateFunction

public static Optional<IndexMaintainer> indexMaintainerForAggregateFunction(@Nonnull
                                                                            FDBRecordStore store,
                                                                            @Nonnull
                                                                            IndexAggregateFunction function,
                                                                            @Nonnull
                                                                            List<String> recordTypeNames)

bindIndexForPermutableAggregateFunctionCall

protected static Optional<org.apache.commons.lang3.tuple.Pair<IndexAggregateFunction,IndexMaintainer>> bindIndexForPermutableAggregateFunctionCall(@Nonnull
                                                                                                                                                         FDBRecordStore store,
                                                                                                                                                         @Nonnull
                                                                                                                                                         IndexAggregateFunctionCall functionCall,
                                                                                                                                                         @Nonnull
                                                                                                                                                         List<String> recordTypeNames)

Bind a IndexAggregateFunctionCall to an index and return a resulting IndexAggregateFunction and IndexMaintainer. During the binding process we enumerate all indexes and for each such index we enumerate all permutations of grouping expressions in order to find an index that can be used to evaluated the aggregate function call.

Parameters:

store - the store containing the record types

functionCall - an IndexAggregateFunctionCall

recordTypeNames - the names of the record types for which indexes need to be considered

Returns:

an optional of a bound IndexAggregateFunction and a IndexMaintainer if a matching index was found, Optional.empty() otherwise.

indexesForRecordTypes

public static Stream<Index> indexesForRecordTypes(@Nonnull
                                                  FDBRecordStore store,
                                                  @Nonnull
                                                  List<String> recordTypeNames)

The indexes that apply to exactly the given types, no more, no less.

Parameters:

store - the store containing the record types

recordTypeNames - the names of the record types for which indexes are needed

Returns:

a stream of indexes

indexesForRecordTypes

public static Stream<Index> indexesForRecordTypes(@Nonnull
                                                  RecordMetaData metaData,
                                                  @Nonnull
                                                  Collection<String> recordTypeNames)

The indexes that apply to exactly the given types, no more, no less.

Parameters:

metaData - the meta-data containing the record types

recordTypeNames - the names of the record types for which indexes are needed

Returns:

a stream of indexes

isGroupPrefix

public static boolean isGroupPrefix(@Nonnull
                                    KeyExpression functionOperand,
                                    @Nonnull
                                    KeyExpression indexRoot)

Is the operand for this function compatible with this index? The grouped part must match. The grouping part must be a prefix.

Parameters:

functionOperand - the operand to the function

indexRoot - the index's expression

Returns:

true if the operand is compatible with the index

getGroupedKey

public static KeyExpression getGroupedKey(@Nonnull
                                          KeyExpression key)

getGroupingKey

public static KeyExpression getGroupingKey(@Nonnull
                                           KeyExpression key)

groupKey

protected static KeyExpression groupKey(@Nonnull
                                        KeyExpression key)

getSubKey

protected static KeyExpression getSubKey(KeyExpression key,
                                         int start,
                                         int end)

getThenSubKey

protected static KeyExpression getThenSubKey(ThenKeyExpression then,
                                             int columnStart,
                                             int columnEnd)

count

public static IndexAggregateFunction count(@Nonnull
                                           KeyExpression by)

countUpdates

public static IndexAggregateFunction countUpdates(@Nonnull
                                                  KeyExpression by)

bindAggregateFunction

public static Optional<IndexAggregateFunction> bindAggregateFunction(@Nonnull
                                                                     FDBRecordStore store,
                                                                     @Nonnull
                                                                     IndexAggregateFunction function,
                                                                     @Nonnull
                                                                     List<String> recordTypeNames)

bindAggregateFunctionCall

public static Optional<IndexAggregateFunction> bindAggregateFunctionCall(@Nonnull
                                                                         FDBRecordStore store,
                                                                         @Nonnull
                                                                         IndexAggregateFunctionCall functionCall,
                                                                         @Nonnull
                                                                         List<String> recordTypeNames)

(Public) method to bind an IndexAggregateFunctionCall to an index resulting in an IndexAggregateFunction if successful. See bindIndexForPermutableAggregateFunctionCall(FDBRecordStore, IndexAggregateFunctionCall, List) for details.

Parameters:

store - the store containing the record types

functionCall - an IndexAggregateFunctionCall

recordTypeNames - the names of the record types for which indexes need to be considered

Returns:

an optional of a bound IndexAggregateFunction if a matching index was found, Optional.empty() otherwise.

recordFunctionWithSubrecordCondition

@Nonnull
public static <T> IndexRecordFunction<T> recordFunctionWithSubrecordCondition(@Nonnull
                                                                              FDBRecordStore store,
                                                                              @Nonnull
                                                                              IndexRecordFunction<T> recordFunction,
                                                                              @Nonnull
                                                                              FDBRecord<?> record,
                                                                              @Nonnull
                                                                              QueryComponent condition)

Given an index record function and condition on repeated fields (such as a key for a map-like field), return a function suitable for use with recordFunctionIndexEntry(com.apple.foundationdb.record.provider.foundationdb.FDBRecordStore, com.apple.foundationdb.record.metadata.Index, com.apple.foundationdb.record.EvaluationContext, com.apple.foundationdb.record.metadata.IndexRecordFunction<?>, com.apple.foundationdb.record.provider.foundationdb.FDBRecord<?>, int) to get the matching index entry.

Type Parameters:

T - return type of function

Parameters:

store - store against which function will be evaluated

recordFunction - function to be evaluated

record - record against which to evaluate

condition - condition on fields of index entry

Returns:

a new function that remembers the condition for matching

recordFunctionIndexEntry

@Nullable
public static Key.Evaluated recordFunctionIndexEntry(@Nonnull
                                                     FDBRecordStore store,
                                                     @Nonnull
                                                     Index index,
                                                     @Nonnull
                                                     EvaluationContext context,
                                                     @Nullable
                                                     IndexRecordFunction<?> recordFunction,
                                                     @Nonnull
                                                     FDBRecord<?> record,
                                                     int groupSize)

Get the index entry for use by the given index to evaluate the given record function. In most cases, this is the same as KeyExpression.evaluateSingleton(com.apple.foundationdb.record.provider.foundationdb.FDBRecord<M>). But if recordFunction is the result of recordFunctionWithSubrecordCondition(com.apple.foundationdb.record.provider.foundationdb.FDBRecordStore, com.apple.foundationdb.record.metadata.IndexRecordFunction<T>, com.apple.foundationdb.record.provider.foundationdb.FDBRecord<?>, com.apple.foundationdb.record.query.expressions.QueryComponent), a matching entry will be found.

Parameters:

store - store against which function will be evaluated

index - index for which to evaluate

context - context for parameter bindings

recordFunction - record function for which to evaluate

record - record against which to evaluate

groupSize - grouping size for the given index

Returns:

an index entry or null if none matches a bound condition