All Classes

Class	Description
AbsorptionRule<P extends AndOrPredicate>	A rule that matches an AndPredicate or OrPredicate and attempts to simplify the terms underneath according to the boolean absorption law.
AbstractArrayConstructorValue	A Value that encapsulates its homogeneous children Values into a single Type.Array typed Value.
AbstractArrayConstructorValue.ArrayFn	The array function.
AbstractArrayConstructorValue.LightArrayConstructorValue	An array that does not need any nested proto constructed.
AbstractArrayConstructorValue.LightArrayConstructorValue.Deserializer	Deserializer.
AbstractDataAccessRule<R extends RelationalExpression>	A rule that utilizes index matching information compiled by CascadesPlanner to create one or more expressions for data access.
AbstractPlannerGraph<N extends AbstractPlannerGraph.AbstractNode,E extends AbstractPlannerGraph.AbstractEdge>	The planner graph class.
AbstractPlannerGraph.AbstractEdge	Edge class.
AbstractPlannerGraph.AbstractNode	Node class functioning as parent for all nodes in the network.
AbstractPlannerGraph.PlannerGraphBuilder<N extends AbstractPlannerGraph.AbstractNode,E extends AbstractPlannerGraph.AbstractEdge,B extends AbstractPlannerGraph<N,E>>	Builder class for planner graph.
AbstractQueryPredicate	Abstract implementation of QueryPredicate that provides memoization of correlatedTo sets.
AbstractQueryPredicateRule<RESULT,CALL extends AbstractQueryPredicateRuleCall<RESULT,CALL>,TYPE extends QueryPredicate>	Tag class to bind the base BASE to QueryPredicate.
AbstractQueryPredicateRuleCall<RESULT,CALL extends AbstractQueryPredicateRuleCall<RESULT,CALL>>	A rule call tag sub class for the simplification of QueryPredicate trees.
AbstractQueryPredicateRuleSet<R,C extends AbstractQueryPredicateRuleCall<R,C>>	A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
AbstractRule<RESULT,CALL extends AbstractRuleCall<RESULT,CALL,BASE>,BASE,TYPE extends BASE>	The rule matching occurs in two stages: first, the planner examines the AbstractRule.matcher of the rule, which is a BindingMatcher expression that expresses the operators that the rule applies to and the hierarchical structure that they take on in the expression tree.
AbstractRuleCall<RESULT,CALL extends AbstractRuleCall<RESULT,CALL,BASE>,BASE>	A rule call implementation for the simplification of Value trees.
AbstractRuleSet<RESULT,CALL extends AbstractRuleCall<RESULT,CALL,BASE>,BASE>	A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
AbstractValue	Abstract implementation of Value that provides memoization of correlatedTo sets.
AbstractValueRule<RESULT,CALL extends AbstractValueRuleCall<RESULT,CALL>,TYPE extends Value>	Tag class to bind the base BASE to Value.
AbstractValueRuleCall<RESULT,CALL extends AbstractValueRuleCall<RESULT,CALL>>	A rule call implementation for the simplification of Value trees.
AbstractValueRuleSet<R,C extends AbstractValueRuleCall<R,C>>	A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
AccessHint	Interface to represent an access hint.
AccessHints	Represents a set of AccessHint a query or a match candidate has.
Accumulator	An aggregate accumulator.
AccumulatorState<T,R>	This interface presents a state af an accumulated value.
AdjustMatchRule	A rule that attempts to improve an existing PartialMatch by absorbing an expression on the candidate side.
AggregateAccumulator	This interface encapsulates the aggregation operator behavior: It holds onto the current state and applies a new record onto the current state to arrive at the new accumulated state.
AggregateCursor<M extends Message>	A cursor that groups incoming records by the given grouping criteria.
AggregateFunctionNotSupportedException	Exception thrown when an aggregate function is not supported.
AggregateIndexExpansionVisitor	Expands an aggregate index into a MatchCandidate.
AggregateIndexMatchCandidate	Case class that represents a grouping index with aggregate function(s).
AggregateValue	A value representing an aggregate: a value calculated (derived) from other values by applying an aggregation operator (e.g.
AliasMap	This class encapsulates mappings between CorrelationIdentifiers and helpers to create and maintain these mappings.
AliasMap.Builder	Builder class for the AliasMap.
AllOfMatcher<T>	A matcher that only matches anything if all of its downstream matchers produce bindings.
AndComponent	A QueryComponent that is satisfied when all of its child components are satisfied.
AndOrComponent	The common base class for Boolean And and Or query components.
AndOrPredicate	Common base class for predicates with many children, such as AndPredicate and OrPredicate.
AndOrValue	A Value that applies conjunction/disjunction on its boolean children, and if possible, simplifies its boolean children.
AndOrValue.AndFn	The and function.
AndOrValue.Deserializer	Deserializer.
AndOrValue.OrFn	The or function.
AndPredicate	A QueryPredicate that is satisfied when all of its child components are.
AndPredicate.Deserializer	Deserializer.
AnnulmentAndRule	A rule that matches a AndPredicate (with the argument values) that applies the annulment law.
AnnulmentOrRule	A rule that matches a OrPredicate (with the argument values) that applies the annulment law.
AnyMatcher<T>	A binding matcher that is a CollectionMatcher that binds to individual elements contained in a collection separately.
AnyOfMatcher<T>	A matcher that matches if any of its downstream matchers produce bindings.
APIVersion	An enum representing the different supported FDB API versions.
ArithmeticValue	A Value that applies an arithmetic operation on its child expressions.
ArithmeticValue.AddFn	The add function.
ArithmeticValue.BitAndFn	The bitwise and function.
ArithmeticValue.BitmapBitPositionFn	The bitmap_bit_position function.
ArithmeticValue.BitmapBucketNumberFn	The bitmap_bucket_number function.
ArithmeticValue.BitmapBucketOffsetFn	The bitwise bitmap_bucket_offset function.
ArithmeticValue.BitOrFn	The bitwise or function.
ArithmeticValue.BitXorFn	The bitwise xor function.
ArithmeticValue.Deserializer	Deserializer.
ArithmeticValue.DivFn	The div function.
ArithmeticValue.LogicalOperator	Logical operator.
ArithmeticValue.ModFn	The mod function.
ArithmeticValue.MulFn	The mul function.
ArithmeticValue.PhysicalOperator	Physical operators.
ArithmeticValue.SubFn	The sub function.
AsyncBoolean<M extends Message,Q>	An asynchronous Boolean and / or over a sequence of operands.
AsyncIteratorCursor<T>	A cursor that returns the elements of an AsyncIterator.
AsyncLoadingCache<K,V>	A cache for retaining the result of some asynchronous operation up until some expiration time.
AsyncLock	The data-structure to maintain the current state of requested locks on a particular resource.
AsyncLockCursor<T>	A wrapper cursor that manages the locking of resources before operating on inner cursor.
AtomicMutation	The particular operation to be performed by an AtomicMutationIndexMaintainer index.
AtomicMutation.Standard	The atomic mutations implemented straightforwardly by the FDB API.
AtomicMutationIndexMaintainer	An index that maintains an aggregate value in a low-contention way.
AtomicMutationIndexMaintainerFactory	A factory for AtomicMutationIndexMaintainer indexes.
AtomKeyExpression	An "atom expression" is one that has semantic meaning; that is, its presence is significant to the meaning of the expression.
Attribute	Basic interface for all attributes of AbstractPlannerGraph.AbstractNode as well as AbstractPlannerGraph.AbstractEdge.
Attribute.CommonAttribute	Interface for attributes of AbstractPlannerGraph.AbstractNode as well as AbstractPlannerGraph.AbstractEdge that are used to serialize to GML or to DOT.
Attribute.DotAttribute	Interface for attributes of AbstractPlannerGraph.AbstractNode as well as AbstractPlannerGraph.AbstractEdge that are used to serialize to DOT.
Attribute.GmlAttribute	Basic interface all attributes of AbstractPlannerGraph.AbstractNode as well as AbstractPlannerGraph.AbstractEdge that are use to serialize to GML.
Attribute.InvisibleAttribute	Interface for attributes of AbstractPlannerGraph.AbstractNode as well as AbstractPlannerGraph.AbstractEdge that are used to neither serialize to GML or to DOT.
AutoContinuingCursor<T>	A cursor that can iterate over a cursor across transactions.
AvailableFields	Represents a subset of the fields available in a stream of records, including partial records.
AvailableFields.ConditionalUponPathPredicate	A copy-if-predicate that returns true if a particula ordinal path already exists in the tuple.
AvailableFields.ConditionalUponPathPredicate.Deserializer	Deserializer.
AvailableFields.CopyIfPredicate	A predicate that tests whether a copy in IndexKeyValueToPartialRecord.Copier is necessary.
AvailableFields.FieldData	A pair of a tuple source (key or value) and an index within that tuple source.
AvailableFields.TruePredicate	A copy-if-predicate that always returns true.
AvailableFields.TruePredicate.Deserializer	Deserializer.
AverageAccumulatorState<T extends java.lang.Number>	Accumulator state for AVERAGE operations.
BaseCursor<T>	A tag interface for "base" cursors which read records directly from the database.
BaseField	An abstract base class for field-like QueryComponents that involve predicates on one particular record field, as specified by the BaseField.fieldName member.
BaseKeyExpression	Base class to provide some common logic shared between most expression implementations.
BaseKeyExpression.IllegalSubKeyException	An exception that is thrown when BaseKeyExpression.getSubKey(int, int) is used incorrectly.
BaseKeyExpression.UnsplittableKeyExpressionException	An exception indicating that the key expression is not splittable.
BaseMatcher<T>	Abstract base class for all matchers.
BaseNestedField	An abstract base class for all QueryComponents that represent a query of a nested record type.
BindingFunction	Helper methods for manipulating parameter values passed in Bindings.
BindingMatcher<T>	A binding matcher is an object that can be matched against a complex object tree, while binding certain references in the tree to matcher objects.
Bindings	A map of bound parameter values passed to query evaluation.
Bindings.Builder	A builder for Bindings.
Bindings.Internal	Bindings slots used internally by plan operators.
BitmapAggregateIndexExpansionVisitor	The bitmap aggregate index expansion visitor.
BitmapValueIndexMaintainer	An index maintainer for storing bitmaps of which records meet a specific condition.
BitmapValueIndexMaintainerFactory	A factory for BitmapValueIndexMaintainer.
BlockingInAsyncDetection	Indicates whether FDBDatabase.asyncToSync(FDBStoreTimer, FDBStoreTimer.Wait, java.util.concurrent.CompletableFuture) or FDBRecordContext.asyncToSync(FDBStoreTimer.Wait, java.util.concurrent.CompletableFuture) should attempt to detect when it is being called from an asynchronous context and, if so, how it should react to this fact.
BlockingInAsyncException	Exception thrown when asyncToSync detects that it is being called from within an asynchronous context.
BooleanComponent	A boolean component is a component representing an operation in the boolean algebra, e.g.
BooleanNormalizer	A normalizer of a tree of QueryComponent predicates into disjunctive normal form.
BooleanPredicateNormalizer	A normalizer of a tree of QueryPredicates into a normal form which may be its conjunctive or disjunctive normal form.
BooleanPredicateNormalizer.Mode	The target normal form.
BooleanPredicateNormalizer.PredicateMetrics	Case class for metrics we need to keep track of for various purposes.
BooleanValue	Shim class to translate objects of type Value to QueryPredicate.
BooleanWithConstraint	A boolean container that can if the boolean is true carry a QueryPlanConstraint.
BoundMatch<R>	Case class to represent a match for matchers that compute a result.
BoundRecordQuery	A bound record query wraps an instance of RecordQuery and RecordStoreState in order to associate the query with the state of a store.
BrowserHelper	Helper class to interface with the system browser.
BuiltInFunction<T extends Typed>	Main interface for defining a built-in function that can be evaluated against a number of arguments.
ByteArrayContinuation	A shim to wrap old-style byte array continuations.
ByteScanLimiter	Track the number of bytes scanned up to some limit, after which record scans should not be allowed.
ByteScanLimiterFactory	A factory that produces implementations of ByteScanLimiters.
CardinalitiesProperty	This property attempts to derive the minimum and the maximum cardinality of the conceptual result of a RelationalExpression.
CardinalitiesProperty.Cardinalities	Class to capture both minimum and maximum cardinality of an expression.
CardinalitiesProperty.Cardinality	Class to encapsulate the minimum or maximum cardinality of an expression.
CascadesCostModel	A comparator implementing the current heuristic cost model for the CascadesPlanner.
CascadesPlanner	A Cascades-style query planner that converts a RecordQuery to a RecordQueryPlan, possibly using secondary indexes defined in a RecordMetaData to execute the query efficiently.
CascadesPlanner.Task	Represents actual tasks in the task stack of the planner.
CascadesRule<T>	Classes that inherit from CascadesRule form the base of the Cascades planning system.
CascadesRuleCall	A rule call implementation for the CascadesPlanner.
ChainedCursor<T>	A cursor that iterates over a set of data that is dynamically generated a single value at a time.
ChooseK	Utility class to provide helpers related to enumeration of n choose k.
CipherPool	Helper class for pooling Cipher.
CollapseRecordConstructorOverFieldsToStarRule	A rule that un-expands a star expansion.
CollateFunctionKeyExpression	COLLATE function.
CollateFunctionKeyExpressionFactoryJRE	Implementation of CollateFunctionKeyExpression using TextCollatorRegistryJRE.
CollateFunctionKeyExpressionFactoryJRE.CollateFunctionKeyExpressionJRE
CollateValue	A Value that turns a string into a locale-specific sort key.
CollateValue.CollateFunction	Base class for defining collation built-in function.
CollateValue.CollateValueJRE	Define collate_jre built-in function.
CollateValue.Deserializer	Deserializer for PCollateValue.
CollectionMatcher<T>	Tag interface used for overloads for matchers that bind to collections of values/objects.
Column<V extends Value>	A class to hold a value computing a column together with information about the field of a record it supplies the result for.
CombineFilterRule	A simple rule that combines two nested filter plans and combines them into a single filter plan with a conjunction of the two filters.
ComparablePair<L extends java.lang.Comparable<? super L>,R extends java.lang.Comparable<? super R>>	An implementation of the Pair that adds comparison support to the Pair.
ComparatorCursor<T>	A cursor that implements a comparison of matching elements from a set of cursors all of whom are ordered compatibly.
ComparisonCompensation	Interface to define compensation for partially matched Value-trees and their associated comparisons, as e.g.
ComparisonCompensation.NestedInvertableComparisonCompensation	Nested chaining comparison compensation.
ComparisonRange	A set of compatible comparisons on a single field of a KeyExpression representing a contiguous range of values for that field.
ComparisonRange.MergeResult	Class to represent the outcome of a merge operation.
ComparisonRange.Type	Comparison ranges can be divided into three types.
ComparisonRanges	Helper class that operates on a list of ComparisonRanges.
Comparisons	Helper methods for building Comparisons.Comparisons.
Comparisons.Comparison	A comparison between a value associated with someplace in the record (such as a field) and a value associated with the plan (such as a constant or a bound parameter).
Comparisons.ComparisonWithParameter	A comparison against a parameter.
Comparisons.EvaluationContextRequiredException	Exception thrown when comparison evaluation needs the query context, but none was supplied.
Comparisons.InvertedFunctionComparison	Comparison that is built on applying function's inverse to the comparand of a different comparison.
Comparisons.InvertedFunctionComparison.Deserializer	Deserializer.
Comparisons.ListComparison	A comparison with a list of values.
Comparisons.ListComparison.Deserializer	Deserializer.
Comparisons.MultiColumnComparison	Comparison wrapping another one and answering true to Comparisons.MultiColumnComparison.hasMultiColumnComparand().
Comparisons.MultiColumnComparison.Deserializer	Deserializer.
Comparisons.NullComparison	A unary predicate for special nullity checks, such as NULL and NOT NULL.
Comparisons.NullComparison.Deserializer	Deserializer.
Comparisons.OpaqueEqualityComparison	A predicate for comparisons to things unknown or opaque to the planner.
Comparisons.OpaqueEqualityComparison.Deserializer	Deserializer.
Comparisons.ParameterComparison	A comparison with a bound parameter, as opposed to a literal constant in the query.
Comparisons.ParameterComparison.Deserializer	Deserializer.
Comparisons.ParameterComparisonBase	A comparison with a bound parameter, as opposed to a literal constant in the query.
Comparisons.SimpleComparison	A comparison with a constant value.
Comparisons.SimpleComparison.Deserializer	Deserializer.
Comparisons.SimpleComparisonBase	A comparison with a constant value.
Comparisons.TextComparison	A text-style comparison, such as containing a given set of tokens.
Comparisons.TextContainsAllPrefixesComparison	A Comparisons.TextComparison that checks for all prefixes.
Comparisons.TextWithMaxDistanceComparison	A Comparisons.TextComparison that must be satisfied within a certain number of text tokens.
Comparisons.Type	The type for a Comparisons.Comparison predicate.
Comparisons.ValueComparison	A comparison with a Value, as opposed to a literal constant in the query.
Comparisons.ValueComparison.Deserializer	Deserializer.
ComparisonsProperty	A property for collecting all ScanComparisons for the sub tree the property is evaluated on.
CompatibleTypeEvolutionPredicate	A predicate to be used as part of a QueryPlanConstraint which can determine if a given plan can be executed under the types currently defined in the schema.
CompatibleTypeEvolutionPredicate.Deserializer	Deserializer.
CompatibleTypeEvolutionPredicate.FieldAccessTrieNode	Trie to capture the paths this value needs to check for compatible type evolution.
CompatibleTypeEvolutionPredicate.FieldAccessTrieNodeBuilder	Builder version of CompatibleTypeEvolutionPredicate.FieldAccessTrieNode.
CompensateRecordConstructorRule	A rule that computes compensation for a record constructor and all matched values for children of this record constructor.
CompensateToOrderedBytesValueRule	A rule that matches a Value (with the argument values).
Compensation	Interface for all kinds of compensation.
Compensation.ForMatch	Regular compensation class for matches based on query predicates.
Compensation.WithSelectCompensation	Interface for Compensations that map original QueryPredicates to compensating QueryPredicates.
CompletionExceptionLogHelper	Helper class for helping with logging of CompletionExceptions.
CompletionExceptionLogHelper.IgnoredSuppressedExceptionCount	A special "exception" to record the number of suppressed exceptions that were not recorded due to the CompletionExceptionLogHelper.maxSuppressedCount.
ComponentWithChildren	A QueryComponent that has child components.
ComponentWithComparison	A QueryComponent that uses a Comparisons.Comparison on the record.
ComponentWithNoChildren	A QueryComponent that does not have any child components.
ComponentWithSingleChild	A QueryComponent with exactly one child component.
ComposedBitmapIndexAggregate	Transform a tree of Boolean expressions into a tree of bitwise operations on streams of bitmaps from multiple IndexTypes.BITMAP_VALUE indexes with common group and position keys.
ComposedBitmapIndexQueryPlan	A query plan implementing a bit-wise merge of two or more covering index scans of BITMAP_VALUE indexes.
ComposedBitmapIndexQueryPlan.ComposerBase	Plan extension of ComposedBitmapIndexCursor.Composer.
ComposeFieldValueOverFieldValueRule	A rule that composes a field access and an underlying field access to a concatenated field access.
ComposeFieldValueOverRecordConstructorRule	A rule that composes a field access and an underlying record construction, that is, it simplifies a field access over a record construction by replacing it with the field itself, for example (("Hello" as a, "World" as b).b is transformed to "World".
ComputeToOrderedBytesValueRule<O extends OrderingPart.SortOrder,P extends OrderingPart<O>>	A rule that computes the underlying order of a Value tree rooted at a ToOrderedBytesValue.
ComputingMatcher<T,M,R>	This class implements a GenericMatcher which matches two sets of elements of type T to compute a result of type Iterable<BoundMatch<R>>.
ConcatCursor<T>	A cursor that returns the elements of a first cursor followed by the elements of a second cursor.
ConditionSelectorValue	This returns the index of the first implication that is satisfied.
ConditionSelectorValue.Deserializer	Deserializer.
ConstantObjectValue	Represents a constant value that references a constant in __CONST__ binding of EvaluationContext.
ConstantObjectValue.Deserializer	Deserializer.
ConstantPredicate	A predicate with a constant boolean value.
ConstantPredicate.Deserializer	Deserializer.
ConstantValue	A wrapper around a constant.
ConstantValue.Deserializer	Deserializer.
ConstraintsMap	A map to keep track of constraining attributes for an expression reference.
ContainerMatcher<T,C extends java.lang.Iterable<? extends T>>	Tag interface used for overloads for matchers.
ContainsExpressionInReferenceMatcher	A typed matcher that matches the current expression if the current expression is contained in a group reference binding designated by another BindingMatcher (which was bound earlier on a reference).
Correlated<S extends Correlated<S>>	A correlated entity is one which can only be evaluated as a function of some input (usually a Quantifier from its relational parent).
Correlated.BoundEquivalence<S extends Correlated<S>>	Helper class to wrap extenders of Correlated to provide standard equivalence and hash code functionality under a given AliasMap.
CorrelationIdentifier	A correlation identifier is an immutable object that is created with a string uniquely identifying it.
CountValue	A counting aggregate value.
CountValue.CountFn	The count(x) function.
CountValue.Deserializer	Deserializer.
CountValue.PhysicalOperator	The counting argument type.
CountValue.SumAccumulator	Sum partial counts in the appropriate mode.
CreatesDynamicTypesValue	A Value that creates dynamic types on the fly and therefore needs special consideration when dealing with protobuf descriptors.
CrossProduct	Utility class to provide helpers related to enumeration of cross products.
CursorLimitManager	Handles the logic of tracking various out-of-band limits on a BaseCursor.
CursorStreamingMode	The streaming mode to use when opening RecordCursors.
DataAccessRule	A rule that utilizes index matching information compiled by CascadesPlanner to create one or more expressions for data access.
DatabaseObjectDependenciesPredicate	A predicate to be used as part of a QueryPlanConstraint which can determine if a given plan can be executed under the currently available database objects.
DatabaseObjectDependenciesPredicate.Deserializer	Deserializer.
DatabaseObjectDependenciesPredicate.UsedIndex	Helper class to capture the name together and the last modified version of an index.
Debugger	This interface functions as a stub providing hooks which can be called from the planner logic during planning.
Debugger.AbstractEventWithState	Abstract event class to capture rootReference amd taskStack.
Debugger.AdjustMatchEvent	Events of this class are generated when the planner attempts to adjust an existing match.
Debugger.Event	Tag interface for all events.
Debugger.EventWithCurrentGroupReference	Interface for events that hold a group ref.
Debugger.EventWithRule	Events that are created by a or as part of a transformation rule.
Debugger.EventWithState	Interface for events that hold a root reference.
Debugger.ExecutingTaskEvent	Events of this class are generated every time the planner executes a task.
Debugger.ExploreExpressionEvent	Events of this class are generated when the planner explores an expression.
Debugger.ExploreGroupEvent	Events of this class are generated when the planner explores a group.
Debugger.InsertIntoMemoEvent	Events of this class are generated when the planner attempts to insert a new expression into the memoization structures of the planner.
Debugger.Location	Enum to indicate where an event happened.
Debugger.OptimizeGroupEvent	Events of this class are generated when the planner optimizes a group.
Debugger.OptimizeInputsEvent	Events of this class are generated when the planner optimizes inputs.
Debugger.Shorthand	Shorthands to identify a kind of event.
Debugger.TransformEvent	Events of this class are generated when the planner transforms an expression using a rule.
Debugger.TransformRuleCallEvent	Events of this class are generated when the planner calls a transformation rule.
Debugger.TranslateCorrelationsEvent	Events of this class are generated when the planner creates new expressions as part of rebasing or as part of a translation of correlations in a graph.
DefaultExplainFormatter	A formatter for tokens.
DefaultExplainSymbolMap	Symbol table that uses the alias' string representation as symbol.
DefaultOrderingPartRule<O extends OrderingPart.SortOrder,P extends OrderingPart<O>>	A rule that computes the default order of a Value tree.
DefaultPlanSerializationRegistry	Default implementation of a plan serialization registry.
DefaultQueryPredicateRuleSet	A set of rules for use by a planner that supports quickly finding rules that could match a given QueryPredicate.
DefaultTextTokenizer	This is the default tokenizer used by full-text indexes.
DefaultTextTokenizerFactory	Factory class for the DefaultTextTokenizer.
DefaultValueSimplificationRuleSet	A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
DeleteExpression	A logical version of RecordQueryDeletePlan.
DeMorgansTheoremRule<P extends AndOrPredicate>	A rule that matches a NotPredicate over an AndPredicate or OrPredicate and applies a transformation utilizing deMorgan's law.
DependencyUtils	Helper methods useful for managing dependency sets using CorrelationIdentifiers.
DerivationsProperty	A property used to create and collect the derivations of data flowing in a plan.
DerivationsProperty.Derivations	Cases class to capture the derivations that are being collected by the visitor.
DerivationsProperty.DerivationsVisitor	A visitor that determines the derivations of a RecordQueryPlan.
DerivedValue	A value merges the input messages given to it into an output message.
DerivedValue.Deserializer	Deserializer.
DimensionsKeyExpression	A key expression that divides into three parts that represent the constituent parts of a multidimensional index.
DirectoryLayerDirectory	A KeySpaceDirectory that maps a STRING value to a compact LONG value using the FDB directory layer.
DistinctRecordsProperty	An attribute used to indicate if a plan produces distinct records.
DistinctRecordsProperty.DistinctRecordsVisitor	A visitor that determines whether the expression may produce distinct records.
DotExporter<N extends PlannerGraph.Node,E extends PlannerGraph.Edge>	Exports a graph into a DOT file.
DoubleState	Accumulator state for Double types.
DynamicMessageRecordSerializer	Serialize records using default Protobuf serialization using DynamicMessage.
EliminateArithmeticValueWithConstantRule	A rule that eliminates an arithmetic operation.
EmptyComparison	A comparison to determine whether a repeated field is empty (has no occurrences).
EmptyCursor<T>	A RecordCursor that always returns zero items.
EmptyKeyExpression	A single empty key.
EmptyValue	A value that evaluates to empty.
EmptyValue.Deserializer	Deserializer.
EncapsulationFunction<T extends Typed>	A functional interface that provides an encapsulation of a runtime computation against a set of arguments.
EndpointType	The type of one of the endpoints of a TupleRange.
EnumeratingIterable<T>	Iterable that provides special iterators of type EnumeratingIterator.
EnumeratingIterable.EmptyIterable<T>	An implementation of EnumeratingIterable that is optimized to work for empty input sets.
EnumeratingIterable.SingleIterable<T>	An implementation of EnumeratingIterable that is optimized to work for single item input sets.
EnumeratingIterable.SingleIterator<T>	A single element iterator.
EnumeratingIterator<T>	An iterator extending Iterator providing the ability to skip a certain prefix.
EnumerationFunction<R>	Functional interface to allow implementors to provide use case-specific logic when permutations are enumerated by BaseMatcher.match(com.apple.foundationdb.record.query.plan.cascades.matching.graph.EnumerationFunction<R>, boolean).
EvaluationContext	A context for query evaluation.
EvaluationContextBuilder	A builder for EvaluationContext.
ExecuteProperties	Limits on the execution of a query.
ExecuteProperties.Builder	A builder for ExecuteProperties.
ExecuteState	An encapsulation of the mutable state of query or scan execution.
ExistsPredicate	An existential predicate that is true if the inner correlation produces any values, and false otherwise.
ExistsPredicate.Deserializer	Deserializer.
ExistsValue	A Value that checks whether an item exists in its child quantifier expression or not.
ExistsValue.Deserializer	Deserializer.
ExistsValue.ExistsFn	A function that checks whether an item exists in a RelationalExpression.
ExpandFusedFieldValueRule	A rule that decomposes a FieldValue that uses multiple steps into two FieldValues as follows:
ExpandRecordRule	A rule that expands a Value of type Type.Record into a record constructor over its constituent parts as follows:
ExpansionVisitor<S extends KeyExpressionVisitor.State>	A sub interface of KeyExpressionVisitor that fixes the return type to be a GraphExpansion and adds an API to cause the expansion of a metadata-based data access structure to a data flow graph that can then be used for matching.
ExplainFormatter	A formatter for tokens.
ExplainLevel	Explain level.
ExplainPlannerGraphRewritable	Interface to allow RelationalExpressions to rewrite their own explain graph representation.
ExplainPlanVisitor	Visitor that produces a string representation of a RecordQueryPlan.
ExplainSelfContainedSymbolMap	Formatting for Value.explain().
ExplainSymbolMap	Interface for simple symbol maps for the purpose of mapping an alias as supplied by the planner to a human-readable string symbol.
ExplainTokens	Class to hold information about a list of tokens.
ExplainTokens.AliasDefinitionToken	An alias definition token.
ExplainTokens.AliasReferenceToken	An alias reference token.
ExplainTokens.BracketLikeToken	A brackets token.
ExplainTokens.CommaLikeToken	A comma-like token.
ExplainTokens.CurrentAliasDefinitionToken	Token that registers an alias explicitly to some symbol.
ExplainTokens.IdentifierToken	An identifier token.
ExplainTokens.KeywordToken	A keyword token.
ExplainTokens.LineBreakOrSpaceToken	A line break or whitespace token.
ExplainTokens.NestedToken	A nested token.
ExplainTokens.OptionalWhitespaceToken	An optional whitespace token.
ExplainTokens.PopToken	A pop token.
ExplainTokens.PushToken	A push token.
ExplainTokens.Token	Generic token structure.
ExplainTokens.TokenKind	A token enumeration that is used intermittently when something is explained.
ExplainTokens.ToStringToken	A ToString token.
ExplainTokens.WhitespaceToken	A whitespace token.
ExplainTokensWithPrecedence	Holder class for the result of a call to Value.explain() and derivatives.
ExplainTokensWithPrecedence.Precedence	Precedence which informs the explain logic whether to put parentheses around explain terms or not.
ExplodeExpression	A table function expression that "explodes" a repeated field into a stream of its values.
ExponentialDelay	This class maintains a delay that should be used when retrying transactional operations that have failed due to something retriable.
ExpressionProperty<T>	An interface for certain Cascades-style properties, which are measurable features of an expression other than the structure of the expression tree.
ExpressionToTuplePathVisitor	Visitor to find mappings of KeyExpressions to tuple access paths that are encoded as AvailableFields.FieldData.
ExpressionToTuplePathVisitor.Result	Result class.
ExpressionToTuplePathVisitor.State	State class.
ExtendedDirectoryLayer	An implementation of LocatableResolver that uses a key format that is compatible with the ScopedDirectoryLayer to keep track of the allocation of strings to integers.
ExtractFromIndexKeyValueRuleSet	A set of rules to be used to create a Value tree to extract an item from an index entry and perform necessary adjustments prior to constructing the partial record in IndexKeyValueToPartialRecord.
Extractor<T,U>	Interface for the unapply function using in a variety of matchers.
FallbackCursor<T>	Provide an alternative cursor in case the primary cursor fails.
FallbackCursor.FallbackExecutionFailedException	Exception thrown when the fallback cursor fails.
FDBDatabase	A known FDB Database, associated with a cluster file location.
FDBDatabase.ExceptionMapper	Function for mapping an underlying exception to a synchronous failure.
FDBDatabase.WeakReadSemantics	1.
FDBDatabaseFactory	Abstract class for a factory that manages FDBDatabase instances.
FDBDatabaseFactoryImpl	A singleton maintaining a list of FDBDatabase instances, indexed by their cluster file location.
FDBDatabaseRunner	A context for running against an FDBDatabase with retrying of transient exceptions.
FDBDatabaseRunner.RunnerClosed	Exception thrown when FDBDatabaseRunner has been closed but tries to do work.
FDBDatabaseRunnerImpl	The standard implementation of FDBDatabaseRunner.
FDBExceptions	Namespace for exceptions that wrap the underlying exceptions from the FDB API.
FDBExceptions.FDBStoreException	Exceptions that are reported by (or due to limitations of, etc.) the FDB API.
FDBExceptions.FDBStoreKeySizeException	Exception thrown when key size is exceeded.
FDBExceptions.FDBStoreLockTakenException	Transaction failed due to a lock already taken.
FDBExceptions.FDBStoreRetriableException	An exception that should be retried by the caller because is stems from a transient condition in FDB.
FDBExceptions.FDBStoreTransactionConflictException	Transaction failed due to a conflict with another transaction.
FDBExceptions.FDBStoreTransactionIsTooOldException	Transaction is too old to perform reads or be committed.
FDBExceptions.FDBStoreTransactionSizeException	Exception thrown when transaction size is exceeded.
FDBExceptions.FDBStoreTransactionTimeoutException	Exception thrown when a transaction times out.
FDBExceptions.FDBStoreValueSizeException	Exception thrown when value size is exceeded.
FDBIndexableRecord<M extends Message>	A record that can be passed to an index maintainer.
FDBIndexedRawRecord	A raw record that has been loaded via an index.
FDBIndexedRecord<M extends Message>	A record that has been loaded via an index.
FDBLatencySource	Indicates which FDB API calls are to have latency injected into them via FDBDatabaseFactory.setLatencyInjector(Function).
FDBLocalityProvider	An interface containing a set of functions for discovering the location of the keys within a cluster.
FDBLocalityUtil	An implementation of the FDBLocalityProvider interface that uses foundationDB's LocalityUtil API to discover the storage locations of keys within a cluster.
FDBMetaDataStore	Serialization of RecordMetaData into the database.
FDBMetaDataStore.MissingMetaDataException	Thrown if meta-data was never written to the store.
FDBQueriedRecord<M extends Message>	A record returned by a query and therefore possibly associated with a particular entry in some index.
FDBRecord<M extends Message>	A record associated with the corresponding meta-data.
FDBRecordContext	An open transaction against FDB.
FDBRecordContext.AfterCommit	A hook to run after commit has completed successfully.
FDBRecordContext.CommitCheck	A synchronous FDBRecordContext.CommitCheckAsync.
FDBRecordContext.CommitCheckAsync	A consistency check, such as uniqueness, that can execute asynchronously and is finally checked at or before commit time.
FDBRecordContext.PostCommit	A supplier of a future to be executed after the transaction has been successfully committed.
FDBRecordContextConfig	A configuration struct that can be used to set various options on an FDBRecordContext.
FDBRecordContextConfig.Builder	A builder of FDBRecordContextConfigs using the standard builder pattern.
FDBRecordStore	A multi-type record store.
FDBRecordStore.Builder	A builder for FDBRecordStore.
FDBRecordStore.IndexNotBuiltException	Exception that can be thrown if one attempts to mark an index as readable if it is not yet readable.
FDBRecordStore.RebuildIndexReason	Reason that an index is being rebuilt now.
FDBRecordStore.StateCacheabilityOnOpen	Enum controlling how the store state cacheability flag should be changed when the store is opened.
FDBRecordStoreBase<M extends Message>	Base interface for typed and untyped record stores.
FDBRecordStoreBase.BaseBuilder<M extends Message,R extends FDBRecordStoreBase<M>>	Builder for FDBRecordStoreBase.
FDBRecordStoreBase.PipelineSizer	Function for computing the number of elements to allow in the asynchronous pipeline for an operation of the given type.
FDBRecordStoreBase.RecordExistenceCheck	Action to take if the record being saved does / does not already exist.
FDBRecordStoreBase.StoreExistenceCheck	Action to take if the record store does / does not already exist.
FDBRecordStoreBase.UserVersionChecker	Hook for checking if store state for client changes.
FDBRecordStoreBase.VersionstampSaveBehavior	Provided during record save (via FDBRecordStoreBase.saveRecord(Message, FDBRecordVersion, VersionstampSaveBehavior)), directs the behavior of the save w.r.t.
FDBRecordStoreKeyspace	Unique integers used as the first tuple item within a record store's subspace.
FDBRecordStoreProperties	Property keys for the FDBRecordStore and related classes.
FDBRecordStoreStateCache	A cache for FDBRecordStoreStateCacheEntry objects.
FDBRecordStoreStateCacheEntry	Information needed to initialize an FDBRecordStore that is not stored within the record store's RecordMetaData.
FDBRecordStoreStateCacheFactory	A factory interface for FDBRecordStoreStateCaches.
FDBRecordVersion	Class representing a specific version within FDB.
FDBRecordVersion.IncompleteRecordVersionException	Exception that can be thrown if one tries to get the global version associated with a version whose global version has not yet been set.
FDBReverseDirectoryCache	A persistent cache providing reverse lookup facilities from the FDB DirectoryLayer.
FDBStoreBase	Base class for record stores and meta-data stores, which have in common that they are opened by an FDBRecordContext and occupy some Subspace in the database.
FDBStoredRecord<M extends Message>	A record stored in the database.
FDBStoredRecordBuilder<M extends Message>	A builder for FDBStoredRecord.
FDBStoredSizes	Information about how a record is stored in the database.
FDBStoreTimer	A StoreTimer associated with FDBRecordStore operations.
FDBStoreTimer.CountAggregates	An aggregate over other count events.
FDBStoreTimer.Counts	Standard StoreTimer.Count events.
FDBStoreTimer.DetailEvents	Standard StoreTimer.DetailEvents.
FDBStoreTimer.Events	Ordinary top-level events which surround a single body of code.
FDBStoreTimer.Waits	Standard StoreTimer.Wait events.
FDBSyntheticRecord	A record synthesized from stored records.
FDBSystemOperations	View of an FoundationDB database used for accessing system and special keys.
FDBTraceFormat	The FoundationDB native client can be configured to emit its trace logs (containing important metrics and instrumentation information) in one of several different formats.
FDBTransactionContext	Wrapper class for an open FDB Transaction.
FDBTransactionPriority	An enum indicating the priority of transactions against FoundationDB.
FDBTypedRecordStore<M extends Message>	A type-safe record store.
FDBTypedRecordStore.Builder<M extends Message>	A builder for FDBTypedRecordStore.
Field	Class that provides context for asserting about a field value.
Field.OneOfThemEmptyMode	How an empty / unset repeated field should be handled.
FieldKeyExpression	Take keys from a record field.
FieldValue	A value representing the contents of a (non-repeated, arbitrarily-nested) field of a quantifier.
FieldValue.Accessor	Helper class to hold information about a particular field access.
FieldValue.Deserializer	Deserializer.
FieldValue.FieldPath	A list of fields forming a path.
FieldValue.ResolvedAccessor	A resolved FieldValue.Accessor that now also holds the resolved Type.
FieldValueCompensation	A compensation that utilizes a field access.
FieldWithComparison	A QueryComponent that implements a Comparisons.Comparison against a field of the record.
FieldWithComparisonCountProperty	A property that counts the number of FieldWithComparisons that appear in a planner expression tree.
FileSortAdapter<K,V>	Provide various options for FileSorter and FileSortCursor.
FileSortCursor<K,V>	Sort records in memory and / or in files, then return them in order.
FileSorter<K,V>	Write sorted keyed values into Files.
FileSorter.LoadResult	The result of FileSorter.load(com.apple.foundationdb.record.RecordCursor<V>).
FilterCursor<T>	A cursor that filters elements using a predicate.
FilterSatisfiedMask	A mask that can be applied over a QueryComponent to determine whether a filter and any sub-filters or child components have been satisfied.
FilterVisitor	A substitution visitor that pushes a filter below a record fetch if all of the (non-repeated) field are available in a covering scan.
FindExpressionProperty	A property that determines finds all occurrences of expressions of interest in a planner graph.
FindingMatcher<T>	This class implements a PredicatedMatcher which matches two sets of elements of type T to compute an Iterable of AliasMaps.
FirstOrDefaultValue	A value that returns the first element of the input array passed in.
FirstOrDefaultValue.Deserializer	Deserializer.
FlatMapPipelinedCursor<T,V>	A cursor that maps elements to another cursor which is then flattened.
FloatState	Accumulator state for Float types.
FoldConstantRule	A rule that detects a value that evaluates to one constant value given the a set of aliases that are considered being bound to constant objects.
FoldingValueSimplificationRuleSet	A set of rules for simplifying Value trees used to expression ordering constraints.
FormerIndex	The location where a deleted index used to live.
FromOrderedBytesValue	A value that produces a binary encoding that is comparable according to certain modes gives by TupleOrdering.Direction.
FromOrderedBytesValue.Deserializer	Deserializer.
FromOrderedBytesValue.FromOrderedBytesAscNullsFirstFn	The FROM_ORDERED_BYTES_ASC_NULLS_FIRST function.
FromOrderedBytesValue.FromOrderedBytesAscNullsLastFn	The FROM_ORDERED_BYTES_ASC_NULLS_LAST function.
FromOrderedBytesValue.FromOrderedBytesDescNullsFirstFn	The FROM_ORDERED_BYTES_DESC_NULLS_FIRST function.
FromOrderedBytesValue.FromOrderedBytesDescNullsLastFn	The FROM_ORDERED_BYTES_DESC_NULLS_LAST function.
FullUnorderedScanExpression	A planner expression representing a full, unordered scan of the records by primary key, which is the logical version of a RecordQueryScanPlan with ScanComparisons.EMPTY.
FunctionCatalog	A catalog of functions that provides BuiltInFunctions.
FunctionKeyExpression	A FunctionKeyExpression is a KeyExpression that is dynamically loaded and defined by a String name and a Key.Expression that produces sets of arguments to which the function is to be evaluated.
FunctionKeyExpression.BiFunctionBuilder	An implementation of a Builder that can construct a KeyExpressionFunction via a provided generator.
FunctionKeyExpression.Builder	A builder is capable of producing an instance of a FunctionKeyExpression given the arguments to the function.
FunctionKeyExpression.Factory	Implementations of FunctionKeyExpression.Factory are dynamically located by the FunctionKeyExpression.Registry and are polled once to request a list of builders for functions that the factory is capable of producing.
FunctionKeyExpression.Registry	The Registry maintains a mapping from a function name to a Builder capable of producing an instance of the function.
FunctionNames	Names of core-supported query functions.
FutureCursor<T>	A cursor that returns a single element when a future completes.
GenericMatcher<R>	Tag interface for generic matchers, that is instances of ComputingMatcher.
GmlExporter<N extends PlannerGraph.Node,E extends PlannerGraph.Edge>	Exports a graph into a DOT file.
GraphExpansion	Class to abstract behavior when query expansion is applied to query components or key expressions.
GraphExpansion.Builder	Builder for GraphExpansion.
GraphExporter<N,E>	Exports a graph into a DOT file.
GraphExporter.Cluster<N,E>	This class represents a cluster with the additional ability to further subdivide the cluster into sub-clusters.
GraphExporter.ClusterProvider<N,E>	Shorthand-type for the extended functional interface.
GraphExporter.ComponentAttributeProvider<T>	Shorthand-type for the extended functional interface.
GraphExporter.ComponentIdProvider<T>	Shorthand-type for the extended functional interface.
GroupByExpression	A logical group by expression that represents grouping incoming tuples and aggregating each group.
GroupingKeyExpression	A key expression that divides into two parts for the sake of aggregate or rank indexing.
HashUtils	Utility class for hash functions.
HighContentionAllocator	A supplier of unique integers that tries to balance size of the integer and conflicts on the assignment.
HighContentionAllocator.AllocationWindow	A range of possible values to try.
IdentityAndRule	A rule that matches a AndPredicate (with the argument values).
IdentityBiMap<K,V>	BiMap based on identities of types K and V.
IdentityOrRule	A rule that matches a OrPredicate (with the argument values).
IllegalContinuationAccessChecker	Check that RecordCursorIterator.getContinuation() is only called when allowed.
ImmutablePair<L,R>	Immutable implementation of the Pair interface.
ImplementDeleteRule	A rule that implements a DeleteExpression by creating a RecordQueryDeletePlan.
ImplementDistinctRule	A rule that implements a distinct expression by adding a RecordQueryUnorderedPrimaryKeyDistinctPlan if necessary.
ImplementDistinctUnionRule	A rule that implements a distinct union of its (already implemented) children.
ImplementExplodeRule	A rule that implements an explode expression as a RecordQueryExplodePlan.
ImplementFilterRule	A rule that implements a logical filter around a RecordQueryPlan as a RecordQueryFilterPlan.
ImplementInJoinRule	A rule that implements a SELECT over a VALUES and a correlated subexpression as a RecordQueryInUnionPlan.
ImplementInsertRule	A rule that implements an InsertExpression by creating a RecordQueryInsertPlan.
ImplementIntersectionRule	A rule that implements an intersection of its (already implemented) children.
ImplementInUnionRule	A rule that implements a SELECT over a VALUES and a correlated subexpression as a RecordQueryInUnionPlan.
ImplementNestedLoopJoinRule	A rule that implements an existential nested loop join of its (already implemented) children.
ImplementPhysicalScanRule	A rule that converts a logical index scan expression to a RecordQueryScanPlan.
ImplementRecursiveUnionRule	A rule that implements a RecursiveUnionExpression.
ImplementSimpleSelectRule	A rule that implements a select expression without predicates over a single partition as a RecordQueryMapPlan.
ImplementStreamingAggregationRule	Rule for implementing logical GROUP BY into a physical streaming aggregate operator RecordQueryStreamingAggregationPlan.
ImplementTempTableInsertRule	A rule that implements a TempTableInsertExpression producing a TempTableInsertPlan operator.
ImplementTempTableScanRule	A rule that implements a TempTableScanExpression producing a TempTableScanPlan operator.
ImplementTypeFilterRule	A rule that implements a logical type filter on an (already implemented) RecordQueryPlan as a RecordQueryTypeFilterPlan.
ImplementUniqueRule	This rule implements LogicalUniqueExpression by absorbing it if the inner reference is already distinct.
ImplementUnorderedUnionRule	A rule that implements an unordered union of its (already implemented) children.
ImplementUpdateRule	A rule that implements an UpdateExpression by creating a RecordQueryUpdatePlan.
InComparandSource	Source of values for an "IN" query where the values are derived from the comparand of a Comparison object.
InComparandSource.Deserializer	Deserializer.
InComparisonToExplodeRule	A rule that traverses a predicate in a SelectExpression and attempts to extract IN-comparisons into separate ExplodeExpressions, e.g.
Index	Meta-data for a secondary index.
IndexableAggregateValue	Tag interface for AggregateValue that are backed by an aggregate index.
IndexAccessHint	Represents an index hint.
IndexAggregateFunction	An aggregate function implemented by scanning an appropriate index.
IndexAggregateFunctionCall	Class to represent a construct AGG by Set.of(col1, col2, ...).
IndexAggregateGroupKeys	Helper class for extracting grouping keys from an IndexAggregateFunction given query conditions.
IndexAggregateGroupKeys.Conditions
IndexAggregateGroupKeys.IndexScan
IndexBuildState	A class that contains the build progress of a given index in a given record store.
IndexComparison	This is a simple PoJo hierarchy representing SerDe operations on a predicate comparison of a sparse Index.
IndexComparison.NullComparison	A POJO equivalent for Comparisons.NullComparison.
IndexComparison.SimpleComparison	A POJO equivalent for Comparisons.SimpleComparison.
IndexComparison.SimpleComparison.ComparisonType	The type of the comparison, this is a subset of Comparisons.Type.
IndexDeferredMaintenanceControl	Some store's indexes may need merging on some occasions.
IndexDeferredMaintenanceControl.LastStep	During the deferred operation, each step should record its action.
IndexedValue	A value representing the source of a value derivation.
IndexedValue.Deserializer	Deserializer.
IndexEntry	An IndexEntry carries around the key and value read from an index (as the name would imply).
IndexEntryObjectValue	Represents a value that references into an index entry in the bindings of EvaluationContext by means of an ordinal path (dewey id).
IndexEntryObjectValue.Deserializer	Deserializer.
IndexFetchMethod	An indicator for the index fetch method to use for a query or an index scan.
IndexFunctionHelper	Helper class for finding appropriate indexes for IndexRecordFunction and IndexAggregateFunction.
IndexingBase	A base class for different types of online indexing process.
IndexingBase.PartlyBuiltException	thrown when partly built by another method.
IndexingBase.TimeLimitException	Thrown when the indexing process exceeds the time limit.
IndexingBase.UnexpectedReadableException	thrown if some or all of the indexes to build became readable (maybe by another process).
IndexingBase.ValidationException	Thrown when the indexing process fails to meet a precondition.
IndexingByIndex	This indexer scans records by a source index.
IndexingByRecords	This indexer scans all records in the record store.
IndexingCommon	Shared data structure to be used (only) by the Indexing* modules.
IndexingCommon.IndexContext	Index and record types for indexing.
IndexingMerger	Implement an index merge.
IndexingMultiTargetByRecords	This indexer scans records to build multiple indexes.
IndexingMutuallyByRecords	This indexer supports mutual concurrent multi-target indexing by multiple processes or hosts.
IndexingRangeSet	Wrapper around a RangeSet class that binds the class with a specific transaction.
IndexingScrubDangling	Manifesto: Scrub a readable index to validate its consistency.
IndexingScrubMissing	Manifesto: Scrub a readable index to validate its consistency.
IndexingThrottle	This class provides build/commit/retry with throttling to the OnlineIndexer.
IndexKeyValueToPartialRecord	Construct a record from a covering index.
IndexKeyValueToPartialRecord.Builder	A builder for IndexKeyValueToPartialRecord.
IndexKeyValueToPartialRecord.Copier	Copy from an index entry into part of a record.
IndexKeyValueToPartialRecord.FieldCopier	Copier for basic fields.
IndexKeyValueToPartialRecord.FieldCopier.Deserializer	Deserializer.
IndexKeyValueToPartialRecord.FieldWithValueCopier	Copier for fields that is based on some give Value to do its work.
IndexKeyValueToPartialRecord.FieldWithValueCopier.Deserializer	Deserializer.
IndexKeyValueToPartialRecord.MessageCopier	Copier for nested messages.
IndexKeyValueToPartialRecord.MessageCopier.Deserializer	Deserializer.
IndexKeyValueToPartialRecord.TupleSource	Which side of the IndexEntry to take a field from.
IndexMaintainer	Object responsible for translating record saves and deletes into updates to a secondary index.
IndexMaintainerFactory	A factory for IndexMaintainer.
IndexMaintainerRegistry	A registry of IndexMaintainers.
IndexMaintainerRegistryImpl	A singleton IndexMaintainerRegistry that finds IndexMaintainerFactory classes in the classpath.
IndexMaintainerState	Common state for an IndexMaintainer.
IndexMaintenanceFilter	A hook for suppressing secondary indexing of some records.
IndexMaintenanceFilter.IndexValues	Whether to maintain a subset of the indexable values for the given record.
IndexOnlyAggregateValue	Represents a compile-time aggregation value that must be backed by an aggregation index, and can not be evaluated at runtime by a streaming aggregation operator.
IndexOnlyAggregateValue.MaxEverFn	The max_ever function.
IndexOnlyAggregateValue.MaxEverValue	Class to represent MAX_EVER(field) where field which can only be provided by a suitable index.
IndexOnlyAggregateValue.MaxEverValue.Deserializer	Deserializer.
IndexOnlyAggregateValue.MinEverFn	The min_ever function.
IndexOnlyAggregateValue.MinEverValue	Class to represent MIN_EVER(field) where field which can only be provided by a suitable index.
IndexOnlyAggregateValue.MinEverValue.Deserializer	Deserializer.
IndexOnlyAggregateValue.PhysicalOperator
IndexOperation	A maintenance operation on a secondary index.
IndexOperationResult	The result of an IndexOperation.
IndexOptions	The standard options for use with Index.
IndexOrphanBehavior	Provided during index scan operations in which associated records are being retrieved, to indicate what should happen in response to an index entry which has no associated record.
IndexPredicate	This is a Plain old Java object (POJO) hierarchy representing SerDe operations on a predicate on an Index.
IndexPredicate.AndPredicate	A POJO equivalent for AndPredicate.
IndexPredicate.ConstantPredicate	a POJO equivalent for ConstantPredicate.
IndexPredicate.ConstantPredicate.ConstantValue	The constant to use.
IndexPredicate.NotPredicate	A POJO equivalent of NotPredicate.
IndexPredicate.OrPredicate	A POJO equivalent for OrPredicate.
IndexPredicate.ValuePredicate	A POJO equivalent of ValuePredicate.
IndexPredicateExpansion	Trait that plugs index predicate expansion utility methods into the consumer.
IndexPrefetchRangeKeyValueCursor	A KeyValueCursor that scans an index using the IndexPrefetch operation.
IndexPrefetchRangeKeyValueCursor.Builder	A Builder for the cursor.
IndexQueryabilityFilter	A filter used to determine whether an index should be considered when planning queries.
IndexRecordFunction<T>	A function which is applied to a record with the help of an index.
IndexScanBounds	The bounds for an index scan.
IndexScanComparisons	ScanComparisons for use in an index scan.
IndexScanComparisons.Deserializer	Deserializer.
IndexScanParameters	The parameterized form of index scan bounds.
IndexScanRange	TupleRange for an index scan.
IndexScanType	The way in which an index should be scanned.
IndexScrubbing	Scrub a readable index to validate its consistency.
IndexScrubbingTools<T>	Index Scrubbing Toolbox for a specific index maintainer.
IndexScrubbingTools.Issue	A single issue reported by IndexScrubbingTools.handleOneItem(com.apple.foundationdb.record.provider.foundationdb.FDBRecordStore, com.apple.foundationdb.record.RecordCursorResult<T>).
IndexScrubbingTools.ScrubbingType	The specific type of scrubbing.
IndexState	Different states an index might be in within a given store.
IndexTypes	The standard index types.
IndexValidator	Validate an index according to the constraints of the index's type.
IndexValidatorRegistry	A registry of IndexValidators.
InExtractor	Extract IN predicates in a query filter by replacing them with equality comparisons with a bound parameter that will take on the values of the comparison list in turn.
InJoinVisitor	A substitution visitor that pushes a RecordQueryInJoinPlan below a RecordQueryFetchFromPartialRecordPlan.
InOpValue	A Value that checks if the left child is in the list of values.
InOpValue.Deserializer	Deserializer.
InOpValue.InFn	The in function.
InParameterSource	Helper class which represents a specialized InSource whose input is an outer binding (a parameter).
InParameterSource.Deserializer	Deserializer.
InsertExpression	A logical version of RecordQueryInsertPlan.
InSource	Helper class to describe an IN-list for physical RecordQueryInJoinPlans and RecordQueryInUnionPlans.
InstanceMatcher<T>	A binding matcher that matches the same object as another BindingMatcher.
InstrumentedTransaction	Wrapper around Transaction that instruments certain calls to expose their behavior with FDBStoreTimer metrics.
IntegerState	Accumulator state for Integer types.
InternalPlannerGraphRewritable	Interface to allow RelationalExpressions to rewrite their own internal graph representation.
IntersectionCursor<T>	A cursor that implements an intersection of matching elements from a set of cursors all of whom are ordered compatibly.
IntersectionMultiCursor<T>	A cursor that implements an intersection of matching elements from a set of cursors all of whom are ordered compatibly.
IntersectionVisitor	This visitor pulls index fetches after the intersection if possible.
InUnionVisitor	A substitution visitor that pushes a RecordQueryInJoinPlan below a RecordQueryFetchFromPartialRecordPlan.
InvalidIndexEntry	An invalid index entry including the entry and the reason why it is invalid.
InvalidIndexEntry.Reason	The reason why an index entry is invalid.
InvalidIndexEntry.Reasons	The reasons supported in the Record Layer.
InValuesSource	Helper class which represents a specialized InSource whose input is a list of literal values.
InValuesSource.Deserializer	Deserializer.
InvertibleFunctionKeyExpression	Key expression representing an invertible function.
IsolationLevel	The isolation level for reads from the database.
IterableHelpers	Helper methods for Iterables.
IteratorCursor<T>	A cursor that returns the elements of an ordinary synchronous iterator.
JavaCallFunction	Represents a Java user-defined function.
JoinedRecordType	A synthetic record type representing the indexable result of joining stored records.
JoinedRecordType.Join	An equi-join between constituent types.
JoinedRecordType.JoinConstituent	A constituent type within a joined record type.
JoinedRecordTypeBuilder	A builder for JoinedRecordType.
JoinedRecordTypeBuilder.Join	An equi-join between constituent types.
JoinedRecordTypeBuilder.JoinConstituent	A constituent type within a joined record type.
Key	Namespace for classes related to KeyExpression construction and evaluation.
Key.Evaluated	Represents the list objects for a key in a secondary index or primary storage.
Key.Evaluated.NullStandin	Values used in index keys in place of missing fields.
Key.Expressions	Holder class for the static methods for creating Key Expressions.
KeyChecker	Hook for checking keys passed to a Transaction.
KeyCheckingReadTransaction<T extends ReadTransaction>	Wrapper around Transaction that performs checks on keys passed to various operations.
KeyCheckingTransaction	Wrapper around Transaction that performs checks on keys passed to various operations.
KeyComparisons	Comparators for key expressions.
KeyExpression	Interface for expressions that evaluate to keys.
KeyExpression.DeserializationException	Exception thrown when there is a problem deserializing a key expression.
KeyExpression.FanType	How should repeated fields be handled.
KeyExpression.InvalidExpressionException	Exception thrown when there is a problem with using a key expression in a certain context.
KeyExpression.InvalidResultException	This is a runtime exception (i.e.
KeyExpression.NoSuchArgumentException	Exception thrown when a function key expression does not have an argument.
KeyExpression.SerializationException	Exception thrown when there is a problem serializing a key expression.
KeyExpressionExpansionVisitor	Expansion visitor that implements the shared logic between primary scan data access and value index access.
KeyExpressionExpansionVisitor.VisitorState	Class that holds the state necessary to expand both primary data access as well as value indexes.
KeyExpressionVisitor<S extends KeyExpressionVisitor.State,R>	An interface to provide a state-based visitor pattern that can traverse a tree of KeyExpressions.
KeyExpressionVisitor.State	Tag interface to capture state within this visitor.
KeyExpressionWithChild	A KeyExpression with exactly one child expression.
KeyExpressionWithChildren	A KeyExpression with child expressions.
KeyExpressionWithoutChildren	A KeyExpression with no children.
KeyExpressionWithValue	A key expression that can be represented as a single Value because it meets both of the following criteria: It's a single value rather than a complex tuple. It does not produce multiple values because of fan-out. This is completely unrelated to the (disturbingly) similarly named KeyWithValueExpression.
KeyRange	A range within a subspace specified by two byte value endpoints.
KeySpace	A KeySpace defines a logical directory structure for keys that comprise an FDB row key.
KeySpaceCountTree	Count keys and resolve back to key space paths.
KeySpaceDirectory	Defines a directory within a KeySpace.
KeySpaceDirectory.KeyType	The available data types for directories.
KeySpacePath	A KeySpacePath represents a discrete path through a directory tree defined by a KeySpace.
KeySpacePathWrapper	Helper class to make it easy to create KeySpacePath wrapper implementations for use in KeySpaceDirectory(String, KeySpaceDirectory.KeyType, Object, java.util.function.Function) (String, KeySpaceDirectory.KeyType, Object, Function)}.
KeySpaceTreeResolver	Resolve trees of key space paths and record store descendants.
KeySpaceTreeResolver.Resolved	The resolved interpretation of the node value.
KeySpaceTreeResolver.ResolvedAndRemainder	Result of resolving a Tuple into a KeySpaceTreeResolver.Resolved key space path or other resolved element in the tree.
KeySpaceTreeResolver.ResolvedIndexKeyspace	A resolved index keyspace.
KeySpaceTreeResolver.ResolvedKeyField	A resolved field of a record primary key or index key.
KeySpaceTreeResolver.ResolvedPath	KeySpaceTreeResolver.Resolved to a ResolvedKeySpacePath.
KeySpaceTreeResolver.ResolvedPrefixRoot	KeySpaceTreeResolver.ResolvedRoot with a prefix object.
KeySpaceTreeResolver.ResolvedRecordStoreKeyspace	A resolved record store keyspace, such as records or indexes.
KeySpaceTreeResolver.ResolvedRecordTypeKeyspace	A resolved record type key prefix keyspace.
KeySpaceTreeResolver.ResolvedRoot	KeySpaceTreeResolver.Resolved to a KeySpace root.
KeyValueCursor	The basic cursor for scanning ranges of the FDB database.
KeyValueCursor.Builder	A builder for KeyValueCursor.
KeyValueCursorBase<K extends KeyValue>	The base class for cursors scanning ranges of the FDB database.
KeyValueCursorBase.Builder<T extends KeyValueCursorBase.Builder<T>>	A builder for KeyValueCursorBase.
KeyValueLogMessage	A formatter for log messages.
KeyWithValueExpression	A KeyWithValue expression is a top level expression that takes as input an expression that produces more than one column, and indicates that all columns before the specified splitPoint should be used in the key of a covering index and all of the values starting at the splitPoint are to be used as the value of a covering index.
LazyCursor<T>	Wraps a future that supplies a record cursor.
LeafQueryPredicate	Class to model the concept of a predicate.
LeafValue	A scalar value type that has children.
LiftConstructorRule	A rule that lifts the fields of a nested record constructor into the current record constructor.
LikeOperatorValue	A Value that applies a like operator on its child expressions.
LikeOperatorValue.Deserializer	Deserializer.
LikeOperatorValue.LikeFn	The like operator.
LinkedIdentityMap<K,V>	A map of items that uses reference equality to determine equivalence for the purposes of set membership, rather than the LinkedIdentityMap.equals(Object) method used by the Java Set interface.
LinkedIdentitySet<T>	A set of items that uses reference equality to determine equivalence for the purposes of set membership, rather than the LinkedIdentitySet.equals(Object) method used by the Java Set interface.
ListCursor<T>	A cursor that returns the elements of a list.
ListKeyExpression	Combine keys from zero or more child keys.
ListMatcher<T>	A collection matcher that binds a sub collection of the collection it is being matched by pairing up the items in the collection (in iteration order) with a list of downstream matchers.
LiteralKeyExpression<T>	Expression to allow a static value to be utilized in a key expression.
LiteralValue<T>	A wrapper around a literal of the given type.
LiteralValue.Deserializer<T>	Deserializer.
LocatableResolver	LocatableResolver represents the concept of a locatable bi-directional mapping between Strings and Longs that is rooted at some location in the FDB key space.
LocatableResolver.LocatableResolverLockedException	Exception thrown when the locatable resolver is locked.
LockIdentifier	Tuple-based identifier used to locate a resource in the LockRegistry.
LockRegistry	The LockRegistry keeps track of locking over resources in the context of a single transaction.
LoggableTimeoutException	Subclass of TimeoutException with support for adding logging info in the form of keys and values.
LogicalDistinctExpression	A relational planner expression representing a stream of distinct records.
LogicalFilterExpression	A relational planner expression that represents an unimplemented filter on the records produced by its inner relational planner expression.
LogicalIntersectionExpression	A query plan that executes by taking the union of records from two or more compatibly-sorted child plans.
LogicalProjectionExpression	A relational planner expression that projects its input values.
LogicalSortExpression	A relational planner expression that represents an unimplemented sort on the records produced by its inner relational planner expression.
LogicalTypeFilterExpression	A relational planner expression that represents an unimplemented type filter on the records produced by its inner relational planner expression.
LogicalUnionExpression	A relational planner expression that represents an unimplemented union of its children.
LogicalUniqueExpression	A relational planner expression representing a stream of unique records.
LogMessageKeys	Common KeyValueLogMessage keys logged by the Record Layer core.
LongArithmethicFunctionKeyExpression	Function key expression representing evaluating arithmetic functions on longs.
LongArithmethicFunctionKeyExpression.Builder	Builder for LongArithmethicFunctionKeyExpressions.
LongArithmethicFunctionKeyExpression.LongArithmethicFunctionKeyExpressionFactory	Factory for constructing built-in arithmetic functions that operate on longs.
LongState	Accumulator state for Long types.
MapCursor<T,V>	Deprecated. Use RecordCursor.map(java.util.function.Function<T, V>) or MapResultCursor instead
MappedPool<K,V,E extends java.lang.Exception>	MappedPool Class Attempts to reuse objects organized by keys.
MappedPool.MappedPoolProvider<K,V,E extends java.lang.Exception>	Function with Exceptions to provide the pool.
MapPipelinedCursor<T,V>	A cursor that applies an asynchronous function to the elements of another cursor.
MapResultCursor<T,V>	A cursor that applies a function to the elements of another cursor.
MapUtils	Utility functions for manipulating maps.
MapWhileCursor<T,V>	A RecordCursor that calls a function that maps the value and can stop the cursor.
MapWhileCursor.StopContinuation	What to return for RecordCursorResult.getContinuation() after stopping.
MatchableSortExpression	A relational planner expression that represents an unimplemented sort on the records produced by its inner relational planner expression.
MatchAccumulator<M,R>	Class to used to accumulate the individual match results (the results of applying the MatchFunction) into an object of type R.
MatchCandidate	Interface to represent a match candidate.
MatchConstantValueRule	A rule that matches any Value (with the argument values) that is a constant expression.
MatchFieldValueAgainstQuantifiedObjectValueRule	A rule that matches a QuantifiedObjectValue (with the argument values).
MatchFieldValueOverFieldValueRule	A rule that matches a FieldValue over another FieldValue to simplify into one FieldValue using a concatenated accessor path.
MatchFunction<T,M>	An functional interface for a match function that computes a match result (an Iterable of type M.
MatchInfo	This interface represents the result of matching one expression against an expression from a MatchCandidate.
MatchInfo.AdjustedBuilder	Builder for an adjusted MatchInfo.
MatchInfo.AdjustedMatchInfo	An adjusted MatchInfo that is based on another underlying MatchInfo.
MatchInfo.RegularMatchInfo	Implementation of MatchInfo that represents a match between two expressions.
MatchIntermediateRule	Expression-based transformation rule that matches any non-leaf expression (called an intermediate expression) to a candidate expression in a MatchCandidate.
MatchIntermediateRule.PartialMatchWithQuantifier	Partial match with a quantifier pulled up along with the partial match during matching.
MatchLeafRule	Expression-based transformation rule that matches any leaf expression.
MatchOrCompensateFieldValueRule	A rule that matches a FieldValue (with the argument values).
MatchPartition	Case class to represent a partition of partial matches.
MatchPartitionMatchers	Matchers for MatchPartition.
MatchPredicate<T>	An predicate that tests for a match between quantifiers also taking into account an equivalence maps between CorrelationIdentifiers.
MatchSimpleFieldValueRule	A rule that matches any simple FieldValue, i.e.
MatchValueAgainstQuantifiedObjectValueRule	A rule that matches a Value against the current QuantifiedObjectValue.
MatchValueRule	A rule that matches a Value (with the argument values).
MaxMatchMap	Represents a maximum match between a query result Value and a candidate result Value.
MaxMatchMapSimplificationRuleSet	A set of rules for use by the maximum map computation logic.
Memoizer	A memoization interface.
Memoizer.ReferenceBuilder	Builder for references.
MemoryDam<K,V>	Collect keyed values into a LinkedHashMap so that they end up sorted in insertion order.
MemoryScratchpad<K,V,M extends java.util.Map<K,V>>	Collect keyed values into an in-memory data structure.
MemoryScratchpad.LoadResult<K>	The result of MemoryScratchpad.load(com.apple.foundationdb.record.RecordCursor<V>, K).
MemoryScratchpad.RecordCountInMemoryLimitMode	How the getMaxRecordCountInMemory is interpreted for MemoryScratchpad.load(com.apple.foundationdb.record.RecordCursor<V>, K).
MemorySortAdapter<K,V>	Provide various options for MemorySorter and MemorySortCursor.
MemorySortAdapter.InsertionOrderComparator<K>	Stateful comparator supporting insertion order and delegating to a regular Comparator to establish equality between the minimum key and a probe.
MemorySortAdapter.MemorySortComparator<K>	An extended version of a comparator that can be stateful.
MemorySortAdapter.OrderComparator<K>	Stateful comparator to support orderings based on regular comparisons delegated to a Comparator.
MemorySortCursor<K,V>	Sort records in memory up to a specified limit, then return them in order.
MemorySorter<K,V>	Collect keyed values into a TreeMap so that they end up sorted.
MergeCursor<T,U,S extends MergeCursorState<T>>	An abstract class that corresponds to some kind of cursor merging multiple children together.
MergeCursorContinuation<B extends Message.Builder,C extends RecordCursorContinuation>	Common code for handling the continuations of MergeCursors.
MergeCursorState<T>	A holder for mutable state needed to track one of the children cursors of some merge operation.
MergeFetchIntoCoveringIndexRule	A rule that merges a fetch into a covering index scan.
MergeProjectionAndFetchRule	A rule that removes a LogicalProjectionExpression and a RecordQueryFetchFromPartialRecordPlan if all fields needed by the projection are already available prior to the fetch.
MessageBuilderRecordSerializer	Serialize records using default Protobuf serialization using the supplied message builder for the union message type.
MessageBuilderRecordSerializerBase<M extends Message,U extends Message,B extends Message.Builder>	Base class for record serializers that use a supplied union message builder method reference to reconstruct records.
MessageHelpers	A utility class for extracting data and meta-data from Protocol Buffer Messages, as used in the Record Layer.
MessageHelpers.CoercionBiFunction	Coercion (bi)-function which also is plan hashable.
MessageHelpers.CoercionTrieNode	Trie data structure of Type.Record.Fields to conversion functions used to coerce an object of a certain type into an object of another type.
MessageHelpers.TransformationTrieNode	Trie data structure of Type.Record.Fields to Values.
MetaDataCache	A caching hook for FDBMetaDataStore.
MetaDataEvolutionValidator	This class can be used to validate that the new meta-data for a record store is responsibly evolved from its existing meta-data.
MetaDataEvolutionValidator.Builder	A builder class for the MetaDataEvolutionValidator.
MetaDataException	Exception thrown when there is a problem with something in the RecordMetaDataProto.MetaData.
MetaDataPlanContext	A PlanContext where the underlying meta-data comes from RecordMetaData and RecordStoreState objects, as is generally the case when planning actual queries.
MetaDataProtoEditor	A helper class for mutating the meta-data proto.
MetaDataProtoEditor.AmbiguousTypeNameException	An exception that is thrown if the type of a field is ambiguous.
MetaDataValidator	Validator for RecordMetaData.
MetaDataVersionStampStoreStateCache	An implementation of the FDBRecordStoreStateCache that uses the database's meta-data version-stamp key as the cache invalidation key.
MetaDataVersionStampStoreStateCacheFactory	A factory for creating MetaDataVersionStampStoreStateCaches.
MinimumTupleSizeKeyChecker	Key checker that reports when operations are not limited to a single tuple subspace of a given minimum size.
MinimumTupleSizeKeyChecker.CheckedSubspace	A key prefix and associated check settings.
MultiDimensionalIndexHelper	Helper functions for index maintainers that use a RTree.
MultiDimensionalIndexHelper.Events	Instrumentation events specific to R-tree index maintenance.
MultidimensionalIndexMaintainer	An index maintainer for keeping a RTree.
MultidimensionalIndexMaintainerFactory	A factory for MultidimensionalIndexMaintainer indexes.
MultidimensionalIndexScanBounds	IndexScanBounds for a multidimensional index scan.
MultidimensionalIndexScanBounds.And	Scan bounds that consists of other MultidimensionalIndexScanBounds.SpatialPredicates to form a logical AND.
MultidimensionalIndexScanBounds.Hypercube	Scan bounds describing an n-dimensional hypercube.
MultidimensionalIndexScanBounds.Or	Scan bounds that consists of other MultidimensionalIndexScanBounds.SpatialPredicates to form a logical OR.
MultidimensionalIndexScanBounds.SpatialPredicate	Spatial predicate.
MultidimensionalIndexScanComparisons	ScanComparisons for use in a multidimensional index scan.
MultidimensionalIndexScanComparisons.Deserializer	Deserializer.
MultiMatcher<T>	A multi matcher is a CollectionMatcher and by extension also a BindingMatcher that binds to a sub collection of objects in the presented collection.
MultiMatcher.AllMatcher<T>	A multi matcher that binds to all objects in the collection it is being matched or it does not match anything at all, i.e.
MultiMatcher.SomeMatcher<T>	A multi matcher that binds a sub collection of objects of the collection it is being matched.
MutableRecordStoreState	A record store that can be modified to reflect changes made to the database.
Narrowable<T>	Narrow-able trait that can safely downcast to a particular implementation.
NestedField	A QueryComponent that evaluates a nested component against a Message-valued field.
NestedRecordType	Extension of record type representing a nested message within a larger record type.
NestedRecordTypeBuilder	Builder class for NestedRecordTypes.
NestingKeyExpression	A key expression within a nested subrecord.
NodeIcon	NodeIcon Ids.
NodeInfo	Explanatory information about the Record Layer's plan operators and storage objects.
NonnullPair<L,R>	A Pair implementation where both elements are not null.
NoOpIndexMaintainer	An index maintainer that doesn't do anything.
NoOpIndexMaintainerFactory	A factory for NoOpIndexMaintainer indexes.
NormalFormRule	A rule that transforms a boolean expression into a normal form.
NormalizedResidualPredicateProperty	This property collects a QueryPredicate that represents the entirety of all accumulated residual predicates.
NormalizePredicatesRule	Rule to create the conjunctive normal form of the predicates in a SelectExpression.
NoSuchDirectoryException	Exception thrown when a KeySpaceDirectory does not have the named directory component.
NotComponent	A QueryComponent that is satisfied when its child component is not satisfied.
NotMatcher	Matcher that matches the current object if its downstream was unable to match and vice versa.
NotOverComparisonRule	A rule that matches a NotPredicate (with the argument values) and attempts to push it into a boolean variable underneath (which can be a comparison).
NotPredicate	A QueryPredicate that is satisfied when its child component is not satisfied.
NotPredicate.Deserializer	Deserializer.
NotValue	A value that flips the output of its boolean child.
NotValue.Deserializer	Deserializer.
NotValue.NotFn	The not function.
NullableArrayTypeUtils	A Utils class that holds logic related to nullable arrays.
NullValue	A value that evaluates to empty.
NullValue.Deserializer	Deserializer.
NumericAggregationValue	Aggregation over numeric values.
NumericAggregationValue.Avg	Average aggregation Value.
NumericAggregationValue.Avg.Deserializer	Deserializer.
NumericAggregationValue.AvgFn	The avg function.
NumericAggregationValue.BitmapConstructAgg	Bitmap aggregation Value.
NumericAggregationValue.BitmapConstructAgg.Deserializer	Deserializer.
NumericAggregationValue.BitmapConstructAggFn	The bitmap function.
NumericAggregationValue.Max	Max aggregation Value.
NumericAggregationValue.Max.Deserializer	Deserializer.
NumericAggregationValue.MaxFn	The max function.
NumericAggregationValue.Min	Min aggregation Value.
NumericAggregationValue.Min.Deserializer	Deserializer.
NumericAggregationValue.MinFn	The min function.
NumericAggregationValue.NumericAccumulator	Accumulator for aggregation using a type- and function-specific operator.
NumericAggregationValue.PhysicalOperator	The function- x type-specific numeric aggregator.
NumericAggregationValue.Sum	Sum aggregation Value.
NumericAggregationValue.Sum.Deserializer	Deserializer.
NumericAggregationValue.SumFn	The sum function.
ObjectPlanHash	This class implements a planHash for the member classes of the query plan.
ObjectValue	A Value representing any object.
ObjectValue.Deserializer	Deserializer.
OfTypeValue	Checks whether a Value's evaluation conforms to its result type.
OfTypeValue.Deserializer	Deserializer.
OneOfThem	Class for matching any value of a repeated field.
OneOfThemWithComparison	A QueryComponent that evaluates a Comparisons.Comparison against each of the values of a repeated field and is satisfied if any of those are.
OneOfThemWithComponent	A QueryComponent that evaluates a nested component against each of the values of a repeated field and is satisfied if any of those are.
OnlineIndexer	Builds an index online, i.e., concurrently with other database operations.
OnlineIndexer.Builder	Builder for OnlineIndexer.
OnlineIndexer.IndexingPolicy	A builder for the indexing policy.
OnlineIndexer.IndexingPolicy.Builder	Builder for OnlineIndexer.IndexingPolicy.
OnlineIndexer.IndexingPolicy.DesiredAction	Possible actions when an index is already partially built.
OnlineIndexer.IndexingPolicy.TakeoverTypes	Possible conversion from one indexing method to another.
OnlineIndexer.IndexStatePrecondition	This defines in which situations the index should be built.
OnlineIndexer.RecordBuiltRangeException	This Exception can be thrown in the case that one calls one of the methods that explicitly state that they are building an unbuilt range, i.e., a range of keys that contains no keys which have yet been processed by the OnlineIndexer during an index build.
OnlineIndexOperationBaseBuilder<B extends OnlineIndexOperationBaseBuilder<B>>	Base class that the OnlineIndexer.Builder and the OnlineIndexScrubber.Builder can both inherit from.
OnlineIndexOperationConfig	A holder for the mutable configuration parameters needed to rebuild an online index.
OnlineIndexOperationConfig.Builder	A builder for OnlineIndexOperationConfig.
OnlineIndexScrubber	Scan indexes for problems and optionally report or repair.
OnlineIndexScrubber.Builder	Builder for OnlineIndexScrubber.
OnlineIndexScrubber.ScrubbingPolicy	A builder for the scrubbing policy.
OnlineIndexScrubber.ScrubbingPolicy.Builder	Builder for OnlineIndexScrubber.ScrubbingPolicy.
OptionalIfPresentMatcher<T>	A matcher that matches an optional if the object is present.
OrComponent	A QueryComponent that is satisfied when any of its child components is satisfied.
OrderedBytesHelpers	A value that produces a binary encoding that is comparable according to certain modes gives by TupleOrdering.Direction.
OrderFunctionKeyExpression	ORDER_xxx function.
OrderFunctionKeyExpressionFactory	Factory for OrderFunctionKeyExpression for each supported direction.
Ordering	This class captures an ordering property.
Ordering.Binding	A helper class used inside an Ordering to indicate if a value is considered to be ascending, descending, or fixed to a comparison/a set of comparisons (which have to be of type ComparisonRange.Type.EQUALITY).
Ordering.DirectOrderPreservingValue	Interface that declares that all instances of the implementing class are directly order-preserving.
Ordering.Intersection	TODO.
Ordering.InverseOrderPreservingValue	Interface that declares that all instances of the implementing class are inverse order-preserving.
Ordering.MergeOperator<O extends Ordering.SetOperationsOrdering>	Merge operator for orderings.
Ordering.OrderPreservingKind	Enum to differentiate the different kinds of preserving order.
Ordering.OrderPreservingValue	Interface that declares that this Value preserves the order of the input value in some way.
Ordering.SetOperationsOrdering	Abstract static class that represents an ordering that is produced by an ordered set operation such as a union or intersection operation prior to the application of a comparison key.
Ordering.Union	TODO.
OrderingPart<S extends OrderingPart.SortOrder>	A class that is used to express ordered-ness.
OrderingPart.MatchedOrderingPart	An OrderingPart that is bound by a comparison during graph matching.
OrderingPart.MatchedSortOrder	Sort order that can be assigned during index matching.
OrderingPart.OrderingPartCreator<O extends OrderingPart.SortOrder,P extends OrderingPart<O>>	Functional interface to be used to create instances of a particular kind of OrderingPart.
OrderingPart.ProvidedOrderingPart	Final class to tag provided ordering parts and to seal OrderingPart.
OrderingPart.ProvidedSortOrder	Enum implementing OrderingPart.SortOrder that provides sort orders that for instance a plan can provide to downstream operators.
OrderingPart.RequestedOrderingPart	Final class to tag requested ordering parts and to seal OrderingPart.
OrderingPart.RequestedSortOrder	Sort order used to model requested orderings, that is orderings that a down stream operator or the client requires the result set of the upstream operator to adhere to.
OrderingPart.SortOrder	A common interface all sort orders have to implement.
OrderingProperty	A property used for the ordering(s) of a plan.
OrderingProperty.OrderingVisitor	A property that determines the ordering of a RecordQueryPlan.
OrderingValueComputationRuleSet<O extends OrderingPart.SortOrder,P extends OrderingPart<O>>	A set of rules for simplifying Value trees used to expression ordering constraints.
OrderQueryKeyExpression	Handle OrderFunctionKeyExpression in a query.
OrElseCursor<T>	A cursor that returns the elements of one cursor followed by the elements of another cursor if the first was empty.
OrPredicate	A QueryPredicate that is satisfied when any of its child components is satisfied.
OrPredicate.Deserializer	Deserializer.
Pair<L,R>	A simple interface for pairs of two elements.
ParameterRelationshipGraph	A class to keep track of the relationships of parameters in a query given a RecordQuery and a set of pre-bindings.
ParameterRelationshipGraph.Relationship	A relationship between two parameter values.
ParameterRelationshipGraph.RelationshipType	The type of ParameterRelationshipGraph.Relationship.
PartiallyOrderedSet<T>	A class to represent partially ordered set of elements of some type.
PartiallyOrderedSet.Builder<T>	Builder for PartiallyOrderedSet.
PartiallyOrderedSet.EligibleSet<T>	A class allowing to compute a subset of elements in a partial order that are said to be eligible.
PartialMatch	Case class to represent a partial match.
PartialMatchMatchers	Matchers of PartialMatch.
PartitionBinarySelectRule	A rule that splits a SelectExpression into a new upper and two lower SelectExpression that can absorb predicates which may prove advantageous for the implementation rules.
PartitionSelectRule	A rule that splits a SelectExpression into two SelectExpressions .
PassThroughRecordStoreStateCache	An implementation of the FDBRecordStoreStateCache interface that does not actually cache anything.
PassThroughRecordStoreStateCacheFactory	A factory for creating PassThroughRecordStoreStateCaches.
PathValue	A class to represent the value stored at a particular element of a KeySpacePath.
PatternForLikeValue	A Value that applies a like operator on its child expressions.
PatternForLikeValue.Deserializer	Deserializer.
PatternForLikeValue.PatternForLikeFn	The patternForLike operator.
PermutedMinMaxIndexMaintainer	An index that maintains an extremum value in a way that can be enumerated by that value rather than by group.
PermutedMinMaxIndexMaintainer.Type
PermutedMinMaxIndexMaintainerFactory	A factory for PermutedMinMaxIndexMaintainer indexes.
PickValue	A value representing multiple "alternative" values.
PickValue.Deserializer	Deserializer.
PipelineOperation	Kind of asynchronous pipelined operation being performed.
Placeholder	A Placeholder is basically a PredicateWithValueAndRanges with an alias that is used solely used for index matching.
PlanContext	A basic context object that stores all of the metadata about a record store, such as the available indexes.
PlanDeserializer<M extends Message,T>	Interface that needs to be implemented separately for every class that is PlanSerializable.
PlanHashable	A more stable version of Object.hashCode().
PlanHashable.PlanHashKind	The "kinds" of planHash calculations.
PlanHashable.PlanHashMode	A mode for a plan hash which captures both kind and version.
PlannableIndexTypes	A wrapper class to identify groups of that behave the same way from the perspective of the planner.
PlannerBindings	A map-like structure that supports a map from a binding to a collection of objects, such as RelationalExpressions and References.
PlannerBindings.Builder	A mutable builder for a set of PlannerBindings which can be used to incrementally build up a set of bindings without repeatedly calling PlannerBindings.mergedWith(PlannerBindings), which is less efficient.
PlannerConstraint<T>	Base interface to capture constraints for the planner.
PlannerGraph	Lightweight class to save some boilerplate.
PlannerGraph.DataNodeWithInfo	Node class for data objects.
PlannerGraph.Edge	Edge class.
PlannerGraph.ExistentialQuantifierEdge	Edge class for existential quantifiers.
PlannerGraph.ForEachQuantifierEdge	Edge class for for-each quantifiers.
PlannerGraph.InternalPlannerGraphBuilder	Specific builder for explain planner graph building.
PlannerGraph.LogicalOperatorNode	Node class for logical operators.
PlannerGraph.LogicalOperatorNodeWithInfo	Node class for logical operators that also have a NodeInfo.
PlannerGraph.ModificationLogicalOperatorNode	Node class for logical operators that also have a NodeInfo.
PlannerGraph.ModificationOperatorNodeWithInfo	Node class for actual plan operators.
PlannerGraph.ModificationTargetEdge	Edge class for modification (delete, insert, update) targets.
PlannerGraph.Node	Node class functioning as parent for any nodes in the network.
PlannerGraph.NodeWithInfo	Node class that additionally captures a reference to a NodeInfo.
PlannerGraph.OperatorNodeWithInfo	Node class for actual plan operators.
PlannerGraph.PartialMatchEdge	Edge class for matches that connect a query reference to a match candidate reference.
PlannerGraph.PhysicalQuantifierEdge	Edge class for physical quantifiers.
PlannerGraph.ReferenceEdge	Edge class for Reference.
PlannerGraph.ReferenceHeadNode	Node class for References -- head.
PlannerGraph.ReferenceInternalEdge	Edge class for Reference.
PlannerGraph.ReferenceMemberNode	Node class for Reference - member.
PlannerGraph.TemporaryDataNodeWithInfo	Node class for temporary data objects.
PlannerGraph.WithExpression	Interface to be implemented by all node classes that represent an RelationalExpression.
PlannerGraph.WithInfoId	Interface to be implemented by all node classes that need to externalize an info id for exporting global information such as names and descriptions.
PlannerGraphProperty	Class to hold a graph for explain, optimization, and rewrite purposes.
PlannerGraphProperty.NamedCluster	Class to represent an actual sub cluster of inside the planner graph.
PlannerGraphRewritable	Interface to allow RelationalExpressions to rewrite their own graph representation.
PlannerRule<R,C extends PlannerRuleCall<R>,T>	Basic rule interface.
PlannerRule.PreOrderRule	Marker interface for rules that run in pre-order.
PlannerRuleCall<R>	A PlannerRuleCall is a context object that supports a single application of a rule to a particular expression.
PlannerRuleSet	A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
PlanOrderingKey	The keys that order the results from a plan.
PlanPartition	A plan partition used for matching.
PlanProperty<A>	Base interface to capture attributes for plans.
PlanSelector	A plan selector selects one plan from the given list via some policy.
PlanSerializable	Base interface to indicate that a java class is reachable through a RecordQueryPlan and therefore needs to be capable of serialization/deserialization.
PlanSerialization	Class to facilitate serialization and deserialization of RecordQueryPlans.
PlanSerializationContext	Context class defining the state of serialization/deserialization currently in-flight.
PlanSerializationRegistry	Plugin interface to be used by the plan serialization framework to dispatch serialization/deserialiation invocations properly.
PlanWithOrderingKey	A plan that knows its own {#link PlanOrderingKey}.
PlanWithStoredFields	A plan that has some, but not all, stored fields.
PredicatedMatcher	Tag interface for predicate matchers, that is instances of FindingMatcher.
PredicateMap	Predicate map that enforces a constraint that a predicate can only be mapped to at most one candidate.
PredicateMap.Builder	Builder class for a predicate maps.
PredicateMultiMap	Map that maps from a QueryPredicate of a query to a QueryPredicate of a MatchCandidate.
PredicateMultiMap.Builder	Builder class for a predicate maps.
PredicateMultiMap.PredicateCompensation	Functional interface to reapply a predicate if necessary.
PredicateMultiMap.PredicateCompensationFunction	Functional interface to reapply a predicate if necessary.
PredicateMultiMap.PredicateMapping	Mapping class.
PredicateMultiMap.PredicateMapping.Builder	Builder class for PredicateMultiMap.PredicateMapping.
PredicateMultiMap.PredicateMapping.MappingKey	Class to capture the relationship between query predicate and candidate predicate.
PredicateMultiMap.PredicateMapping.MappingKind	Kind of mapping.
PredicateMultiMap.ResultCompensationFunction	Functional interface to finally adjust the shape of the records returned by the index/match.
PredicateToLogicalUnionRule	Transform a SelectExpression with a set of QueryPredicates into a union operation.
PredicateWithComparisons	Tag interface to announce that the implementing class can provide Comparisons.Comparisons upon request.
PredicateWithValue	A predicate consisting of a Value.
PredicateWithValueAndRanges	This class associates a Value with a set of range constraints (RangeConstraints).
PredicateWithValueAndRanges.Deserializer	Deserializer.
PreOrderIterator<T extends TreeLike<T>>	An iterator that accesses all elements of a TreeLike object in pre-order fashion.
PrettyExplainFormatter	A formatter for tokens.
PrettyExplainFormatter.Color	Utility class that encapsulates ANSI escape sequences for colors.
PrimaryAccessExpansionVisitor	Class to expand primary data access into a candidate.
PrimaryAccessHint	Represents reading a table directly without using an index plus fetch.
PrimaryKeyProperty	The primary key property that computes the primary key of a sub graph if it exists.
PrimaryKeyProperty.PrimaryKeyVisitor	Planner property which indicates if the record flowed as the result of a RecordQueryPlan flows things stored records flow, e.g.
PrimaryScanExpression	A logical version of RecordQueryScanPlan.
PrimaryScanMatchCandidate	Case class to represent a match candidate that is backed by an index.
PrimitiveAccumulatorOperation	The types of accumulation operations allowed for a primitive accumulator.
PrimitiveMatchers	Binding matchers (BindingMatcher) for primitive types.
ProbableIntersectionCursor<T>	A cursor that returns all results that are probably in all of its children.
PromoteValue	A value that promotes an object of a type to an object of another type.
PromoteValue.ArrayCoercionBiFunction	Coercion function for arrays.
PromoteValue.ArrayCoercionBiFunction.Deserializer	Deserializer.
PromoteValue.Deserializer	Deserializer.
PromoteValue.PrimitiveCoercionBiFunction	A coercion function for primitive types.
PromoteValue.PrimitiveCoercionBiFunction.Deserializer	Deserializer.
PropertiesMap	Class to manage properties for plans.
Proposition	Represents a three-valued logic operation.
ProtoSerializable	A interface indicating whether a given type can be serialized into a ProtoBuf Message.
ProtoUtils	Utility functions for interacting with protobuf.
ProtoUtils.DynamicEnum	A dynamic enum when we don't want to worry about actual enum structures/descriptors etc.
PullUp	Chain to pull up Value trees through a series of relational expressions.
PullUpNullOnEmptyRule	A rewrite rule that splits a SelectExpression expression that ranges over a child with a Quantifier that has null-on-empty semantics into two parts: a lower SelectExpression expression that ranges over the old child with a normal Quantifier, i.e.
PullUpValueRuleSet	A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
PushDistinctBelowFilterRule	A rule that moves a RecordQueryUnorderedPrimaryKeyDistinctPlan below a RecordQueryFilterPlan.
PushDistinctThroughFetchRule	A rule that pushes a RecordQueryUnorderedPrimaryKeyDistinctPlan through a RecordQueryFetchFromPartialRecordPlan in order to reduce the number of records prior to a potentially expensive fetch operation.
PushFilterThroughFetchRule	A rule that pushes a set of predicates that can be evaluated on a partial record of keys and values that were retrieved by an index scan underneath a RecordQueryFetchFromPartialRecordPlan in order to filter out records not satisfying the pushed predicates prior to a potentially expensive fetch operation.
PushInJoinThroughFetchRule<P extends RecordQueryInJoinPlan>	A rule that pushes a RecordQueryInJoinPlan through a RecordQueryFetchFromPartialRecordPlan.
PushMapThroughFetchRule	A rule that pushes a map expression containing a Value that can be evaluated on a partial record of keys and values that were retrieved by an index scan underneath a RecordQueryFetchFromPartialRecordPlan in order to eliminate the fetch altogether.
PushReferencedFieldsThroughDistinctRule	A rule that pushes a ReferencedFieldsConstraint through a LogicalDistinctExpression.
PushReferencedFieldsThroughFilterRule	A rule that pushes a ReferencedFieldsConstraint through a LogicalFilterExpression.
PushReferencedFieldsThroughSelectRule	A rule that pushes a ReferencedFieldsConstraint through a SelectExpression.
PushReferencedFieldsThroughUniqueRule	A rule that pushes a ReferencedFieldsConstraint through a LogicalUniqueExpression.
PushRequestedOrderingThroughDeleteRule	A rule that pushes an ordering RequestedOrderingConstraint through a DeleteExpression.
PushRequestedOrderingThroughDistinctRule	A rule that pushes an RequestedOrderingConstraint through a LogicalDistinctExpression.
PushRequestedOrderingThroughGroupByRule	Rule that passes sorting requirements from GROUP BY expression downstream.
PushRequestedOrderingThroughInLikeSelectRule	A rule that pushes an RequestedOrderingConstraint through a specific SelectExpression.
PushRequestedOrderingThroughInsertRule	A rule that pushes an ordering RequestedOrderingConstraint through an InsertExpression.
PushRequestedOrderingThroughInsertTempTableRule	A rule that pushes an ordering RequestedOrderingConstraint through an TempTableInsertExpression.
PushRequestedOrderingThroughRecursiveUnionRule	A rule that pushes an ordering RequestedOrderingConstraint through a RecursiveUnionExpression.
PushRequestedOrderingThroughSelectExistentialRule	A rule that pushes a ReferencedFieldsConstraint through a SelectExpression.
PushRequestedOrderingThroughSelectRule	A rule that pushes a ReferencedFieldsConstraint through a SelectExpression.
PushRequestedOrderingThroughSortRule	A rule that pushes an ordering RequestedOrderingConstraint through a LogicalSortExpression.
PushRequestedOrderingThroughUnionRule	A rule that pushes an ordering RequestedOrderingConstraint through a LogicalUnionExpression.
PushRequestedOrderingThroughUniqueRule	A rule that pushes an RequestedOrderingConstraint through a LogicalUniqueExpression.
PushRequestedOrderingThroughUpdateRule	A rule that pushes an ordering RequestedOrderingConstraint through an UpdateExpression.
PushSetOperationThroughFetchRule<P extends RecordQuerySetPlan>	A (prototype) rule that pushes a set operation (e.g.
PushTypeFilterBelowFilterRule	A rule that moves a RecordQueryTypeFilterPlan below a RecordQueryFilterPlan.
QuantifiedObjectValue	A value representing the quantifier as an object.
QuantifiedObjectValue.Deserializer	Deserializer.
QuantifiedRecordValue	A value representing the quantifier as an object.
QuantifiedRecordValue.Deserializer	Deserializer.
QuantifiedValue	A scalar value type that is directly derived from an alias.
Quantifier	Models the concept of quantification.
Quantifier.Builder<Q extends Quantifier,B extends Quantifier.Builder<Q,B>>	Builder class for quantifiers.
Quantifier.Existential	A quantifier that conceptually flows exactly one item containing a boolean to the owning expression indicating whether the sub-graph that the quantifier ranges over, produced a non-empty or an empty result.
Quantifier.Existential.ExistentialBuilder	Builder subclass for existential quantifiers.
Quantifier.ForEach	A quantifier that conceptually flows one item at a time from the expression it ranges over to the owning expression.
Quantifier.ForEach.ForEachBuilder	Builder subclass to build for-each quantifiers.
Quantifier.Physical	Physical quantifier.
Quantifier.Physical.PhysicalBuilder	Builder subclass for physical quantifiers.
QuantifierMatchers	Matchers for Quantifiers.
Quantifiers	Auxiliary class containing factory methods and helpers for Quantifier.
Quantifiers.AliasResolver	Resolver to resolve aliases to quantifiers.
QueriedValue	A value representing the source of a value derivation.
QueriedValue.Deserializer	Deserializer.
Query	Holder class for creating querying expressions.
Query.InvalidExpressionException	Exception thrown when a query expression is not valid in some context.
QueryableKeyExpression	A KeyExpression that can be used with a QueryKeyExpressionWithComparison.
QueryComponent	Base component interface for checking whether a given record matches a query.
QueryHashable	Query hash - calculate and return identifying hash values for queries.
QueryHashable.QueryHashKind	The "kinds" of queryHash calculations.
QueryKeyExpression	Allow use of a QueryableKeyExpression in a query.
QueryKeyExpressionWithComparison	A QueryComponent that implements a Comparisons.Comparison against a QueryableKeyExpression.
QueryKeyExpressionWithOneOfComparison	A QueryComponent that implements a Comparisons.Comparison against a multi-valued QueryableKeyExpression.
QueryPlan<T>	An executable query plan.
QueryPlanConstraint	Represents a query plan constraint.
QueryPlanInfo	This class holds some additional information regarding the query plan that can be attached to the plan itself, without impacting its structure.
QueryPlanInfo.Builder	A Builder for the QueryPlanInfo class.
QueryPlanInfo.QueryPlanInfoKey<T>	An implementation of a type-safe Enum.
QueryPlanInfoKeys	Container for QueryPlanInfo.QueryPlanInfoKey static instances used in the planner.
QueryPlanner	A common interface for classes that can plan a RecordQuery into a RecordQueryPlan.
QueryPlanner.IndexScanPreference	Preference between index scan and record scan.
QueryPlanResult	The result of planning a query.
QueryPlanUtils	Utility class for query planning.
QueryPredicate	Class to model the concept of a predicate.
QueryPredicateComputationRule<ARGUMENT,RESULT,TYPE extends QueryPredicate>	Intermediate class that fixes the type of the PlannerRuleCall.
QueryPredicateComputationRuleCall<ARGUMENT,RESULT>	A rule call implementation for the computation of a result while traversing QueryPredicate trees.
QueryPredicateComputationRuleSet<ARGUMENT,RESULT>	A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
QueryPredicateMatchers	A BindingMatcher is an expression that can be matched against a RelationalExpression tree, while binding certain expressions/references in the tree to expression matcher objects.
QueryPredicateWithChild	A scalar value type that has children.
QueryPredicateWithCnfRuleSet	A set of rules for use by a planner that supports quickly finding rules that could match a given QueryPredicate.
QueryPredicateWithDnfRuleSet	A set of rules for use by a planner that supports quickly finding rules that could match a given QueryPredicate.
QueryRecordFunction<T>	Class that provides context for asserting about a specially calculated value.
QueryRecordFunctionWithComparison	A Comparisons.Comparison whose value from the record, to be compared with the comparison's value, is the result of applying a RecordFunction to the record.
QueryResult	QueryResult is the general result that encapsulates the data that is flowed up from plan to plan as well as from plan to consumer.
QueryToKeyMatcher	Match a query filter, represented by a QueryComponent, to a KeyExpression.
QueryToKeyMatcher.Match	The result of matching a particular KeyExpression.
QueryToKeyMatcher.MatchType	Whether a match was a successful, and if it was, whether the resulting keys have a single value.
RangeConstraints	Represents a compile-time range that can be evaluated against other compile-time ranges with an optional list of deferred ranges that cannot be evaluated at compile-time but can still be used as scan index prefix.
RangeConstraints.Builder	Builds an instance of RangeConstraints.
RangeConstraints.CompilableRange	Represents a range that comprises an intersection of a set of Comparisons.Comparison with reference operands (i.e.
RangeCursor	A cursor that returns a sequence from 0 to an (exclusive) limit.
RankComparisons	Track comparisons involving rank-type functions.
RankComparisons.RankComparison	A single rank function comparison.
RankedSetHashFunctions	Known hash functions available as index options.
RankedSetIndexHelper	Helper functions for index maintainers that use a RankedSet.
RankedSetIndexHelper.Events	Instrumentation events specific to rank index maintenance.
RankedSetIndexHelper.InstrumentedRankedSet	A RankedSet that adds StoreTimer instrumentation.
RankIndexMaintainer	An index maintainer for keeping a RankedSet of record field values.
RankIndexMaintainerFactory	A factory for RankIndexMaintainer indexes.
RankValue	A windowed value that computes the RANK of a list of expressions which can optionally be partitioned by expressions defining a window.
RankValue.Deserializer	Deserializer.
ReadVersionRecordStoreStateCache	An implementation of the FDBRecordStoreStateCache that uses the read-version of the associated transaction as the cache invalidation key.
ReadVersionRecordStoreStateCacheFactory	A factory for creating ReadVersionRecordStoreStateCaches.
RecordAlreadyExistsException	Exception thrown when FDBRecordStoreBase.insertRecord(M) is called, but the record already exists.
RecordConstructorValue	A Value that encapsulates its children Values into a single Value of a Type.Record type.
RecordConstructorValue.Deserializer	Deserializer.
RecordConstructorValue.RecordFn	The record function.
RecordCoreArgumentException	Functional equivalent of IllegalArgumentException.
RecordCoreException	An exception thrown by the core of the Record Layer.
RecordCoreInterruptedException	Functional equivalent of InterruptedException.
RecordCoreRetriableTransactionException	An exception from transaction processing that ought to be retried.
RecordCoreStorageException	Exceptions due to problems with the state of or connection to a particular record store.
RecordCursor<T>	An asynchronous iterator that supports continuations.
RecordCursor.ContinuationConvertor	Transformation to apply to a continuation.
RecordCursor.NoNextReason	The reason that RecordCursorResult.hasNext() returned false.
RecordCursorContinuation	An interface for types that represent the continuation of a RecordCursor.
RecordCursorEndContinuation	A concrete continuation representing that a RecordCursor has returned all of the records that it ever will.
RecordCursorIterator<T>	An asynchronous iterator that wraps a RecordCursor and presents an iterator-style interface for advancing the cursor.
RecordCursorResult<T>	A result obtained when a RecordCursor advances.
RecordCursorResult.IllegalResultNoNextReasonAccessException	An exception thrown when RecordCursorResult.getNoNextReason() is called on a result that has a next value.
RecordCursorResult.IllegalResultValueAccessException	An exception thrown when RecordCursorResult.get() is called on a result without a next value.
RecordCursorStartContinuation	A continuation representing the start of a cursor's execution.
RecordCursorVisitor	A hierarchical visitor for record cursor trees designed mostly to allow tests to gather information without adding invasive query methods to the RecordCursor interface.
RecordDoesNotExistException	Exception thrown when FDBRecordStoreBase.updateRecord(M) is called, but the record does not exist yet.
RecordFunction<T>	A function to be applied to a record as part of query execution.
RecordIndexUniquenessViolation	An exception thrown when there is an attempt to store a duplicate value in a unique index.
RecordLayerPropertyKey<T>	A key for a property that adopter configures for Record Layer.
RecordLayerPropertyStorage	Adopter can use this mapping of RecordLayerPropertyKeys to RecordLayerPropertyValues to configure Record Layer parameters.
RecordLayerPropertyStorage.Builder	Builder for RecordLayerPropertyStorage.
RecordLayerPropertyValue<T>	A value and its associated RecordLayerPropertyKey for a property that adopter configures for Record Layer.
RecordMetaData	Meta-data for Record Layer record stores.
RecordMetaDataBuilder	A builder for RecordMetaData.
RecordMetaDataBuilder.MetaDataProtoDeserializationException	Exception thrown when meta-data cannot be loaded from serialized form.
RecordMetaDataProvider	A source of RecordMetaData.
RecordQuery	The logical form of a query.
RecordQuery.Builder	A builder for RecordQuery.
RecordQueryAbstractDataModificationPlan	A query plan that performs transformations on the incoming record according to a set of transformation instructions in conjunction with a target Type and a target Descriptors.Descriptor which both together define a set of instructions for type promotion and for protobuf coercion.
RecordQueryAggregateIndexPlan	A query plan that reconstructs records from the entries in an aggregate index.
RecordQueryAggregateIndexPlan.Deserializer	Deserializer.
RecordQueryChooserPlanBase	A RecordQueryChooserPlanBase is a plan that, at runtime, chooses to execute plans from multiple alternatives.
RecordQueryComparatorPlan	A RecordQueryChooserPlanBase that executes all child plans and compares their results using the provided comparison key.
RecordQueryCoveringIndexPlan	A query plan that reconstructs records from the entries in a covering index.
RecordQueryCoveringIndexPlan.Deserializer	Deserializer.
RecordQueryDamPlan	A query plan implementing a dam in-memory.
RecordQueryDamPlan.Deserializer	Deserializer.
RecordQueryDefaultOnEmptyPlan	A query plan that only flows all the records it processes from its inner.
RecordQueryDefaultOnEmptyPlan.Deserializer	Deserializer.
RecordQueryDeletePlan	A query plan that deletes records.
RecordQueryDeletePlan.Deserializer	Deserializer.
RecordQueryExplodePlan	A query plan that applies the values it contains over the incoming ones.
RecordQueryExplodePlan.Deserializer	Deserializer.
RecordQueryFetchFromPartialRecordPlan	A query plan that transforms a stream of partial records (derived from index entries, as in the RecordQueryCoveringIndexPlan) into full records by fetching the records by primary key.
RecordQueryFetchFromPartialRecordPlan.Deserializer	Deserializer.
RecordQueryFetchFromPartialRecordPlan.FetchIndexRecords	Enum to govern how to interpret the primary key of an index entry when accessing its base record(s).
RecordQueryFetchFromPartialRecordPlan.FetchIndexRecords.FetchIndexRecordsFunction	The function to apply.
RecordQueryFilterPlan	A query plan that filters out records from a child plan that do not satisfy a filter component.
RecordQueryFilterPlanBase	A base class for all query plans that filter based on predicates.
RecordQueryFirstOrDefaultPlan	A query plan that only flows the first record it processes from its inner and then stops.
RecordQueryFirstOrDefaultPlan.Deserializer	Deserializer.
RecordQueryFlatMapPlan	A query plan that applies the values it contains over the incoming ones.
RecordQueryFlatMapPlan.Deserializer	Deserializer.
RecordQueryInComparandJoinPlan	A query plan that executes a child plan once for each of the elements extracted from a Comparison object's comparand.
RecordQueryInComparandJoinPlan.Deserializer	Deserializer.
RecordQueryIndexPlan	A query plan that outputs records pointed to by entries in a secondary index within some range.
RecordQueryIndexPlan.Deserializer	Deserializer.
RecordQueryInJoinPlan	A query plan that executes a child plan once for each of the elements of some IN list.
RecordQueryInParameterJoinPlan	A query plan that executes a child plan once for each of the elements of an IN list taken from a parameter.
RecordQueryInParameterJoinPlan.Deserializer	Deserializer.
RecordQueryInsertPlan	A query plan that inserts records into the database.
RecordQueryInsertPlan.Deserializer	Deserializer.
RecordQueryIntersectionOnKeyExpressionPlan	Intersection plan that compares using a KeyExpression.
RecordQueryIntersectionOnKeyExpressionPlan.Deserializer	Deserializer.
RecordQueryIntersectionOnValuesPlan	Intersection plan that compares using a Value.
RecordQueryIntersectionOnValuesPlan.Deserializer	Deserializer.
RecordQueryIntersectionPlan	A query plan that executes by taking the union of records from two or more compatibly-sorted child plans.
RecordQueryInUnionOnKeyExpressionPlan	Union plan that compares using a KeyExpression.
RecordQueryInUnionOnKeyExpressionPlan.Deserializer	Deserializer.
RecordQueryInUnionOnValuesPlan	Union plan that compares using a Value.
RecordQueryInUnionOnValuesPlan.Deserializer	Deserializer.
RecordQueryInUnionPlan	A query plan that executes union over instantiations of a child plan for each of the elements of some IN list(s).
RecordQueryInValuesJoinPlan	A query plan that executes a child plan once for each of the elements of a constant IN list.
RecordQueryInValuesJoinPlan.Deserializer	Deserializer.
RecordQueryLoadByKeysPlan	A query plan that returns records whose primary keys are taken from some list.
RecordQueryLoadByKeysPlan.KeysSource	A source for the primary keys for records.
RecordQueryMapPlan	A query plan that applies the values it contains over the incoming ones.
RecordQueryMapPlan.Deserializer	Deserializer.
RecordQueryPlan	An executable query plan for producing records.
RecordQueryPlanComplexityException	Exception thrown when a query plan is more complex than the configured limit.
RecordQueryPlanMatchers	Matchers for descendants of RecordQueryPlan.
RecordQueryPlanner	The query planner.
RecordQueryPlanner.CandidateScan
RecordQueryPlanner.ScoredInfo<T,S extends RecordQueryPlanner.ScoredInfo<T,S>>
RecordQueryPlanner.ScoredMatch
RecordQueryPlanner.ScoredPlan
RecordQueryPlannerConfiguration	A set of configuration options for the RecordQueryPlanner.
RecordQueryPlannerConfiguration.Builder	A builder for RecordQueryPlannerConfiguration.
RecordQueryPlannerSortConfiguration	Configuration for planning of non-index sort queries.
RecordQueryPlannerSubstitutionVisitor	Visitor interface for performing substitution-type rules on RecordQueryPlans.
RecordQueryPlanVisitor<T>
RecordQueryPlanVisitorWithDefaults<T>
RecordQueryPlanWithChild	A query plan with a single child plan.
RecordQueryPlanWithChildren	A query plan with child plans.
RecordQueryPlanWithComparisonKeyValues	Interface to be implemented by plans that provide comparison key values.
RecordQueryPlanWithComparisons	A query plan that uses ScanComparisons or Comparisons.Comparison to drive some scan of the record store.
RecordQueryPlanWithConstraint	Mixin for a RecordQueryPlan that has a QueryPlanConstraint.
RecordQueryPlanWithExplain	Interface for plans in downstream modules to implement explain functionality.
RecordQueryPlanWithIndex	A query plan that uses a single index.
RecordQueryPlanWithMatchCandidate	A query plan that was created using a MatchCandidate to match a physical access path.
RecordQueryPlanWithNoChildren	A query plan that does not have any child plans.
RecordQueryPredicatesFilterPlan	A query plan that filters out records from a child plan that do not satisfy a QueryPredicate.
RecordQueryPredicatesFilterPlan.Deserializer	Deserializer.
RecordQueryRangePlan	A query plan that produced a stream of integers for 0(inclusive) to some limit (exclusive).
RecordQueryRangePlan.Deserializer	Deserializer.
RecordQueryRecursiveUnionPlan	A physical representation of a recursive union.
RecordQueryRecursiveUnionPlan.Deserializer	Deserializer of RecordQueryRecursiveUnionPlan.
RecordQueryScanPlan	A query plan that scans records directly from the main tree within a range of primary keys.
RecordQueryScanPlan.Deserializer	Deserializer.
RecordQueryScoreForRankPlan	A query plan that converts ranks to scores and executes a child plan with the conversion results bound in named parameters.
RecordQueryScoreForRankPlan.Deserializer	Deserializer.
RecordQueryScoreForRankPlan.ScoreForRank	A single conversion of a rank to a score to be bound to some name.
RecordQuerySelectorPlan	A RecordQueryChooserPlanBase that selects one of its children to be executed.
RecordQuerySetPlan	Interface for query plans that represent set-based operators such as union or intersection.
RecordQuerySetPlan.ComparisonKeyFunction	A comparison key function that extracts a comparison key for binary comparison by some set operations which also provides a stable plan hash and hash code.
RecordQuerySetPlan.ComparisonKeyFunction.OnKeyExpression	Class to encapsulate the functionality of extracting a comparison key from a QueryResult while also providing comparability and the ability to compute a stable plan hash.
RecordQuerySetPlan.ComparisonKeyFunction.OnKeyExpression.Deserializer	Deserializer.
RecordQuerySetPlan.ComparisonKeyFunction.OnValues	Class to encapsulate the functionality of extracting a comparison key from a QueryResult while also providing comparability and the ability to compute a stable plan hash.
RecordQuerySetPlan.ComparisonKeyFunction.OnValues.Deserializer	Deserializer.
RecordQuerySortAdapter<M extends Message>	A MemorySortAdapter / FileSortAdapter for use with RecordQuerySortPlan.
RecordQuerySortKey	Defines, logically, how RecordQuerySortPlan should sort the records.
RecordQuerySortPlan	A query plan implementing sorting in-memory, possibly spilling to disk.
RecordQuerySortPlan.Deserializer	Deserializer.
RecordQueryStreamingAggregationPlan	A query plan that applies an aggregate function(s) to its inputs and also places them into groups.
RecordQueryStreamingAggregationPlan.Deserializer	Deserializer.
RecordQueryTextIndexPlan	A query plan that can scan text indexes.
RecordQueryTypeFilterPlan	A query plan that filters out records from a child plan that are not of the designated record type(s).
RecordQueryTypeFilterPlan.Deserializer	Deserializer.
RecordQueryUnionOnKeyExpressionPlan	Union plan that compares using a KeyExpression.
RecordQueryUnionOnKeyExpressionPlan.Deserializer	Deserializer.
RecordQueryUnionOnValuesPlan	Union plan that compares using a Value.
RecordQueryUnionOnValuesPlan.Deserializer	Deserializer.
RecordQueryUnionPlan	A query plan that executes by taking the union of records from two or more compatibly-sorted child plans.
RecordQueryUnionPlanBase	Common base class for plans that perform stream union operations.
RecordQueryUnorderedDistinctPlan	A query plan that removes duplicates by means of a hash table of previously seen values.
RecordQueryUnorderedDistinctPlan.Deserializer	Deserializer.
RecordQueryUnorderedPrimaryKeyDistinctPlan	A query plan that removes duplicates by means of a hash table of primary keys already seen.
RecordQueryUnorderedPrimaryKeyDistinctPlan.Deserializer	Deserializer.
RecordQueryUnorderedUnionPlan	A query plan that returns results from two-or-more cursors as they as ready.
RecordQueryUnorderedUnionPlan.Deserializer	Deserializer.
RecordQueryUpdatePlan	A query plan that updates records in the database using a stream of incoming records, that are transformed according to a transformation map, then coerced into a target type, and then saved using FDBRecordStoreBase.saveRecord(Message).
RecordQueryUpdatePlan.Deserializer	Deserializer.
RecordScanLimiter	Track number of records scanned up to some limit, after which record scans should not be allowed.
RecordScanLimiterFactory	A factory that produces implementations of RecordScanLimiters.
RecordSerializationException	Exception thrown when there is a problem serializing or deserializing a record.
RecordSerializationValidationException	Exception class thrown by RecordSerializer.validateSerialization(RecordMetaData, RecordType, Message, byte[], StoreTimer).
RecordSerializer<M extends Message>	A converter between a Protobuf record and a byte string stored in one or more values in the FDB key-value store.
RecordSerializer.Counts	Instrumentation counts related to record serialization.
RecordSerializer.Events	Instrumentation events related to record serialization.
RecordStoreAlreadyExistsException	Exception thrown when FDBRecordStoreBase.BaseBuilder.create() is called, but the record store already exists.
RecordStoreDoesNotExistException	Exception thrown when FDBRecordStoreBase.BaseBuilder.open() is called, but the record store does not exist yet.
RecordStoreNoInfoAndNotEmptyException	Exception thrown when FDBRecordStoreBase.BaseBuilder.createOrOpen() is called, and the record store does not have a store info header, but does have something else.
RecordStoreStaleMetaDataVersionException	Exception thrown when the record store has a newer meta-data version than the one from the given RecordMetaDataProvider.
RecordStoreStaleUserVersionException	Exception thrown when the record store has a newer user version than the one from the given FDBRecordStoreBase.UserVersionChecker.
RecordStoreState	The RecordStoreState interface handles information that might differ between otherwise identical record stores.
RecordType	Record type meta-data.
RecordTypeBuilder	A builder for RecordType.
RecordTypeBuilder.NonbuildableException	Exception thrown when a RecordTypeBuilder is not yet in a state where it can be built.
RecordTypeChangedException	Exception thrown when FDBRecordStoreBase.updateRecord(M) is called, but the existing record has a different record type.
RecordTypeIndexesBuilder	A base builder for RecordType.
RecordTypeKeyComparison	A QueryComponent that implements checking for a given record type.
RecordTypeKeyComparison.RecordTypeComparison	Equality comparison to check for records of a particular record type.
RecordTypeKeyComparison.RecordTypeComparison.Deserializer	Deserializer.
RecordTypeKeyExpression	A key expression that indicates that a unique record type identifier should be contained within the key.
RecordTypeOrBuilder	Common interface implemented by the RecordType and RecordTypeBuilder classes that contains accessors that they are both expected to have.
RecordTypesProperty	A property visitor that determines the set of record type names (as Strings) that a RelationalExpression could produce.
RecordTypeValue	A value which is unique for each record type produced by its quantifier.
RecordTypeValue.Deserializer	Deserializer.
RecursiveUnionCursor<T>	A cursor that repeatedly executes its children until reaching a fix-point.
RecursiveUnionCursor.Continuation	Continuation that captures the state of execution of a RecursiveUnionCursor that is orchestrated by RecordQueryRecursiveUnionPlan through a RecursiveUnionCursor.RecursiveStateManager.
RecursiveUnionCursor.RecursiveStateManager<T>	Interface for recursive state management, the caller is expected to invoke respective callbacks when certain events occur so the internal state mutates accordingly, it also offers a set of methods that enable examining current state and whether the execution can proceed to a subsequent recursive state or not.
RecursiveUnionExpression	This is a logical representation of a recursive union, a recursive union is similar to a normal unordered union, however its legs have special execution semantics; just like a union, it returns the results verbatim of one particular leg called the "initial state" leg.
Reference	The memo data structure can compactly represent a large set of similar RelationalExpressions through careful memoization.
Reference.UngettableReferenceException	An exception thrown when Reference.get() is called on a reference that does not support it, such as a reference containing more than one expression.
ReferencedFieldsConstraint	A constraint holding a set of referenced field values.
ReferencedFieldsConstraint.ReferencedFields	A set of referenced field values.
ReferenceMatchers	Matchers for References.
ReferencePrinter	A utility class for printing out a Reference in a readable form.
References	Utility methods for References.
ReferencesAndDependenciesProperty	This property establishes a partial order over the expressions contained in a subgraph.
RelationalExpression	A relational expression is a RelationalExpression that represents a stream of records.
RelationalExpression.CombineFunction<R,S>	A functional interface to combine the matches computed over pairs of quantifiers during matching into a result (for the bound correlatedTo set handed into RelationalExpression.CombineFunction.combine(com.apple.foundationdb.record.query.plan.cascades.AliasMap, java.lang.Iterable<com.apple.foundationdb.record.query.plan.cascades.matching.graph.BoundMatch<com.apple.foundationdb.record.query.combinatorics.EnumeratingIterable<R>>>)).
RelationalExpression.CombinePredicate	A functional interface to combine the matches computed over pairs of quantifiers during matching into a boolean result (for the bound correlatedTo set handed into RelationalExpression.CombinePredicate.combine(com.apple.foundationdb.record.query.plan.cascades.AliasMap, java.lang.Iterable<com.apple.foundationdb.record.query.plan.cascades.AliasMap>)).
RelationalExpressionDepthProperty	A property representing the minimum depth of any of a set of relational planner expression types in a relational planner expression: that is, the smallest integer such that one of those types is exactly that many relational planner expressions away from the root expression.
RelationalExpressionMatchers	Matchers for descendants of RelationalExpression.
RelationalExpressionVisitor<T>
RelationalExpressionVisitorWithDefaults<T>
RelationalExpressionWithChildren	A parent interface for RelationalExpressions that have relational children (as opposed to non-relation children, such as QueryComponents).
RelationalExpressionWithChildren.ChildrenAsSet	Tag interface to signal that the children this expression owns, that is the owned Quantifiers, are to be treated as an unordered set.
RelationalExpressionWithPredicates	A (relational) expression that has a predicate on it.
RelativeProbabilityPlanSelector	A utility class to implement an algorithm to make a random selection based off of relative probabilities.
RelOpValue	A Value that returns the comparison result between its children.
RelOpValue.BinaryRelOpValue	Binary rel ops.
RelOpValue.BinaryRelOpValue.Deserializer	Deserializer.
RelOpValue.EqualsFn	The equals function.
RelOpValue.GteFn	The gte function.
RelOpValue.GtFn	The gt function.
RelOpValue.IsNullFn	The isNull function.
RelOpValue.LteFn	The lte function.
RelOpValue.LtFn	The lt function.
RelOpValue.NotEqualsFn	The notequals function.
RelOpValue.NotNullFn	The notNull function.
RelOpValue.UnaryRelOpValue	Unary rel ops.
RelOpValue.UnaryRelOpValue.Deserializer	Deserializer.
RemoveProjectionRule	A rule that removes a LogicalProjectionExpression and if appropriate a RecordQueryFetchFromPartialRecordPlan if all fields needed by the projection are already available prior to the fetch.
RemoveSortRule	A rule that implements a sort expression by removing this expression if appropriate.
RequestedOrdering	This class captures a requested ordering.
RequestedOrdering.Distinctness	Whether the ordered records are distinct.
RequestedOrderingConstraint	A constraint requesting a set of sort orderings.
RequestedOrderingValueSimplificationRuleSet	A set of rules for simplifying Value trees used to expression ordering constraints.
ResolvedKeySpacePath	A KeySpacePath that has been resolved into the value that will be physically stored to represent the path element in the FDB keyspace.
ResolverCreateHooks	Set of hooks to be run only when creating a mapping in a LocatableResolver.
ResolverCreateHooks.MetadataHook	Functional interface for the safety check that will be run before writing a mapping in the LocatableResolver.
ResolverCreateHooks.PreWriteCheck	Functional interface for the safety check that will be run before writing a mapping in the LocatableResolver.
ResolverKeyValue	Encapsulates both the key and its resolved value from a LocatableResolver.
ResolverMappingDigest	Computes a message digest for all of the string to integer mappings in the provided LocatableResolver.
ResolverMappingReplicator	Copies the contents of one LocatableResolver to another.
ResolverResult	A class containing the result of resolving a key with LocatableResolver.
ResolverValidator	Validator that ensures that the resolver mappings are consistent with the reverse directory mappings.
ResolverValidator.ValidatedEntry	Represents a bad/incorrect entry in the resolvers mapping.
ResolverValidator.ValidationResult	The type of bad entry discovered when validating a LocatableResolver's mappings.
RestartException	Tag-exception that is specifically thrown by implementations of Debugger to signal the planner to restart planning.
Result<V,E extends java.lang.Throwable>	A struct representing the result of an operation, containing either the return value or an error.
RowLimitedCursor<T>	A cursor that limits the number of elements that it allows through.
ScalarTranslationVisitor	Visitor that translates a KeyExpression into a Value, keeping a state of the currently processed input type while it is processing the KeyExpression.
ScalarTranslationVisitor.ScalarVisitorState	State class.
ScanComparisons	A set of Comparisons.Comparison for scanning an index.
ScanComparisons.Builder	A builder for ScanComparisons.
ScanComparisons.ComparisonType	The type of a comparison.
ScanLimitReachedException	Exception thrown when a transaction tries to scan more than the allowed number of key-value pairs.
ScanNonReadableIndexException	An exception that can be thrown by FDBRecordStores if they are scanning non-readable indexes.
ScanProperties	A group of properties that pertain to a single scan.
ScanWithFetchMatchCandidate	Interface to represent a candidate that replaces with an index scan.
ScanWithFetchMatchCandidate.IndexEntryToLogicalRecord	Helper structure that allows us to precompute the mapping from index entry to the logical (partial record).
ScopedDirectoryLayer	An implementation of LocatableResolver that uses the FDB directory layer to keep track of the allocation of strings to integers.
ScopedInterningLayer	An implementation of LocatableResolver that is backed by the StringInterningLayer.
ScopedValue<T>	Object to key the forward and reverse directory caches by, two entries should be treated as identical if they attempt to resolve the same string with directory layers that are located at the same path.
SelectDataAccessRule	A rule that utilizes index matching information compiled by CascadesPlanner to create one or more expressions for data access specifically for a SelectExpression.
SelectExpression	A select expression.
SemanticException	Semantic exceptions that could occur e.g.
SemanticException.ErrorCode	Semantic error codes.
ServiceLoaderProvider	A singleton that supports alternatives to ServiceLoader, for example if you want to use a dependency injection framework.
SetMatcher<T>	A multi matcher that binds a sub collection of the collection it is being matched by pairing up the items in the collection (in iteration order) with a list of downstream matchers.
Simplification	Main class of a mini rewrite engine to simplify (or to compute over) Value trees.
Simplification.RuleCallCreator<RESULT,CALL extends AbstractRuleCall<RESULT,CALL,BASE>,BASE>	Functional interface to create a specific rule call object.
SizeStatisticsCollectorCursor	A cursor that collects various distribution statistics on the keys and values within a record store or within an index.
SizeStatisticsCollectorCursor.SizeStatisticsResults	Encapsulates the distribution statistics returned by a SizeStatisticsCollectorCursor.
SkipCursor<T>	A cursor that skips a specified number of initial elements.
SortedFileReader<V>	Read values from files written by FileSorter.
SortedInComparandSource	Variation of InComparandSource where the values should be returned in a sorted order.
SortedInComparandSource.Deserializer	Deserializer.
SortedInParameterSource	Helper class which represents a specialized InSource whose input is an outer binding (a parameter).
SortedInParameterSource.Deserializer	Deserializer.
SortedInValuesSource	Helper class which represents a specialized InSource whose input is a list of literal values.
SortedInValuesSource.Deserializer	Deserializer.
SortedRecordSerializer<M extends Message>	Serialize records during sorting, either in a continuation or in a file.
SortEvents	StoreTimer events related to sorting.
SortEvents.Counts	Instrumentation counts related to sorting.
SortEvents.Events	Events related to sorting.
SplitHelper	Helper classes for splitting records across multiple key-value pairs.
SplitHelper.FoundSplitWithoutStartException	Exception thrown when only part of a split record is found.
SplitHelper.KeyValueUnsplitter	This cursor may exceed out-of-band limits in order to ensure that it only ever stops in between (split) records.
SplitHelper.SingleKeyUnsplitter	Unsplit a single record from a given range scan.
SplitHelper.SizeInfo	Accumulator for key-value sizes while loading / saving split records.
SplitKeyExpression	Turn a key with repeated single values into multiple Key.Evaluated containing several of the values.
SplitSelectExtractIndependentQuantifiersRule	A rule that splits a SelectExpression into two SelectExpressions if one or more quantifiers this expression owns satisfy the following criteria: the quantifier is not correlated to any other quantifier in this SelectExpression the quantifier ranges over a sub expression of limited cardinality.
StandardIndexMaintainer	Base class for IndexMaintainer implementation.
Stats
StatsMaps
StoredRecordProperty	An attribute used to communicate to the planner that a plan flows instances of FDBQueriedRecord (and its subclasses) which can only represent records that reside stored on disk and were retrieved by this query.
StoredRecordProperty.StoredRecordVisitor	Planner property which indicates if the record flowed as the result of a RecordQueryPlan flows things stored records flow, e.g.
StoreRecordFunction<T>	Record function that should be evaluated for some record against an FDBRecordStoreBase instance.
StoreSubTimer	A StoreTimer wrapping an underlying StoreTimer that accumulates the events that are issued to it, as well as sending those events along to the underlying store timer.
StoreTimer	A context-wide accumulator of timing information.
StoreTimer.Aggregate	An aggregate event is an event whose value is computed over the value of another set of events.
StoreTimer.Count	StoreTimer.Events that only count occurrences or total size.
StoreTimer.Counter	Contains the number of occurrences and cumulative time spent/cumulative value of all occurrences of the associated StoreTimer.Event.
StoreTimer.DetailEvent	StoreTimer.Events that are a significant part of a larger process.
StoreTimer.Event	An identifier for occurrences that need to be timed.
StoreTimer.SizeEvent	StoreTimer.Events that count the number of occurrences of an operation and also the size of the operation.
StoreTimer.Wait	StoreTimer.Events that can be waited on.
StoreTimerSnapshot	An immutable snapshot of a StoreTimer.
StoreTimerSnapshot.CounterSnapshot	An immutable snapshot of a StoreTimer.Counter.
StreamableAggregateValue	Tag interface used to mark AggregateValue implementations that can be calculated by a RecordQueryStreamingAggregationPlan operator.
StreamGrouping<M extends Message>	StreamGrouping breaks streams of records into groups, based on grouping criteria.
StringInterningLayer	A persistent bidirectional unique mapping between strings and integers.
SubspaceProvider	Subspace provider can provide a subspace (might be blocking) and logging information to the subspace (non-blocking).
SubspaceProviderByKeySpacePath	A SubspaceProvider wrapping a key space path.
SubspaceProviderBySubspace	A SubspaceProvider wrapping a subspace.
SynchronizedSessionRunner	An FDBDatabaseRunner implementation that performs all work in the context of a SynchronizedSession.
SyntheticRecordFromStoredRecordPlan	A plan for deriving synthetic records from a given record.
SyntheticRecordPlan	A plan for generating synthetic records without an explicit starting point.
SyntheticRecordPlanner	A planner for SyntheticRecordPlan and SyntheticRecordFromStoredRecordPlan plans.
SyntheticRecordType<C extends SyntheticRecordType.Constituent>	A synthetic record type is made up of other record types and not actually stored separately in the record store.
SyntheticRecordType.Constituent	A constituent type of the synthetic record type.
SyntheticRecordTypeBuilder<C extends SyntheticRecordTypeBuilder.Constituent>	A builder for SyntheticRecordType.
SyntheticRecordTypeBuilder.Constituent	A constituent type within a joined record type.
TempTable	A mutable, temporary, serializable, and in-memory buffer of QueryResults.
TempTable.Factory	Factory of TempTable instances.
TempTableInsertCursor	A cursor that returns the items of a child cursor, and as a side effect, it adds the items to a designated TempTable.
TempTableInsertExpression	A logical expression for inserting into a temporary memory buffer TempTable.
TempTableInsertPlan	A query plan that inserts records into a temporary in-memory buffer TempTable.
TempTableInsertPlan.Deserializer	Deserializer.
TempTableScanExpression	A logical expression for scanning from a table-valued Bindings.Internal.CORRELATION that can correspond to a temporary memory buffer, i.e.
TempTableScanPlan	Scans records from a table-valued correlation, corresponding for example to a temporary in-memory buffer TempTable.
TempTableScanPlan.Deserializer	Deserializer.
TestLogMessageKeys	Common KeyValueLogMessage keys logged by the Record Layer core.
Text	Predicates that can be applied to a field that has been indexed with a full-text index.
TextCollator	An interface for locale-sensitive text comparison and sorting.
TextCollator.Strength	Standard strength values.
TextCollatorRegistry	Registry for TextCollators.
TextCollatorRegistryJRE	A text collator registry using the Java Platform's own Collator implementation.
TextCollatorRegistryJRE.TextCollatorJRE
TextIndexBunchedSerializer	Serializer used by the TextIndexMaintainer to write entries into a BunchedMap.
TextIndexMaintainer	The index maintainer class for full-text indexes.
TextIndexMaintainerFactory	Supplier of TextIndexMaintainers, that is, of index maintainers for the full text index type.
TextScan	Encapsulate the information necessary to scan a text-based index.
TextScanPlanner	A utility class for choosing a TextScan object to satisfy a text query.
TextTokenizer	An interface to tokenize text fields.
TextTokenizer.TokenizerMode	Mode that can be used to alter tokenizer behavior depending on the the context its used in.
TextTokenizerFactory	Each implementation of TextTokenizer should have its own implementation of this factory interface to provide instances of the tokenizer to a TextTokenizerRegistry.
TextTokenizerRegistry	Registry for TextTokenizers.
TextTokenizerRegistryImpl	Default implementation of the TextTokenizerRegistry.
ThenKeyExpression	Combine keys from two or more child keys.
ThrowsValue	A value that throws an exception if it gets executed.
ThrowsValue.Deserializer	Deserializer.
TimeScanLimiter	Track time remaining until a given time limit, after which record scans should not be allowed.
TimeWindowAggregateFunction	Evaluate aggregate functions in a certain time window.
TimeWindowForFunction	Additional function arguments for time window.
TimeWindowLeaderboard	A single leaderboard, representing ranks within a time window.
TimeWindowLeaderboardDirectory	The persisted set of active leaderboard ranked sets.
TimeWindowLeaderboardDirectoryOperation	Get the current directory.
TimeWindowLeaderboardDirectoryResult	Currently saved directory.
TimeWindowLeaderboardIndexMaintainer	Maintainer for the TIME_WINDOW_LEADERBOARD index type.
TimeWindowLeaderboardIndexMaintainer.TimeWindowRankAndEntry	Struct containing both the time window leaderboard entry and the rank.
TimeWindowLeaderboardIndexMaintainerFactory	Factory for the TIME_WINDOW_LEADERBOARD index type.
TimeWindowLeaderboardSaveSubDirectory	Save a subdirectory to specify direction.
TimeWindowLeaderboardScoreTrim	Retain only scores that would be indexed by active time windows.
TimeWindowLeaderboardScoreTrimResult	Scores that would be indexed by active time windows.
TimeWindowLeaderboardSubDirectory	Persisted per-group information for leaderboard ranked sets.
TimeWindowLeaderboardSubDirectoryOperation	Get a sub-directory, which presently only contains information about direction.
TimeWindowLeaderboardSubDirectoryResult	A sub-directory, which presently only contains information about direction.
TimeWindowLeaderboardWindowUpdate	Maintain active set of time windows.
TimeWindowLeaderboardWindowUpdate.Rebuild	When to completely rebuild an index.
TimeWindowLeaderboardWindowUpdate.TimeWindowSpec	A specification of a set of sliding time windows.
TimeWindowLeaderboardWindowUpdateResult	Result of TimeWindowLeaderboardWindowUpdate.
TimeWindowRecordFunction<T>	The TIME_WINDOW_RANK record function.
TimeWindowScanComparisons	Extend IndexScanComparisons to have TimeWindowForFunction.
TimeWindowScanComparisons.Deserializer	Deserializer.
TimeWindowScanRange	Extend IndexScanRange to have time window.
ToOrderedBytesValue	A value that produces a binary encoding that is comparable according to certain modes gives by TupleOrdering.Direction.
ToOrderedBytesValue.Deserializer	Deserializer.
ToOrderedBytesValue.ToOrderedBytesAscNullsFirstFn	The TO_ORDERED_BYTES_ASC_NULLS_FIRST function.
ToOrderedBytesValue.ToOrderedBytesAscNullsLastFn	The TO_ORDERED_BYTES_ASC_NULLS_LAST function.
ToOrderedBytesValue.ToOrderedBytesDescNullsFirstFn	The TO_ORDERED_BYTES_DESC_NULLS_FIRST function.
ToOrderedBytesValue.ToOrderedBytesDescNullsLastFn	The TO_ORDERED_BYTES_DESC_NULLS_LAST function.
TopologicalSort	Utility class to provide helpers related to topological sorts.
TransactionalRunner	A simple runner that can be used for opening and committing transactions, and making sure they are all closed.
TransactionListener	A class that is notified of events that take place within the scope of a transaction, such as when the transaction is created, committed, or closed.
TransformedRecordSerializer<M extends Message>	A RecordSerializer implementation that transforms the bytes produced by another serializer before returning (and likewise performs the reverse transformation before deserializing).
TransformedRecordSerializer.Builder<M extends Message>	Builder class for the TransformedRecordSerializer class.
TransformedRecordSerializer.TransformState
TransformedRecordSerializerJCE<M extends Message>	An extension of TransformedRecordSerializer to use JCE to encrypt and decrypt records.
TransformedRecordSerializerJCE.Builder<M extends Message>	Builder class for the TransformedRecordSerializerJCE class.
TransitiveClosure	Utility class to provide helpers related to the computation of the transitive closure of a partial order.
TranslateValueFunction	Interface for functions employed by RecordQueryFetchFromPartialRecordPlan that are used to translate a value by conceptually pushing it through that operation.
TranslationMap	Map used to specify translations.
TranslationMap.Builder	Builder class for a translation map.
TranslationMap.TranslationFunction	Functional interface to specify the translation to take place when a QuantifiedValue is encountered.
Traversal	Utility class to provide a graph view of a expression reference DAG given by a root expression reference (to a RelationalExpression that allows to perform traversal operations that are normally not possible on instances of Reference such as Traversal.getLeafReferences() and Traversal.getParentRefs(com.apple.foundationdb.record.query.plan.cascades.Reference).
Traversal.ReferencePath	Case class to hold information about the path from an expression to another expression reference.
TreeLike<T extends TreeLike<T>>	Interface for tree-like structures and helpers for folds and traversals on these tree-like structures of node type TreeLike.
TreeLike.NonnullBiFunction<T,U,R>	Functional interface for a bi-function whose result is not nullable.
TreeLike.NonnullFunction<T,R>	Functional interface for a function whose result is not nullable.
TrieNode<D,T,N extends TrieNode<D,T,N>>	Basic trie implementation that stores values at the trie's leaves.
TrieNode.AbstractTrieNode<D,T,N extends TrieNode.AbstractTrieNode<D,T,N>>	Basic trie implementation.
TrieNode.AbstractTrieNodeBuilder<D,T,N extends TrieNode.AbstractTrieNodeBuilder<D,T,N>>	Basic trie builder implementation.
TriFunction<T,U,V,R>	Represents a function that accepts three arguments and produces a result.
TupleFieldsHelper	Static methods for dealing with special field types that are messages in protobuf but single items in Tuples.
TupleRange	A range within a subspace specified by two Tuple endpoints.
TupleRange.ByteStringBoundException	Exception thrown when range endpoint is not consistent with CONTINUATION endpoint type.
Type	Provides type information about the output of an expression such as Value in a QGM.
Type.Any	Special Type that is undefined.
Type.Any.Deserializer	Deserializer.
Type.AnyRecord	Special Type.Record that is undefined.
Type.AnyRecord.Deserializer	Deserializer.
Type.Array	A type representing an array of elements sharing the same type.
Type.Array.Deserializer	Deserializer.
Type.Enum	An enumeration type.
Type.Enum.Deserializer	Deserializer.
Type.Enum.EnumValue	A member value of an enumeration.
Type.Erasable	Interface for classes that can be erased, i.e.
Type.None	The none type is an unresolved type meaning that an entity returning a none type should resolve the type to a regular type as the runtime does not support a none-typed data producer.
Type.None.Deserializer	Deserializer.
Type.Null	The null type is an unresolved type meaning that an entity returning a null type should resolve the type to a regular type as the runtime does not support a null-typed data producer.
Type.Null.Deserializer	Deserializer.
Type.Primitive	A primitive type.
Type.Primitive.Deserializer	Deserializer.
Type.Record	A structured Type that contains a list of Type.Record.Field types.
Type.Record.Deserializer	Deserializer.
Type.Record.Field	Represents a field type in a Type.Record type.
Type.Relation	Represents a relational type.
Type.Relation.Deserializer	Deserializer.
Type.TypeCode	All supported Types.
Typed	Provides Type information about result set.
TypedMatcher<T>	A TypedMatcher matches a data structure that is at least of a certain type.
TypedMatcherWithExtractAndDownstream<T>	A TypedMatcher that also extracts an object from the current object and attempts to match that object with a downstream matcher.
TypedMatcherWithPredicate<T>	A TypeMatcherWithPredicate extends TypedMatcher in a way that it still only matches objects that are at least of a certain type but that can be rejected by applying a given predicate to the object that is attempted ot be matched.
TypedRecordSerializer<M extends Message,U extends Message,B extends Message.Builder>	Serialize records using default Protobuf serialization using supplied message builder for the union message type and two accessors for the message field corresponding to the known record type.
TypeFilterCountProperty	A property that determines the sum, over all elements of a PlannerExpression tree, of the number of record types that are passed by type filters in the tree.
TypeFilterExpression	A relational planner expression that represents a type filter.
TypeRepository	A utility class that enables mapping of a structured Type into a dynamically-generated equivalent Protobuf message descriptor.
TypeRepository.Builder	A builder that builds a TypeRepository object.
UdfFunction	This represents a user-defined function that can be subclassed to extend the planner with extra functionality.
UdfValue	This represents a user-defined Value that can be subclassed to provide a custom implementation.
Unapply<T,U>	Interface for the unapply function used in a variety of matchers.
UnapplyWithConfiguration<T,U>	Interface for the unapply function (also using a RecordQueryPlannerConfiguration used in a variety of matchers.
UninitializedRecordStoreException	An exception that can be thrown by FDBRecordStores if they are used before they have been properly initialized.
UnionCursor<T>	A cursor that implements a union of all the records from a set of cursors, all of whom are ordered compatibly.
UnionVisitor	This visitor pulls index fetches after the intersection if possible.
UnmatchedFieldsCountProperty	A property for counting the total number of KeyExpression columns (i.e., field-like KeyExpressions such as FieldKeyExpression and RecordTypeKeyExpression) that are not matched with at least one Comparisons.Comparison in a planner expression tree.
UnnestedRecordType	A synthetic record type representing an unnesting of some kind of repeated, nested structure.
UnnestedRecordType.NestedConstituent	A SyntheticRecordType.Constituent representing an element in an unnested record.
UnnestedRecordTypeBuilder	Builder for creating UnnestedRecordTypes.
UnnestedRecordTypeBuilder.NestedConstituent	Builder variant of UnnestedRecordTypeBuilder.NestedConstituent.
UnorderedPrimaryKeyDistinctVisitor	This class moves the index fetch up from the index scan to after a distinct operation has been applied to the records.
UnorderedUnionCursor<T>	A cursor that returns the results of two or more cursors that may return elements in any order.
UnsupportedFormatVersionException	Exception thrown when a record store has a format version in the database that is not supported by this codebase.
UnsupportedMethodException	Exception thrown when a call is made for an API that is unsupported by the current APIVersion.
UnsupportedRemoteFetchIndexException	Exception thrown when remote fetch is attempted on an index that does not support remote fetch.
UpdateExpression	A logical version of RecordQueryUpdatePlan.
UsedTypesProperty	A property that computes the set of complex (dynamic) types that is used by the graph passed in.
UsesValueEquivalence<T extends UsesValueEquivalence<T>>	Tag interface to provide a common base for all classes implementing a semantic equals using a ValueEquivalence.
Value	A scalar value type.
Value.IndexOnlyValue	A scalar value type that can only fetched from an index, that is the value cannot be fetched from the base record nor can it be computed "on-the-fly".
Value.InvertableValue<V extends Value>	A scalar Value that can be inverted, i.e.
Value.NondeterministicValue	Tag interface for marking a Value that is non-deterministic, i.e.
Value.NonEvaluableValue	A scalar Value that cannot be evaluated.
Value.RangeMatchableValue	A marker interface for Values that can be used in the context of range construction, it must be evaluable without being bound to an FDBRecordStoreBase.
ValueCompensation	Functional interface to perform compensation for partially matched Value-trees.
ValueComputationRule<A,R,T extends Value>	Intermediate class that fixes the type of the PlannerRuleCall.
ValueComputationRule.OnMatchComputationFunction<A,R>	Functional interface whose apply method is invoked after using the simplification's results.
ValueComputationRuleCall<ARGUMENT,RESULT>	A rule call implementation for the computation of a result while traversing Value trees.
ValueComputationRuleSet<A,R>	A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
ValueComputationRuleSet.TransformedRules<A,R>	Holder class to easily transform simplification rules and their dependencies into computation rules and their dependencies.
ValueEquivalence	An interface (together with a set of specific final classes) that captures axiomatic (defined) equivalence between Values.
ValueEquivalence.AliasMapBackedValueEquivalence	Equivalence that is being backed by an AliasMap.
ValueEquivalence.ConstantValueEquivalence	Value equivalence implementation that relates bound constant references between ConstantObjectValues to LiteralValues.
ValueEquivalence.ThenEquivalence	Helper equivalence to compose to equivalences.
ValueEquivalence.ValueMap	Value equivalence based on a map of values.
ValueEquivalence.ValueMap.Builder	Builder.
ValueIndexExpansionVisitor	Class to expand value index access into a candidate graph.
ValueIndexLikeMatchCandidate	Trait to implement some default logic for MatchCandidates that are defined over value index-like data structures such as PrimaryScanMatchCandidate and ValueIndexScanMatchCandidate.
ValueIndexMaintainer	An index maintainer for an ordinary index by value, implementing ordered enumeration of records within a range of indexed values.
ValueIndexMaintainerFactory	A factory for ValueIndexMaintainer indexes.
ValueIndexScanMatchCandidate	Case class to represent a match candidate that is backed by an index.
ValueIndexScrubbingToolsDangling	Index Scrubbing Toolbox for a Value index maintainer.
ValueIndexScrubbingToolsMissing	Index Scrubbing Toolbox for a Value index maintainer.
ValueMatchers	Matchers for descendants of Value.
ValuePredicate	A predicate consisting of a Value and a Comparisons.Comparison.
ValuePredicate.Deserializer	Deserializer.
ValueRange<T>	A range defines the boundaries around a contiguous span of values of some type.
Values	Helper class for dealing with Values.
ValueSimplificationRule<TYPE extends Value>	Intermediate class that fixes the base type of the AbstractRuleCall to be Value.
ValueSimplificationRuleCall	A rule call implementation for the simplification of Value trees.
ValueWithChild	A scalar value type that has children.
VariadicFunctionValue	A Value that applies an arithmetic operation on its child expressions.
VariadicFunctionValue.CoalesceFn	The coalesce function.
VariadicFunctionValue.ComparisonFunction	Logical operator.
VariadicFunctionValue.Deserializer	Deserializer.
VariadicFunctionValue.GreatestFn	The greatest function.
VariadicFunctionValue.LeastFn	The least function.
VariadicFunctionValue.PhysicalOperator	Physical operators.
VersionIndexMaintainer	Implementation of IndexMaintainer for the "version" index type.
VersionIndexMaintainerFactory	A factory for VersionIndexMaintainer indexes.
VersionKeyExpression	A key expression that indicates that a serialized FDBRecordVersion should be contained within the key.
VersionValue	A value representing a version stamp derived from a quantifier.
VersionValue.Deserializer	Deserializer.
VersionValue.VersionFn	The and function.
WindowedIndexExpansionVisitor	Class to expand a by-rank index access into a candidate graph.
WindowedIndexScanMatchCandidate	Case class to represent a match candidate that is backed by a windowed index such as a rank index.
WindowedValue	A value merges the input messages given to it into an output message.
WithAlias	Trait for providing alias information.
WithBaseQuantifierMatchCandidate	Trait to implement some default logic for MatchCandidates that are defined using a base quantifier, that is, match candidates that are not true join indexes.
WithPrimaryKeyMatchCandidate	Interface to represent a candidate that uses a primary key to identify a record.
WithValue<T extends WithValue<T>>	Trait for classes containing a Value.
ZeroCopyByteString	Use this as a way to use existing byte arrays when converting to ByteString for protobuf conversion.