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.
|
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 |
|
AliasMap.MatchingIdPredicate |
An predicate that tests for a match between quantifiers also taking into account an equivalence maps between
CorrelationIdentifier s.
|
AllChildrenMatcher |
An expression children matcher that tries to match all children to a single ExpressionMatcher .
|
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.
|
BaseNestedField |
An abstract base class for all QueryComponent s that represent a query of a nested record type.
|
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.
|
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 |
|
CascadesRuleCall |
|
ChainedCursor<T> |
A cursor that iterates over a set of data that is dynamically generated a single value at a time.
|
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.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 |
|
CompletionExceptionLogHelper |
|
CompletionExceptionLogHelper.IgnoredSuppressedExceptionCount |
|
ComponentWithChildren |
|
ComponentWithComparison |
|
ComponentWithNoChildren |
|
ComponentWithSingleChild |
|
ComposedBitmapIndexAggregate |
Transform a tree of Boolean expressions into a tree of bitwise operations on streams of bitmaps.
|
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 .
|
ConcatCursor<T> |
A cursor that returns the elements of a first cursor followed by the elements of a second cursor.
|
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).
|
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.
|
CursorLimitManager |
Handles the logic of tracking various out-of-band limits on a BaseCursor .
|
CursorStreamingMode |
|
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 .
|
Element |
A value in the ViewExpression language that can be represented as an element of FoundationDB tuple.
|
ElementKeyExpression |
A key expression that derives its values from an Element .
|
ElementPredicate |
|
ElementPredicateCountProperty |
A property that counts the number of ElementPredicate s that appear in a planner expression tree.
|
EmptyComparison |
A comparison to determine whether a repeated field is empty (has no occurrences).
|
EmptyCursor<T> |
|
EmptyKeyExpression |
A single empty key.
|
EndpointType |
|
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.
|
ExplainPlannerGraphRewritable |
|
ExpressionChildrenMatcher |
|
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.
|
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.
|
ExpressionRefDelegate<T extends RelationalExpression> |
An expression reference that wraps another expression reference.
|
ExpressionRefTraversal |
|
ExpressionRefTraversal.RefPath |
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.
|
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.
|
FieldElement |
An element that extracts a single, non-repeated field (at an arbitrary nesting depth) from a source.
|
FieldKeyExpression |
Take keys from a record field.
|
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.
|
FilterWithElementWithComparisonRule |
A rewrite rule that turns a logical filter on the results of a full scan (without a sort) into an index scan on
a compatibly ordered index.
|
FindPossibleIndexForAndPredicateRule |
A rule that finds all indexes that could implement one of the ComponentWithComparison conjuncts of an AND
filter, leaving all the other filters (of any type, including other fields) as a residual filter.
|
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.
|
GmlExporter<N extends PlannerGraph.Node,E extends PlannerGraph.Edge> |
Exports a graph into a DOT file.
|
GraphExporter<N,E> |
Exports a graph into a DOT file.
|
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.
|
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.
|
IllegalContinuationAccessChecker |
|
ImplementDistinctRule |
|
ImplementFilterRule |
|
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.
|
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).
|
IndexEntrySource |
A source of abstract index entries, each of which references a single record.
|
IndexEntrySourceScanExpression |
|
IndexFunctionHelper |
|
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.
|
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.
|
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.
|
KeyExpressionWithChild |
|
KeyExpressionWithChildren |
|
KeyExpressionWithoutChildren |
|
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.
|
LiteralElement<T> |
A value representing a single, static value of type T .
|
LiteralKeyExpression<T> |
Expression to allow a static value to be utilized in a key expression.
|
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.
|
LogicalSortExpression |
A relational planner expression that represents an unimplemented sort on the records produced by its inner
relational planner expression.
|
LogicalToPhysicalScanRule |
|
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 |
|
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 |
|
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.
|
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.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.
|
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.
|
PassThroughRecordStoreStateCache |
|
PassThroughRecordStoreStateCacheFactory |
|
PathValue |
A class to represent the value stored at a particular element of a KeySpacePath .
|
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 |
|
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.ExpressionRefHeadNode |
Node class for GroupExpressionRefs -- head.
|
PlannerGraph.ExpressionRefMemberNode |
Node class for GroupExpressionRefs - member.
|
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.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.
|
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.
|
ProbableIntersectionCursor<T> |
A cursor that returns all results that are probably in all of its children.
|
PushConjunctElementWithComparisonIntoExistingScanRule |
A rule that selects one of the ComponentWithComparison
conjuncts from an AND and tries to push it into an existing logical scan.
|
PushDistinctFilterBelowFilterRule |
|
PushElementWithComparisonIntoExistingScanRule |
A simple rule that looks for a ComponentWithComparison
predicate and a compatibly ordered index scan comparison down to the index scan.
|
PushSortIntoExistingIndexRule |
A rule that pushes a sort into a compatibly-ordered index scan, including one with existing comparisons
(from filters or other sort orders) that might affect whether the index is compatibly ordered.
|
PushTypeFilterBelowFilterRule |
|
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.MatchingPredicate |
An predicate that tests for a match between quantifiers also taking into account an equivalence maps between
CorrelationIdentifier s.
|
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.
|
QueryKeyExpression |
|
QueryKeyExpressionWithComparison |
|
QueryPlan<T> |
An executable query plan.
|
QueryPlanner |
|
QueryPlanner.IndexScanPreference |
Preference between index scan and record scan.
|
QueryPredicate |
An interface describing a predicate that can be evaluated on a SourceEntry (usually derived from a record).
|
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 |
|
RecordTypeElement |
An element representing the record type of each entry generated by the source.
|
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.
|
RecordTypeSource |
A Source representing the stream of all records of a particular type or types.
|
RecordTypesProperty |
A property visitor that determines the set of record type names (as Strings) that a RelationalExpression
could produce.
|
ReferenceMatcher<T extends RelationalExpression> |
An expression matcher that matches against any reference at all.
|
RelationalExpression |
|
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.
|
RepeatedFieldSource |
A Source representing the stream of the zero or more values of a repeated field.
|
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 |
|
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.
|
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.
|
SortToIndexRule |
|
Source |
A source represents a stream of entities that can be used to generate Element s, such as records or field values.
|
SourceEntry |
A single entity produced by a source from a record, mapping each (inclusive) dependant source to a concrete value.
|
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.
|
TopologicalSort.TopologicalOrderPermutationIterable<T> |
|
TopologicalSort.TopologicalOrderPermutationIterator<T> |
An iterator extending Iterator providing the ability to skip a certain prefix.
|
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> |
|
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.
|
ValueElement |
An Element representing an entire value, such as a scalar or message, obtained from a source.
|
ValueIndexMaintainer |
An index maintainer for an ordinary index by value, implementing ordered enumeration of records within a range of indexed values.
|
ValueIndexMaintainerFactory |
|
ValueRange<T> |
A range defines the boundaries around a contiguous span of values of some type.
|
VersionElement |
An Element representing a serialized versionstamp in a query or index entry.
|
VersionIndexMaintainer |
|
VersionIndexMaintainerFactory |
|
VersionKeyExpression |
A key expression that indicates that a serialized FDBRecordVersion should
be contained within the key.
|
ViewExpression |
An abstraction that represents a stream of values that can be represented as tuple-encoding keys and binary values
in FoundationDB.
|
ViewExpression.Builder |
A builder class for constructing an (immutable) view expression.
|
ViewExpressionComparisons |
|