All Classes Interface Summary Class Summary Enum Summary Exception Summary
Class |
Description |
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.
|
AdjustMatchRule |
A rule that attempts to improve an existing PartialMatch by absorbing an expression on the
candidate side.
|
AggregateFunctionNotSupportedException |
Exception thrown when an aggregate function is not supported.
|
AliasMap |
This class encapsulates mappings between CorrelationIdentifier s and helpers to create and maintain
these mappings.
|
AliasMap.Builder |
|
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 |
|
AndPredicate |
A QueryPredicate that is satisfied when all of its child components are;
For tri-valued logic:
If all children are true , then true .
If any child is false , then false .
Else null .
|
AnyChildMatcher |
An expression children matcher that tries to match any child to the given ExpressionMatcher , producing a
stream of bindings that is the concatenation of the (possibly empty) streams of bindings from attempting to match each
child to the given matcher.
|
AnyChildrenMatcher |
A children matcher that matches any set of children.
|
AnyChildWithRestMatcher |
|
AsyncIteratorCursor<T> |
|
AsyncLoadingCache<K,V> |
A cache for retaining the result of some asynchronous operation up until some expiration time.
|
AtomicMutation |
|
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 |
|
AtomKeyExpression |
An "atom expression" is one that has semantic meaning; that is, it presence is significant to the meaning of
the expression.
|
Attribute |
|
Attribute.CommonAttribute |
|
Attribute.DotAttribute |
|
Attribute.GmlAttribute |
|
Attribute.InvisibleAttribute |
|
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.FieldData |
A pair of a tuple source (key or value) and an index within that tuple source.
|
BaseCursor<T> |
A tag interface for "base" cursors which read records directly from the database.
|
BaseField |
|
BaseKeyExpression |
Base class to provide some common logic shared between most expression implementations.
|
BaseKeyExpression.IllegalSubKeyException |
|
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 QueryComponent s that represent a query of a nested record type.
|
BaseValue |
A value representing the quantifier as an object.
|
Bindable |
A planner type that supports rule binding.
|
BindingFunctions |
Helper methods for manipulating parameter values passed in Bindings .
|
Bindings |
A map of bound parameter values passed to query evaluation.
|
Bindings.Builder |
|
Bindings.Internal |
Bindings slots used internally by plan operators.
|
BitmapValueIndexMaintainer |
An index maintainer for storing bitmaps of which records meet a specific condition.
|
BitmapValueIndexMaintainerFactory |
|
BlockingInAsyncDetection |
|
BlockingInAsyncException |
Exception thrown when asyncToSync detects that it is being called from within an asynchronous context.
|
BooleanNormalizer |
A normalizer of a tree of QueryComponent predicates into disjunctive normal form.
|
BoundKeyPart |
A key expression that can be bound by a comparison during graph matching.
|
BoundMatch<R> |
Case class to represent a match for matchers that compute a result.
|
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 |
|
CascadesCostModel |
A comparator implementing the current heuristic cost model for the CascadesPlanner .
|
CascadesPlanner |
|
CascadesPlanner.Task |
Represents actual tasks in the task stack of the planner.
|
CascadesRuleCall |
|
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 cross products.
|
CollateFunctionKeyExpression |
COLLATE function.
|
CollateFunctionKeyExpressionFactoryJRE |
|
CollateFunctionKeyExpressionFactoryJRE.CollateFunctionKeyExpressionJRE |
|
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.
|
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, with distinct planning behaviour:
Empty ranges, to which any comparison can be added.
Equality ranges, to which only the same (equality) comparison can be added.
Inequality ranges, to which any other comparison can be added.
This behavior is defined in ComparisonRange.tryToAdd(Comparisons.Comparison) .
|
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.EvaluationContextRequiredException |
Exception thrown when comparison evaluation needs the query context, but none was supplied.
|
Comparisons.ListComparison |
A comparison with a list of values.
|
Comparisons.MultiColumnComparison |
|
Comparisons.NullComparison |
A unary predicate for special nullity checks, such as NULL and NOT NULL .
|
Comparisons.ParameterComparison |
A comparison with a bound parameter, as opposed to a literal constant in the query.
|
Comparisons.SimpleComparison |
A comparison with a constant value.
|
Comparisons.TextComparison |
A text-style comparison, such as containing a given set of tokens.
|
Comparisons.TextContainsAllPrefixesComparison |
|
Comparisons.TextWithMaxDistanceComparison |
|
Comparisons.Type |
|
Compensation |
Interface for all kinds of compensation.
|
Compensation.ForMatch |
Regular compensation class for matches based on query predicates.
|
Compensation.WithPredicateCompensation |
|
CompletionExceptionLogHelper |
|
CompletionExceptionLogHelper.IgnoredSuppressedExceptionCount |
|
ComponentWithChildren |
|
ComponentWithComparison |
|
ComponentWithNoChildren |
|
ComponentWithSingleChild |
|
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 .
|
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.
|
ConstantPredicate |
A predicate with a constant boolean value.
|
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 |
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.
|
CreatesDuplicatesProperty |
A property that determines whether the expression may produce duplicate entries.
|
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 |
|
DataAccessRule |
A rule that utilizes index matching information compiled by CascadesPlanner to create a logical expression
for data access.
|
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.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.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.
|
DefaultTextTokenizer |
This is the default tokenizer used by full-text indexes.
|
DefaultTextTokenizerFactory |
|
DirectoryLayerDirectory |
A KeySpaceDirectory that maps a STRING value to a compact LONG value
using the FDB directory layer.
|
DotExporter<N extends PlannerGraph.Node,E extends PlannerGraph.Edge> |
Exports a graph into a DOT file.
|
DynamicMessageRecordSerializer |
Serialize records using default Protobuf serialization using DynamicMessage .
|
EmptyComparison |
A comparison to determine whether a repeated field is empty (has no occurrences).
|
EmptyCursor<T> |
|
EmptyKeyExpression |
A single empty key.
|
EndpointType |
|
EnumeratingIterable<T> |
|
EnumeratingIterable.EmptyIterable<T> |
|
EnumeratingIterator<T> |
An iterator extending Iterator providing the ability to skip a certain prefix.
|
EnumerationFunction<R> |
|
EvaluationContext |
A context for query evaluation.
|
EvaluationContextBuilder |
|
ExecuteProperties |
Limits on the execution of a query.
|
ExecuteProperties.Builder |
|
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.
|
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.
|
ExplainPlannerGraphRewritable |
|
ExplodeExpression |
A table function expression that "explodes" a repeated field into a stream of its values.
|
ExpressionChildrenMatcher |
|
ExpressionCountProperty |
A property that determines the sum, over all elements of a PlannerExpression tree, of the number of occurrences
of specific types of RelationalExpression .
|
ExpressionMatcher<T extends Bindable> |
A ExpressionMatcher is an expression that can be matched against a
RelationalExpression tree, while binding certain expressions/references in the tree to expression matcher objects.
|
ExpressionMatcher.DefaultMatcher<T extends Bindable> |
A default matcher.
|
ExpressionRef<T extends RelationalExpression> |
This interface is used mostly as an (admittedly surmountable) barrier to rules mutating bound references directly,
which is undefined behavior.
|
ExpressionRef.UngettableReferenceException |
An exception thrown when ExpressionRef.get() is called on a reference that does not support it, such as a group reference.
|
ExpressionRefTraversal |
|
ExpressionRefTraversal.ReferencePath |
Case class to hold information about the path from an expression to another expression reference.
|
ExtendedDirectoryLayer |
|
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 |
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 |
|
FDBDatabaseRunnerImpl |
|
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.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.
|
FDBIndexedRecord<M extends Message> |
A record that has been loaded via an index.
|
FDBLatencySource |
|
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 |
|
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 |
|
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 |
|
FDBRecordStore |
A multi-type record store.
|
FDBRecordStore.Builder |
|
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.
|
FDBRecordStoreBase<M extends Message> |
Base interface for typed and untyped record stores.
|
FDBRecordStoreBase.BaseBuilder<M extends Message,R extends FDBRecordStoreBase<M>> |
|
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 |
|
FDBRecordStoreKeyspace |
Unique integers used as the first tuple item within a record store's subspace.
|
FDBRecordStoreStateCache |
|
FDBRecordStoreStateCacheEntry |
|
FDBRecordStoreStateCacheFactory |
|
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> |
|
FDBStoredSizes |
Information about how a record is stored in the database.
|
FDBStoreTimer |
|
FDBStoreTimer.CountAggregates |
An aggregate over other count events.
|
FDBStoreTimer.Counts |
|
FDBStoreTimer.DetailEvents |
|
FDBStoreTimer.Events |
Ordinary top-level events which surround a single body of code.
|
FDBStoreTimer.Waits |
|
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 |
|
FDBTransactionPriority |
An enum indicating the priority of transactions against FoundationDB.
|
FDBTypedRecordStore<M extends Message> |
A type-safe record store.
|
FDBTypedRecordStore.Builder<M extends Message> |
|
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.
|
FieldWithComparison |
|
FieldWithComparisonCountProperty |
A property that counts the number of FieldWithComparison s that appear in a planner expression tree.
|
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.
|
FindingMatcher<T> |
|
FlatMapPipelinedCursor<T,V> |
A cursor that maps elements to another cursor which is then flattened.
|
FlattenNestedAndPredicateRule |
A simple rule that performs some basic Boolean normalization by flattening a nested AndPredicate into a single,
wider AND.
|
FormerIndex |
The location where a deleted index used to live.
|
FullUnorderedExpressionToScanPlanRule |
|
FullUnorderedScanExpression |
|
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> |
|
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.
|
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.
|
GroupExpressionPrinter |
|
GroupExpressionRef<T extends RelationalExpression> |
A Cascades-style group expression, representing the members of set of RelationalExpression s that belong to
the same equivalence class.
|
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.
|
IdentityBiMap<K,V> |
BiMap based on identities of types K and V .
|
IllegalContinuationAccessChecker |
|
ImplementDistinctRule |
|
ImplementDistinctUnionRule |
A rule that implements a distinct union of its (already implemented) children.
|
ImplementFilterRule |
|
ImplementIndexScanRule |
|
ImplementIntersectionRule |
A rule that implements an intersection of its (already implemented) children.
|
ImplementPhysicalScanRule |
|
ImplementTypeFilterRule |
|
ImplementUnorderedUnionRule |
A rule that implements an unordered union of its (already implemented) children.
|
Index |
Meta-data for a secondary index.
|
IndexAggregateFunction |
An aggregate function implemented by scanning an appropriate index.
|
IndexAggregateFunctionCall |
Class to represent a construct AGG by Set.of(col1, col2, ...) .
|
IndexAggregateGroupKeys |
|
IndexAggregateGroupKeys.Conditions |
|
IndexAggregateGroupKeys.IndexScan |
|
IndexBuildState |
A class that contains the build progress of a given index in a given record store.
|
IndexEntry |
An IndexEntry carries around the key and value read from an index (as the name would imply).
|
IndexFunctionHelper |
|
IndexingBase |
A base class for different types of online indexing scanners.
|
IndexingByIndex |
This indexer scans records by a source index.
|
IndexingByIndex.ValidationException |
thrown when IndexFromIndex validation fails.
|
IndexingByRecords |
This indexer scans all records in the record store.
|
IndexingCommon |
Shared data structure to be used (only) by the Indexing* modules.
|
IndexingThrottle |
This class provides build/commit/retry with throttling to the OnlineIndexer.
|
IndexKeyValueToPartialRecord |
Construct a record from a covering index.
|
IndexKeyValueToPartialRecord.Builder |
|
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 |
|
IndexMaintainerRegistry |
|
IndexMaintainerRegistryImpl |
|
IndexMaintainerState |
|
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.
|
IndexOperation |
A maintenance operation on a secondary index.
|
IndexOperationResult |
|
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.
|
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.
|
IndexScanExpression |
|
IndexScanType |
The way in which an index should be scanned.
|
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 |
|
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.
|
InstrumentedTransaction |
|
InternalPlannerGraphRewritable |
|
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.
|
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.
|
IsolationLevel |
The isolation level for reads from the database.
|
IterableHelpers |
|
IteratorCursor<T> |
A cursor that returns the elements of an ordinary synchronous iterator.
|
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 |
|
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.
|
KeyComparisons |
|
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.
|
KeyExpressionVisitor<S extends KeyExpressionVisitor.State,R extends KeyExpressionVisitor.Result> |
An interface to provide a state-based visitor pattern that can traverse a tree of KeyExpression s.
|
KeyExpressionVisitor.Result |
Tag interface to capture the result being returned by visitation methods of this visitor.
|
KeyExpressionVisitor.State |
Tag interface to capture state within this visitor.
|
KeyExpressionWithChild |
|
KeyExpressionWithChildren |
|
KeyExpressionWithoutChildren |
|
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 the (disturbingly) similarly named KeyWithValueExpression .
|
KeyPart |
A key expression that can be bound by a comparison.
|
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.
|
KeySpaceCountTree.Resolved |
The resolved interpretation of the node value.
|
KeySpaceCountTree.ResolvedIndexKeyspace |
A resolved index keyspace.
|
KeySpaceCountTree.ResolvedKeyField |
A resolved field of a record primary key or index key.
|
KeySpaceCountTree.ResolvedPath |
|
KeySpaceCountTree.ResolvedPrefixRoot |
|
KeySpaceCountTree.ResolvedRecordStoreKeyspace |
A resolved record store keyspace, such as records or indexes.
|
KeySpaceCountTree.ResolvedRecordTypeKeyspace |
A resolved record type key prefix keyspace.
|
KeySpaceCountTree.ResolvedRoot |
|
KeySpaceDirectory |
|
KeySpaceDirectory.KeyType |
The available data types for directories.
|
KeySpacePath |
A KeySpacePath represents a discrete path through a directory tree defined by a KeySpace .
|
KeySpacePathWrapper |
|
KeyValueCursor |
The basic cursor for scanning ranges of the FDB database.
|
KeyValueCursor.Builder |
|
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.
|
ListChildrenMatcher |
A matcher for a children that tries to match each child to a specified matcher.
|
ListCursor<T> |
A cursor that returns the elements of a list.
|
ListKeyExpression |
Combine keys from zero or more child keys.
|
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.
|
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.
|
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 unique 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.
|
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.
|
LogicalUnorderedUnionExpression |
A relational planner expression that represents an unimplemented unordered union of its children.
|
LogMessageKeys |
|
MapCursor<T,V> |
A cursor that applies a function to the elements of another cursor.
|
MappedPool<K,V,E extends Exception> |
MappedPool Class Attempts to reuse objects organized by keys.
|
MappedPool.MappedPoolProvider<K,V,E extends Exception> |
Function with Exceptions to provide the pool.
|
MapPipelinedCursor<T,V> |
A cursor that applies an asynchronous 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 |
|
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.
|
MatchFunction<T,M> |
An functional interface for a match function that computes a match result (an Iterable of type M .
|
MatchInfo |
This class represents the result of matching one expression against a candidate.
|
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.
|
MatchPartition |
Case class to represent a partition of partial matches.
|
MatchPartitionMatcher<T extends MatchPartition> |
Matches a subclass of MatchPartition and a given matcher against the children.
|
MatchPredicate<T> |
An predicate that tests for a match between quantifiers also taking into account an equivalence maps between
CorrelationIdentifier s.
|
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 MergeCursor s.
|
MergeCursorState<T> |
A holder for mutable state needed to track one of the children cursors of some merge operation.
|
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.
|
MessageValue |
A utility class for extracting data and meta-data from Protocol Buffer Message s, as used in the Record Layer.
|
MetaDataCache |
|
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 |
|
MetaDataException |
|
MetaDataPlanContext |
|
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 |
|
MetaDataVersionStampStoreStateCache |
|
MetaDataVersionStampStoreStateCacheFactory |
|
MultiChildrenMatcher |
An expression children matcher that tries to match a multitude of children to a single ExpressionMatcher .
|
MultiChildrenMatcher.AllChildrenMatcher |
An expression children matcher that tries to match all children to a single ExpressionMatcher .
|
MultiChildrenMatcher.SomeChildrenMatcher |
An expression children matcher that tries to match some children to a single ExpressionMatcher .
|
MutableRecordStoreState |
A record store that can be modified to reflect changes made to the database.
|
NestedField |
|
NestingKeyExpression |
A key expression within a nested subrecord.
|
NodeIcon |
NodeIcon Ids.
|
NodeInfo |
Explanatory information about the Record Layer's plan operators and storage objects.
|
NoOpIndexMaintainer |
An index maintainer that doesn't do anything.
|
NoOpIndexMaintainerFactory |
|
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.
|
NotPredicate |
A QueryPredicate that is satisfied when its child component is not satisfied.
|
ObjectPlanHash |
This class implements a planHash for the member classes of the query plan.
|
OneOfThem |
Class for matching any value of a repeated field.
|
OneOfThemWithComparison |
|
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 |
|
OnlineIndexer.Config |
A holder for the mutable configuration parameters needed to rebuild an online index.
|
OnlineIndexer.Config.Builder |
|
OnlineIndexer.IndexFromIndexPolicy |
A builder for the indexFromIndex policy.
|
OnlineIndexer.IndexFromIndexPolicy.Builder |
|
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.
|
OrComponent |
A QueryComponent that is satisfied when any of its child components is satisfied.
|
OrderingProperty |
A property that determines whether the expression may produce duplicate entries.
|
OrderingProperty.OrderingInfo |
Class to hold the info returned by this property.
|
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.
|
OrToUnorderedUnionRule |
Convert a filter on an or expression into a plan on the union.
|
PartialMatch |
Case class to represent a partial match.
|
PartialMatchMatcher<T extends PartialMatch> |
Matches a subclass of PartialMatch and a given matcher against the children.
|
PassThroughRecordStoreStateCache |
|
PassThroughRecordStoreStateCacheFactory |
|
PathValue |
A class to represent the value stored at a particular element of a KeySpacePath .
|
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 |
|
PipelineOperation |
Kind of asynchronous pipelined operation being performed.
|
PlanContext |
A basic context object that stores all of the metadata about a record store, such as the available indexes.
|
PlanHashable |
|
PlanHashable.PlanHashKind |
The "kinds" of planHash calculations.
|
PlannableIndexTypes |
A wrapper class to identify groups of that behave the same way from the perspective of the planner.
|
PlannerBindings |
|
PlannerBindings.Builder |
|
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.ExpressionRefHeadNode |
Node class for GroupExpressionRefs -- head.
|
PlannerGraph.ExpressionRefMemberNode |
Node class for GroupExpressionRefs - member.
|
PlannerGraph.ForEachQuantifierEdge |
Edge class for for-each quantifiers.
|
PlannerGraph.GroupExpressionRefEdge |
Edge class for GroupExpressionRefs.
|
PlannerGraph.GroupExpressionRefInternalEdge |
Edge class for GroupExpressionRefs.
|
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.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 for-each quantifiers.
|
PlannerGraph.WithExpression |
|
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 |
|
PlannerProperty<T> |
An interface for certain Cascades-style properties, which are measurable features of an expression other than the
structure of the expression tree.
|
PlannerRule<T extends Bindable> |
Classes that inherit from PlannerRule form the base of the Cascades planning system.
|
PlannerRuleCall |
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.
|
PredicateCountProperty |
A property that counts the number of ValuePredicate s that appear in a planner expression tree.
|
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 |
|
PredicateMultiMap.Builder |
Builder class for a predicate maps.
|
PredicateMultiMap.PredicateMapping |
Mapping class.
|
PredicateMultiMap.ReapplyPredicateFunction |
Functional interface to reapply a predicate if necessary.
|
PredicateWithValue |
A predicate consisting of a Value .
|
PrimaryAccessExpansionVisitor |
Class to expand primary data access into a candidate.
|
PrimaryScanExpression |
|
PrimaryScanMatchCandidate |
Case class to represent a match candidate that is backed by an index.
|
ProbableIntersectionCursor<T> |
A cursor that returns all results that are probably in all of its children.
|
PushDistinctFilterBelowFilterRule |
|
PushTypeFilterBelowFilterRule |
|
QuantifiedColumnValue |
A value representing the quantifier as an object.
|
QuantifiedObjectValue |
A value representing the quantifier as an object.
|
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.
|
QuantifierMatcher<T extends Quantifier> |
Matches a subclass of Quantifier and a given matcher against the children.
|
Quantifiers |
Auxiliary class containing factory methods and helpers for Quantifier .
|
Quantifiers.AliasResolver |
Resolver to resolve aliases to quantifiers.
|
Query |
Holder class for creating querying expressions.
|
Query.InvalidExpressionException |
Exception thrown when a query expression is not valid in some context.
|
QueryableKeyExpression |
|
QueryComponent |
Base component interface for checking whether a given record matches a query.
|
QueryComponentPredicate |
A QueryPredicate that is satisfied when its child component is satisfied.
|
QueryHashable |
Query hash - calculate and return identifying hash values for queries.
|
QueryHashable.QueryHashKind |
The "kinds" of queryHash calculations.
|
QueryKeyExpression |
|
QueryKeyExpressionWithComparison |
|
QueryPlan<T> |
An executable query plan.
|
QueryPlanInfo |
This class holds some additional information regarding the query plan that can be attached to the plan itself, without
impacting its structure.
|
QueryPlanInfo.QueryPlanInfoKey<T> |
An implementation of a type-safe Enum.
|
QueryPlanInfoKeys |
|
QueryPlanner |
|
QueryPlanner.IndexScanPreference |
Preference between index scan and record scan.
|
QueryPlanResult |
The result of planning a query.
|
QueryPredicate |
Class to model the concept of a predicate.
|
QueryRecordFunction<T> |
Class that provides context for asserting about a specially calculated value.
|
QueryRecordFunctionWithComparison |
|
QueryToKeyMatcher |
|
QueryToKeyMatcher.Match |
|
QueryToKeyMatcher.MatchType |
Whether a match was a successful, and if it was, whether the resulting keys have a single value.
|
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 |
|
RankIndexMaintainer |
An index maintainer for keeping a RankedSet of record field values.
|
RankIndexMaintainerFactory |
|
ReadVersionRecordStoreStateCache |
An implementation of the FDBRecordStoreStateCache that uses the read-version of the associated transaction
as the cache invalidation key.
|
ReadVersionRecordStoreStateCacheFactory |
|
RecordAlreadyExistsException |
|
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.NoNextReason |
|
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> |
|
RecordCursorResult.IllegalResultNoNextReasonAccessException |
|
RecordCursorResult.IllegalResultValueAccessException |
|
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 |
|
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.
|
RecordMetaData |
Meta-data for Record Layer record stores.
|
RecordMetaDataBuilder |
|
RecordMetaDataBuilder.MetaDataProtoDeserializationException |
Exception thrown when meta-data cannot be loaded from serialized form.
|
RecordMetaDataProvider |
|
RecordQuery |
The logical form of a query.
|
RecordQuery.Builder |
|
RecordQueryCoveringIndexPlan |
A query plan that reconstructs records from the entries in a covering index.
|
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.
|
RecordQueryFilterPlan |
A query plan that filters out records from a child plan that do not satisfy a filter component.
|
RecordQueryIndexPlan |
A query plan that outputs records pointed to by entries in a secondary index within some range.
|
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.
|
RecordQueryIntersectionPlan |
A query plan that executes by taking the union of records from two or more compatibly-sorted child plans.
|
RecordQueryInValuesJoinPlan |
A query plan that executes a child plan once for each of the elements of a constant IN list.
|
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.
|
RecordQueryPlan |
An executable query plan for producing records.
|
RecordQueryPlanComplexityException |
Exception thrown when a query plan is more complex than the configured limit.
|
RecordQueryPlanner |
The query planner.
|
RecordQueryPlanner.ScoredPlan |
|
RecordQueryPlannerConfiguration |
|
RecordQueryPlannerConfiguration.Builder |
|
RecordQueryPlannerSubstitutionVisitor |
Visitor interface for performing substitution-type rules on RecordQueryPlan s.
|
RecordQueryPlanWithChild |
A query plan with a single child plan.
|
RecordQueryPlanWithChildren |
A query plan with child plans.
|
RecordQueryPlanWithComparisons |
A query plan that uses ScanComparisons to drive some scan of the record store.
|
RecordQueryPlanWithIndex |
A query plan that uses a single index.
|
RecordQueryPlanWithNoChildren |
A query plan that does not have any child plans.
|
RecordQueryPlanWithRequiredFields |
Interface for query plans that have fields that must be present for successful execution.
|
RecordQueryPredicateFilterPlan |
A query plan that filters out records from a child plan that do not satisfy a QueryPredicate .
|
RecordQueryScanPlan |
A query plan that scans records directly from the main tree within a range of primary keys.
|
RecordQueryScoreForRankPlan |
A query plan that converts ranks to scores and executes a child plan with the conversion results bound in named parameters.
|
RecordQueryScoreForRankPlan.ScoreForRank |
A single conversion of a rank to a score to be bound to some name.
|
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).
|
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.
|
RecordQueryUnorderedPrimaryKeyDistinctPlan |
A query plan that removes duplicates by means of a hash table of primary keys already seen.
|
RecordQueryUnorderedUnionPlan |
A query plan that returns results from two-or-more cursors as they as ready.
|
RecordScanLimiter |
Track number of records scanned up to some limit, after which record scans should not be allowed.
|
RecordScanLimiterFactory |
|
RecordSerializationException |
Exception thrown when there is a problem serializing or deserializing a record.
|
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 |
|
RecordStoreDoesNotExistException |
|
RecordStoreNoInfoAndNotEmptyException |
|
RecordStoreStaleMetaDataVersionException |
Exception thrown when the record store has a newer meta-data version than the one from the given RecordMetaDataProvider .
|
RecordStoreStaleUserVersionException |
|
RecordStoreState |
The RecordStoreState interface handles information that might differ between otherwise identical
record stores.
|
RecordType |
Record type meta-data.
|
RecordTypeBuilder |
|
RecordTypeBuilder.NonbuildableException |
Exception thrown when a RecordTypeBuilder is not yet in a state where it can be built.
|
RecordTypeChangedException |
|
RecordTypeIndexesBuilder |
|
RecordTypeKeyComparison |
|
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.
|
ReferenceMatcher<T extends RelationalExpression> |
An expression matcher that matches against any reference at all.
|
RelationalExpression |
|
RelationalExpression.CombineFunction<R,S> |
|
RelationalExpression.CombinePredicate |
|
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.
|
RelationalExpressionPointerSet<T extends RelationalExpression> |
|
RelationalExpressionWithChildren |
|
RelationalExpressionWithPredicate |
A (relational) expression that has a predicate on it.
|
RemoveRedundantTypeFilterRule |
A rule that eliminates logical type filters that are completely redundant; that is, when the child of the logical
type filter is guaranteed to return records of types included in the filter.
|
RemoveSortRule |
A rule that implements a sort expression by removing this expression if appropriate.
|
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 |
|
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 .
|
ResolverMappingDigest |
Computes a message digest for all of the string to integer mappings in the provided LocatableResolver .
|
ResolverMappingReplicator |
|
ResolverResult |
|
RestartException |
Tag-exception that is specifically thrown by implementations of Debugger to signal the planner to restart
planning.
|
RowLimitedCursor<T> |
A cursor that limits the number of elements that it allows through.
|
ScanComparisons |
|
ScanComparisons.Builder |
|
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 FDBRecordStore s if they are scanning non-readable indexes.
|
ScanProperties |
A group of properties that pertain to a single scan.
|
ScopedDirectoryLayer |
An implementation of LocatableResolver that uses the FDB directory layer to keep track of the allocation of
strings to integers.
|
ScopedInterningLayer |
|
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.
|
SelectExpression |
A select expression.
|
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.
|
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.
|
StandardIndexMaintainer |
|
StoreRecordFunction<T> |
Record function that should be evaluated for some record against
an FDBRecordStoreBase instance.
|
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.Counter |
Contains the number of occurrences and cummulative time spent on an associated StoreTimer.Event .
|
StoreTimer.DetailEvent |
|
StoreTimer.Event |
An identifier for occurrences that need to be timed.
|
StoreTimer.Wait |
|
StoreTimerSnapshot |
|
StoreTimerSnapshot.CounterSnapshot |
|
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 |
|
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> |
|
SyntheticRecordTypeBuilder.Constituent |
A constituent type within a joined record type.
|
TestLogMessageKeys |
|
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 |
|
TextCollatorRegistryJRE |
A text collator registry using the Java Platform's own Collator implementation.
|
TextCollatorRegistryJRE.TextCollatorJRE |
|
TextIndexBunchedSerializer |
|
TextIndexMaintainer |
The index maintainer class for full-text indexes.
|
TextIndexMaintainerFactory |
|
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 |
|
TextTokenizerRegistry |
|
TextTokenizerRegistryImpl |
|
ThenKeyExpression |
Combine keys from two or more child keys.
|
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.
|
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 |
|
TimeWindowRecordFunction<T> |
The TIME_WINDOW_RANK record function.
|
TopologicalSort |
Utility class to provide helpers related to topological sorts.
|
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> |
|
TransformedRecordSerializer.TransformState |
|
TransformedRecordSerializerJCE<M extends Message> |
|
TransformedRecordSerializerJCE.Builder<M extends Message> |
|
TransitiveClosure |
Utility class to provide helpers related to the computation of the transitive closure of a partial order.
|
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 Tuple s.
|
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.
|
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.
|
TypeMatcher<T extends Bindable> |
A matcher that is specified by the class of its expression: to match any of several types of expressions, they must all
implement a common interface (which itself extends PlannerExpression ).
|
TypeWithPredicateMatcher<T extends RelationalExpressionWithPredicate> |
|
UninitializedRecordStoreException |
An exception that can be thrown by FDBRecordStore s 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.
|
UnmatchedFieldsProperty |
|
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.
|
Value |
A scalar value type.
|
ValueComparisonRangePredicate |
A special predicate used to represent a parameterized tuple range.
|
ValueComparisonRangePredicate.Placeholder |
A place holder predicate solely used for index matching.
|
ValueComparisonRangePredicate.Sargable |
A query predicate that can be used as a (s)earch (arg)ument for an index scan.
|
ValueIndexExpansionVisitor |
Class to expand value index access into a candidate graph.
|
ValueIndexLikeExpansionVisitor |
Expansion visitor that implements the shared logic between primary scan data access and value index access.
|
ValueIndexLikeExpansionVisitor.VisitorState |
Class that holds the state necessary to expand both primary data access as well as value indexes.
|
ValueIndexMaintainer |
An index maintainer for an ordinary index by value, implementing ordered enumeration of records within a range of indexed values.
|
ValueIndexMaintainerFactory |
|
ValueIndexScanMatchCandidate |
Case class to represent a match candidate that is backed by an index.
|
ValuePredicate |
|
ValueRange<T> |
A range defines the boundaries around a contiguous span of values of some type.
|
VersionIndexMaintainer |
|
VersionIndexMaintainerFactory |
|
VersionKeyExpression |
A key expression that indicates that a serialized FDBRecordVersion should
be contained within the key.
|
VersionValue |
A value representing a version stamp.
|