All Classes and Interfaces
Class
Description
A rule that matches an
AndPredicate or OrPredicate and attempts to simplify the terms underneath
according to the boolean absorption law.The
array function.An array that does not need any nested proto constructed.
Deserializer.
A rule that utilizes index matching information compiled by
CascadesPlanner to create one or more
expressions for data access.AbstractPlannerGraph<N extends AbstractPlannerGraph.AbstractNode,E extends AbstractPlannerGraph.AbstractEdge>
The planner graph class.
Edge class.
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.
Abstract implementation of
QueryPredicate that provides memoization of correlatedTo sets.AbstractQueryPredicateRule<RESULT,CALL extends AbstractQueryPredicateRuleCall<RESULT,CALL>,TYPE extends QueryPredicate>
Tag class to bind the base
BASE to QueryPredicate.A rule call tag sub class for the simplification of
QueryPredicate trees.A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
The rule matching occurs in two stages: first, the planner examines the
AbstractRule.matcher of the rule,
which is a BindingMatcher expression that expresses the operators that the rule applies to and the hierarchical
structure that they take on in the expression tree.A rule call implementation for the simplification of
Value trees.A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
Abstract implementation of
Value that provides memoization of correlatedTo sets.Tag class to bind the base
BASE to Value.A rule call implementation for the simplification of
Value trees.A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
Interface to represent an access hint.
Represents a set of AccessHint a query or a match candidate has.
An aggregate accumulator.
This interface presents a state af an accumulated value.
A rule that attempts to improve an existing
PartialMatch by absorbing an expression on the
candidate side.This interface encapsulates the aggregation operator behavior: It holds onto the current state
and applies a new record onto the current state to arrive at the new accumulated state.
A cursor that groups incoming records by the given grouping criteria.
Exception thrown when an aggregate function is not supported.
Expands an aggregate index into a
MatchCandidate.Case class that represents a grouping index with aggregate function(s).
A value representing an aggregate: a value calculated (derived) from other values by applying an aggregation operator
(e.g.
This class encapsulates mappings between
CorrelationIdentifiers and helpers to create and maintain
these mappings.Builder class for the
AliasMap.A matcher that only matches anything if all of its downstream matchers produce bindings.
A
QueryComponent that is satisfied when all of its child components are satisfied.The common base class for Boolean
And and Or query components.Common base class for predicates with many children, such as
AndPredicate and OrPredicate.A
Value that applies conjunction/disjunction on its boolean children, and if possible, simplifies its boolean children.The
and function.Deserializer.
The
or function.A
QueryPredicate that is satisfied when all of its child components are.Deserializer.
A rule that matches a
AndPredicate (with the argument values) that applies the annulment law.A rule that matches a
OrPredicate (with the argument values)
that applies the annulment law.A binding matcher that is a
CollectionMatcher that binds to individual elements contained in a collection
separately.A matcher that matches if any of its downstream matchers produce bindings.
An enum representing the different supported FDB API versions.
A
Value that applies an arithmetic operation on its child expressions.The
add function.The bitwise
and function.The
bitmap_bit_position function.The
bitmap_bucket_number function.The bitwise
bitmap_bucket_offset function.The bitwise
or function.The bitwise
xor function.Deserializer.
The
div function.Logical operator.
The
mod function.The
mul function.Physical operators.
The
sub function.An asynchronous Boolean
and / or over a sequence of operands.A cursor that returns the elements of an
AsyncIterator.A cache for retaining the result of some asynchronous operation up until some expiration time.
The data-structure to maintain the current state of requested locks on a particular resource.
A wrapper cursor that manages the locking of resources before operating on inner cursor.
The particular operation to be performed by an
AtomicMutationIndexMaintainer index.The atomic mutations implemented straightforwardly by the FDB API.
An index that maintains an aggregate value in a low-contention way.
A factory for
AtomicMutationIndexMaintainer indexes.An "atom expression" is one that has semantic meaning; that is, its presence is significant to the meaning of
the expression.
Basic interface for all attributes of
AbstractPlannerGraph.AbstractNode
as well as AbstractPlannerGraph.AbstractEdge.Interface for attributes of
AbstractPlannerGraph.AbstractNode
as well as AbstractPlannerGraph.AbstractEdge that are used to serialize to GML or to DOT.Interface for attributes of
AbstractPlannerGraph.AbstractNode
as well as AbstractPlannerGraph.AbstractEdge that are used to serialize to DOT.Basic interface all attributes of
AbstractPlannerGraph.AbstractNode
as well as AbstractPlannerGraph.AbstractEdge that are use to serialize to GML.Interface for attributes of
AbstractPlannerGraph.AbstractNode
as well as AbstractPlannerGraph.AbstractEdge that are used to neither serialize to GML or to DOT.A cursor that can iterate over a cursor across transactions.
Represents a subset of the fields available in a stream of records, including partial records.
A copy-if-predicate that returns
true if a particula ordinal path already exists in the tuple.Deserializer.
A predicate that tests whether a copy in
IndexKeyValueToPartialRecord.Copier is necessary.A pair of a tuple source (key or value) and an index within that tuple source.
A copy-if-predicate that always returns
true.Deserializer.
Accumulator state for AVERAGE operations.
A tag interface for "base" cursors which read records directly from the database.
An abstract base class for field-like
QueryComponents that involve predicates on one particular record field,
as specified by the BaseField.fieldName member.Base class to provide some common logic shared between most expression implementations.
An exception that is thrown when
BaseKeyExpression.getSubKey(int, int) is used incorrectly.An exception indicating that the key expression is not splittable.
Abstract base class for all matchers.
An abstract base class for all
QueryComponents that represent a query of a nested record type.Helper methods for manipulating parameter values passed in
Bindings.A binding matcher is an object that can be matched against a complex object tree, while binding certain
references in the tree to matcher objects.
A map of bound parameter values passed to query evaluation.
A builder for
Bindings.Bindings slots used internally by plan operators.
The bitmap aggregate index expansion visitor.
An index maintainer for storing bitmaps of which records meet a specific condition.
A factory for
BitmapValueIndexMaintainer.Indicates whether
FDBDatabase.asyncToSync(FDBStoreTimer, FDBStoreTimer.Wait, java.util.concurrent.CompletableFuture) or
FDBRecordContext.asyncToSync(FDBStoreTimer.Wait, java.util.concurrent.CompletableFuture) should
attempt to detect when it is being called from an asynchronous context and, if so, how it should react to
this fact.Exception thrown when
asyncToSync detects that it is being called from within an asynchronous context.A boolean component is a component representing an operation in the boolean algebra, e.g.
A normalizer of a tree of
QueryComponent predicates into disjunctive normal form.A normalizer of a tree of
QueryPredicates into a normal form which may be its conjunctive or disjunctive
normal form.The target normal form.
Case class for metrics we need to keep track of for various purposes.
Shim class to translate objects of type
Value to QueryPredicate.A boolean container that can if the boolean is true carry a
QueryPlanConstraint.Case class to represent a match for matchers that compute a result.
A bound record query wraps an instance of
RecordQuery and RecordStoreState in order to associate
the query with the state of a store.Helper class to interface with the system browser.
Main interface for defining a built-in function that can be evaluated against a number of arguments.
A shim to wrap old-style byte array continuations.
Track the number of bytes scanned up to some limit, after which record scans should not be allowed.
A factory that produces implementations of
ByteScanLimiters.This property attempts to derive the minimum and the maximum cardinality of the conceptual result of a
RelationalExpression.Class to capture both minimum and maximum cardinality of an expression.
Class to encapsulate the minimum or maximum cardinality of an expression.
A comparator implementing the current heuristic cost model for the
CascadesPlanner.A Cascades-style query planner that converts a
RecordQuery to a RecordQueryPlan, possibly using
secondary indexes defined in a RecordMetaData to execute the query efficiently.Represents actual tasks in the task stack of the planner.
Classes that inherit from
CascadesRule form the base of the Cascades planning system.A rule call implementation for the
CascadesPlanner.A cursor that iterates over a set of data that is dynamically generated a single value at a time.
Utility class to provide helpers related to enumeration of
n choose k.Helper class for pooling
Cipher.A rule that un-expands a star expansion.
COLLATE function.Implementation of
CollateFunctionKeyExpression using TextCollatorRegistryJRE.A
Value that turns a string into a locale-specific sort key.Base class for defining collation built-in function.
Define
collate_jre built-in function.Deserializer for
PCollateValue.Tag interface used for overloads for matchers that bind to collections of values/objects.
A class to hold a value computing a column together with information about the field of a record it supplies
the result for.
A simple rule that combines two nested filter plans and combines them into a single filter plan with a conjunction
of the two filters.
A cursor that implements a comparison of matching elements from a set of cursors all of whom are ordered compatibly.
Interface to define compensation for partially matched
Value-trees and their associated comparisons, as
e.g.Nested chaining comparison compensation.
A set of compatible comparisons on a single field of a
KeyExpression
representing a contiguous range of values for that field.Class to represent the outcome of a merge operation.
Comparison ranges can be divided into three types.
Helper class that operates on a list of
ComparisonRanges.Helper methods for building
Comparisons.Comparisons.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).
A comparison against a parameter.
Exception thrown when comparison evaluation needs the query context, but none was supplied.
Comparison that is built on applying function's inverse to the comparand of a different comparison.
Deserializer.
A comparison with a list of values.
Deserializer.
Comparison wrapping another one and answering
true to Comparisons.MultiColumnComparison.hasMultiColumnComparand().Deserializer.
A unary predicate for special nullity checks, such as
NULL and NOT NULL.Deserializer.
A predicate for comparisons to things unknown or opaque to the planner.
Deserializer.
A comparison with a bound parameter, as opposed to a literal constant in the query.
Deserializer.
A comparison with a bound parameter, as opposed to a literal constant in the query.
A comparison with a constant value.
Deserializer.
A comparison with a constant value.
A text-style comparison, such as containing a given set of tokens.
A
Comparisons.TextComparison that checks for all prefixes.A
Comparisons.TextComparison that must be satisfied within a certain number of text tokens.The type for a
Comparisons.Comparison predicate.A comparison with a
Value, as opposed to a literal constant in the query.Deserializer.
A property for collecting all
ScanComparisons for the sub tree the property is evaluated on.A predicate to be used as part of a
QueryPlanConstraint
which can determine if a given plan can be executed under the types currently defined in the schema.Deserializer.
Trie to capture the paths this value needs to check for compatible type evolution.
Builder version of
CompatibleTypeEvolutionPredicate.FieldAccessTrieNode.A rule that computes compensation for a record constructor and all matched values for children of this record
constructor.
A rule that matches a
Value (with the argument values).Interface for all kinds of compensation.
Regular compensation class for matches based on query predicates.
Helper class for helping with logging of
CompletionExceptions.A special "exception" to record the number of suppressed exceptions that were not recorded due to the
CompletionExceptionLogHelper.maxSuppressedCount.A
QueryComponent that has child components.A
QueryComponent that uses a Comparisons.Comparison on the record.A
QueryComponent that does not have any child components.A
QueryComponent with exactly one child component.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.A query plan implementing a bit-wise merge of two or more covering index scans of
BITMAP_VALUE indexes.Plan extension of
ComposedBitmapIndexCursor.Composer.A rule that composes a field access and an underlying field access to a concatenated field access.
A rule that composes a field access and an underlying record construction, that is, it simplifies a field
access over a record construction by replacing it with the field itself, for example
(("Hello" as a, "World" as b).b is transformed to "World".A rule that computes the underlying order of a
Value tree rooted at a ToOrderedBytesValue.This class implements a
GenericMatcher which matches two sets of elements of type T to compute
a result of type Iterable<BoundMatch<R>>.A cursor that returns the elements of a first cursor followed by the elements of a second cursor.
This returns the index of the first implication that is satisfied.
Deserializer.
Represents a constant value that references a constant in __CONST__ binding of
EvaluationContext.Deserializer.
A predicate with a constant boolean value.
Deserializer.
A wrapper around a constant.
Deserializer.
A map to keep track of constraining attributes for an expression reference.
Tag interface used for overloads for matchers.
A typed matcher that matches the current expression if the current expression is contained in a
group reference binding designated by another
BindingMatcher (which was bound earlier on a reference).A correlated entity is one which can only be evaluated as a function of some input (usually a
Quantifier
from its relational parent).Helper class to wrap extenders of
Correlated to provide standard equivalence and hash code
functionality under a given AliasMap.A correlation identifier is an immutable object that is created with a string uniquely identifying it.
A counting aggregate value.
The
count(x) function.Deserializer.
The counting argument type.
Sum partial counts in the appropriate mode.
A
Value that creates dynamic types on the fly and therefore needs special consideration when dealing with
protobuf descriptors.Utility class to provide helpers related to enumeration of cross products.
Handles the logic of tracking various out-of-band limits on a
BaseCursor.The streaming mode to use when opening
RecordCursors.A rule that utilizes index matching information compiled by
CascadesPlanner to create one or more
expressions for data access.A predicate to be used as part of a
QueryPlanConstraint
which can determine if a given plan can be executed under the currently available database objects.Deserializer.
Helper class to capture the name together and the last modified version of an index.
This interface functions as a stub providing hooks which can be called from the planner logic during planning.
Abstract event class to capture
rootReference amd taskStack.Events of this class are generated when the planner attempts to adjust an existing match.
Tag interface for all events.
Interface for events that hold a group ref.
Events that are created by a or as part of a transformation rule.
Interface for events that hold a root reference.
Events of this class are generated every time the planner executes a task.
Events of this class are generated when the planner explores an expression.
Events of this class are generated when the planner explores a group.
Events of this class are generated when the planner attempts to insert a new expression into the memoization
structures of the planner.
Enum to indicate where an event happened.
Events of this class are generated when the planner optimizes a group.
Events of this class are generated when the planner optimizes inputs.
Shorthands to identify a kind of event.
Events of this class are generated when the planner transforms an expression using a rule.
Events of this class are generated when the planner calls a transformation rule.
Events of this class are generated when the planner creates new expressions as part of rebasing or as part of
a translation of correlations in a graph.
A formatter for tokens.
Symbol table that uses the alias' string representation as symbol.
A rule that computes the default order of a
Value tree.Default implementation of a plan serialization registry.
A set of rules for use by a planner that supports quickly finding rules that could match a given
QueryPredicate.This is the default tokenizer used by full-text indexes.
Factory class for the
DefaultTextTokenizer.A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
A logical version of
RecordQueryDeletePlan.A rule that matches a
NotPredicate over an AndPredicate or OrPredicate and applies a
transformation utilizing deMorgan's law.Helper methods useful for managing dependency sets using
CorrelationIdentifiers.A property used to create and collect the derivations of data flowing in a plan.
Cases class to capture the derivations that are being collected by the visitor.
A visitor that determines the derivations of a
RecordQueryPlan.A value merges the input messages given to it into an output message.
Deserializer.
A key expression that divides into three parts that represent the constituent parts of a multidimensional index.
A
KeySpaceDirectory that maps a STRING value to a compact LONG value
using the FDB directory layer.An attribute used to indicate if a plan produces distinct records.
A visitor that determines whether the expression may produce distinct records.
Exports a graph into a DOT file.
Accumulator state for Double types.
Serialize records using default Protobuf serialization using
DynamicMessage.A rule that eliminates an arithmetic operation.
A comparison to determine whether a repeated field is empty (has no occurrences).
A
RecordCursor that always returns zero items.A single empty key.
A value that evaluates to empty.
Deserializer.
A functional interface that provides an encapsulation of a runtime computation against a set of arguments.
The type of one of the endpoints of a
TupleRange.Iterable that provides special iterators of type
EnumeratingIterator.An implementation of
EnumeratingIterable that is optimized to work for empty
input sets.An implementation of
EnumeratingIterable that is optimized to work for single item
input sets.A single element iterator.
An iterator extending
Iterator providing the ability to skip a certain prefix.Functional interface to allow implementors to provide use case-specific logic when permutations are enumerated by
BaseMatcher.match(com.apple.foundationdb.record.query.plan.cascades.matching.graph.EnumerationFunction<R>, boolean).A context for query evaluation.
A builder for
EvaluationContext.Limits on the execution of a query.
A builder for
ExecuteProperties.An encapsulation of the mutable state of query or scan execution.
An existential predicate that is true if the inner correlation produces any values, and false otherwise.
Deserializer.
A
Value that checks whether an item exists in its child quantifier expression or not.Deserializer.
A function that checks whether an item exists in a
RelationalExpression.A rule that decomposes a
FieldValue that uses multiple steps into two FieldValues as follows:A rule that expands a
Value of type Type.Record into a record constructor over its constituent parts
as follows:
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.A formatter for tokens.
Explain level.
Interface to allow
RelationalExpressions to rewrite their own
explain graph representation.Visitor that produces a string representation of a
RecordQueryPlan.Formatting for
Value.explain().Interface for simple symbol maps for the purpose of mapping an alias as supplied by the planner to a human-readable
string symbol.
Class to hold information about a list of tokens.
An alias definition token.
An alias reference token.
A brackets token.
A comma-like token.
Token that registers an alias explicitly to some symbol.
An identifier token.
A keyword token.
A line break or whitespace token.
A nested token.
An optional whitespace token.
A pop token.
A push token.
Generic token structure.
A token enumeration that is used intermittently when something is explained.
A ToString token.
A whitespace token.
Holder class for the result of a call to
Value.explain() and derivatives.Precedence which informs the explain logic whether to put parentheses around explain terms or not.
A table function expression that "explodes" a repeated field into a stream of its values.
This class maintains a delay that should be used when retrying transactional operations that have failed due to
something retriable.
An interface for certain Cascades-style properties, which are measurable features of an expression other than the
structure of the expression tree.
Visitor to find mappings of
KeyExpressions to tuple access paths that are encoded as AvailableFields.FieldData.Result class.
State class.
An implementation of
LocatableResolver that uses a key format that is compatible with the ScopedDirectoryLayer
to keep track of the allocation of strings to integers.A set of rules to be used to create a
Value tree to extract an item from an index entry and perform
necessary adjustments prior to constructing the partial record in
IndexKeyValueToPartialRecord.Interface for the unapply function using in a variety of matchers.
Provide an alternative cursor in case the primary cursor fails.
Exception thrown when the fallback cursor fails.
A known FDB
Database, associated with a cluster file location.Function for mapping an underlying exception to a synchronous failure.
1.
Abstract class for a factory that manages
FDBDatabase instances.A singleton maintaining a list of
FDBDatabase instances, indexed by their cluster file location.A context for running against an
FDBDatabase with retrying of transient exceptions.Exception thrown when
FDBDatabaseRunner has been closed but tries to do work.The standard implementation of
FDBDatabaseRunner.Namespace for exceptions that wrap the underlying exceptions from the FDB API.
Exceptions that are reported by (or due to limitations of, etc.) the FDB API.
Exception thrown when key size is exceeded.
Transaction failed due to a lock already taken.
An exception that should be retried by the caller because is stems from a transient condition in FDB.
Transaction failed due to a conflict with another transaction.
Transaction is too old to perform reads or be committed.
Exception thrown when transaction size is exceeded.
Exception thrown when a transaction times out.
Exception thrown when value size is exceeded.
A record that can be passed to an index maintainer.
A raw record that has been loaded via an index.
A record that has been loaded via an index.
Indicates which FDB API calls are to have latency injected into them via
FDBDatabaseFactory.setLatencyInjector(Function).An interface containing a set of functions for discovering the location of the keys within a cluster.
An implementation of the
FDBLocalityProvider interface that uses foundationDB's LocalityUtil API to
discover the storage locations of keys within a cluster.Serialization of
RecordMetaData into the database.Thrown if meta-data was never written to the store.
A record returned by a query and therefore possibly associated with a particular entry in some index.
A record associated with the corresponding meta-data.
An open transaction against FDB.
A hook to run after commit has completed successfully.
A synchronous
FDBRecordContext.CommitCheckAsync.A consistency check, such as uniqueness, that can execute asynchronously and is finally checked at or before commit time.
A supplier of a future to be executed after the transaction has been successfully committed.
A configuration struct that can be used to set various options on an
FDBRecordContext.A builder of
FDBRecordContextConfigs using the standard builder pattern.A multi-type record store.
A builder for
FDBRecordStore.Exception that can be thrown if one attempts to mark an index as readable
if it is not yet readable.
Reason that an index is being rebuilt now.
Enum controlling how the store state cacheability flag should be changed when the store is opened.
Base interface for typed and untyped record stores.
Builder for
FDBRecordStoreBase.Function for computing the number of elements to allow in the asynchronous pipeline for an operation of the given
type.
Action to take if the record being saved does / does not already exist.
Action to take if the record store does / does not already exist.
Hook for checking if store state for client changes.
Provided during record save (via
FDBRecordStoreBase.saveRecord(Message, FDBRecordVersion, VersionstampSaveBehavior)),
directs the behavior of the save w.r.t.Unique integers used as the first tuple item within a record store's subspace.
Property keys for the
FDBRecordStore and related classes.A cache for
FDBRecordStoreStateCacheEntry objects.Information needed to initialize an
FDBRecordStore that is not stored within the record store's
RecordMetaData.A factory interface for
FDBRecordStoreStateCaches.Class representing a specific version within FDB.
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.
A persistent cache providing reverse lookup facilities from the FDB
DirectoryLayer.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.A record stored in the database.
A builder for
FDBStoredRecord.Information about how a record is stored in the database.
A
StoreTimer associated with FDBRecordStore operations.An aggregate over other count events.
Standard
StoreTimer.Count events.Standard
StoreTimer.DetailEvents.Ordinary top-level events which surround a single body of code.
Standard
StoreTimer.Wait events.A record synthesized from stored records.
View of an FoundationDB database used for accessing system and special keys.
The FoundationDB native client can be configured to emit its trace logs (containing important
metrics and instrumentation information) in one of several different formats.
Wrapper class for an open FDB
Transaction.An enum indicating the priority of transactions against FoundationDB.
A type-safe record store.
A builder for
FDBTypedRecordStore.Class that provides context for asserting about a field value.
How an empty / unset repeated field should be handled.
Take keys from a record field.
A value representing the contents of a (non-repeated, arbitrarily-nested) field of a quantifier.
Helper class to hold information about a particular field access.
Deserializer.
A list of fields forming a path.
A resolved
FieldValue.Accessor that now also holds the resolved Type.A compensation that utilizes a field access.
A
QueryComponent that implements a Comparisons.Comparison against a field of the record.A property that counts the number of
FieldWithComparisons that appear in a planner expression tree.Provide various options for
FileSorter and FileSortCursor.Sort records in memory and / or in files, then return them in order.
Write sorted keyed values into
Files.A cursor that filters elements using a predicate.
A mask that can be applied over a
QueryComponent to determine whether a filter and any
sub-filters or child components have been satisfied.A substitution visitor that pushes a filter below a record fetch if all of the (non-repeated) field are available
in a covering scan.
A property that determines finds all occurrences of expressions of interest in a planner graph.
This class implements a
PredicatedMatcher which matches two sets of elements of type T to compute
an Iterable of AliasMaps.A value that returns the first element of the input array passed in.
Deserializer.
A cursor that maps elements to another cursor which is then flattened.
Accumulator state for Float types.
A rule that detects a value that evaluates to one constant value given the a set of aliases that are considered
being bound to constant objects.
A set of rules for simplifying
Value trees used to expression ordering constraints.The location where a deleted index used to live.
A value that produces a binary encoding that is comparable according to certain modes gives by
TupleOrdering.Direction.Deserializer.
The
FROM_ORDERED_BYTES_ASC_NULLS_FIRST function.The
FROM_ORDERED_BYTES_ASC_NULLS_LAST function.The
FROM_ORDERED_BYTES_DESC_NULLS_FIRST function.The
FROM_ORDERED_BYTES_DESC_NULLS_LAST function.A planner expression representing a full, unordered scan of the records by primary key, which is the logical version
of a
RecordQueryScanPlan with
ScanComparisons.EMPTY.A catalog of functions that provides
BuiltInFunctions.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.An implementation of a
Builder that can construct a KeyExpressionFunction
via a provided generator.A builder is capable of producing an instance of a
FunctionKeyExpression given the arguments
to the function.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.The
Registry maintains a mapping from a function name to a Builder capable of
producing an instance of the function.Names of core-supported query functions.
A cursor that returns a single element when a future completes.
Tag interface for generic matchers, that is instances of
ComputingMatcher.Exports a graph into a DOT file.
Class to abstract behavior when query expansion is applied to query components or key expressions.
Builder for
GraphExpansion.Exports a graph into a DOT file.
This class represents a cluster with the additional ability to further subdivide the cluster into sub-clusters.
Shorthand-type for the extended functional interface.
Shorthand-type for the extended functional interface.
Shorthand-type for the extended functional interface.
A logical
group by expression that represents grouping incoming tuples and aggregating each group.A key expression that divides into two parts for the sake of aggregate or rank indexing.
Utility class for hash functions.
A supplier of unique integers that tries to balance size of the integer and conflicts on the assignment.
A range of possible values to try.
A rule that matches a
AndPredicate (with the argument values).BiMap based on identities of types
K and V.A rule that matches a
OrPredicate (with the argument values).Check that
RecordCursorIterator.getContinuation() is only called when allowed.Immutable implementation of the
Pair interface.A rule that implements a
DeleteExpression by creating
a RecordQueryDeletePlan.A rule that implements a distinct expression by adding a
RecordQueryUnorderedPrimaryKeyDistinctPlan
if necessary.A rule that implements a distinct union of its (already implemented) children.
A rule that implements an explode expression as a
RecordQueryExplodePlan.A rule that implements a logical filter around a
RecordQueryPlan as a RecordQueryFilterPlan.A rule that implements a SELECT over a VALUES and a correlated subexpression as a
RecordQueryInUnionPlan.A rule that implements an
InsertExpression by creating
a RecordQueryInsertPlan.A rule that implements an intersection of its (already implemented) children.
A rule that implements a SELECT over a VALUES and a correlated subexpression as a
RecordQueryInUnionPlan.A rule that implements an existential nested loop join of its (already implemented) children.
A rule that converts a logical index scan expression to a
RecordQueryScanPlan.A rule that implements a
RecursiveUnionExpression.A rule that implements a select expression without predicates over a single partition as a
RecordQueryMapPlan.Rule for implementing logical
GROUP BY into a physical streaming aggregate operator RecordQueryStreamingAggregationPlan.A rule that implements a
TempTableInsertExpression producing a TempTableInsertPlan operator.A rule that implements a
TempTableScanExpression producing a TempTableScanPlan operator.A rule that implements a logical type filter on an (already implemented)
RecordQueryPlan as a
RecordQueryTypeFilterPlan.This rule implements
LogicalUniqueExpression by absorbing it if the inner reference is already distinct.A rule that implements an unordered union of its (already implemented) children.
A rule that implements an
UpdateExpression by creating
a RecordQueryUpdatePlan.Source of values for an "IN" query where the values are derived from the comparand of a
Comparison object.Deserializer.
A rule that traverses a predicate in a
SelectExpression and attempts to extract IN-comparisons into
separate ExplodeExpressions, e.g.Meta-data for a secondary index.
Tag interface for
AggregateValue that are backed by an aggregate index.Represents an index hint.
An aggregate function implemented by scanning an appropriate index.
Class to represent a construct
AGG by Set.of(col1, col2, ...).Helper class for extracting grouping keys from an
IndexAggregateFunction given query conditions.A class that contains the build progress of a given index in a given record store.
This is a simple PoJo hierarchy representing SerDe operations on a predicate comparison of a sparse
Index.A POJO equivalent for
Comparisons.NullComparison.A POJO equivalent for
Comparisons.SimpleComparison.The type of the comparison, this is a subset of
Comparisons.Type.Some store's indexes may need merging on some occasions.
During the deferred operation, each step should record its action.
A value representing the source of a value derivation.
Deserializer.
An
IndexEntry carries around the key and value read from an index (as the name would imply).Represents a value that references into an index entry in the bindings of
EvaluationContext by means of an
ordinal path (dewey id).Deserializer.
An indicator for the index fetch method to use for a query or an index scan.
Helper class for finding appropriate indexes for
IndexRecordFunction and IndexAggregateFunction.A base class for different types of online indexing process.
thrown when partly built by another method.
Thrown when the indexing process exceeds the time limit.
thrown if some or all of the indexes to build became readable (maybe by another process).
Thrown when the indexing process fails to meet a precondition.
This indexer scans records by a source index.
This indexer scans all records in the record store.
Shared data structure to be used (only) by the Indexing* modules.
Index and record types for indexing.
Implement an index merge.
This indexer scans records to build multiple indexes.
This indexer supports mutual concurrent multi-target indexing by multiple processes or hosts.
Wrapper around a
RangeSet class that binds the class with a specific transaction.Manifesto:
Scrub a readable index to validate its consistency.
Manifesto:
Scrub a readable index to validate its consistency.
This class provides build/commit/retry with throttling to the OnlineIndexer.
Construct a record from a covering index.
A builder for
IndexKeyValueToPartialRecord.Copy from an index entry into part of a record.
Copier for basic fields.
Deserializer.
Copier for fields that is based on some give
Value to do its work.Deserializer.
Copier for nested messages.
Deserializer.
Which side of the
IndexEntry to take a field from.Object responsible for translating record saves and deletes into updates to a secondary index.
A factory for
IndexMaintainer.A registry of
IndexMaintainers.A singleton
IndexMaintainerRegistry that finds IndexMaintainerFactory classes in the classpath.Common state for an
IndexMaintainer.A hook for suppressing secondary indexing of some records.
Whether to maintain a subset of the indexable values for the given record.
Represents a compile-time aggregation value that must be backed by an aggregation index, and can not be evaluated
at runtime by a streaming aggregation operator.
The
max_ever function.Class to represent
MAX_EVER(field) where field which can only be provided by a suitable index.Deserializer.
The
min_ever function.Class to represent
MIN_EVER(field) where field which can only be provided by a suitable index.Deserializer.
A maintenance operation on a secondary index.
The result of an
IndexOperation.The standard options for use with
Index.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.
This is a Plain old Java object (POJO) hierarchy representing SerDe operations on a predicate on an
Index.A POJO equivalent for
AndPredicate.a POJO equivalent for
ConstantPredicate.The constant to use.
A POJO equivalent of
NotPredicate.A POJO equivalent for
OrPredicate.A POJO equivalent of
ValuePredicate.Trait that plugs index predicate expansion utility methods into the consumer.
A
KeyValueCursor that scans an index using the IndexPrefetch operation.A Builder for the cursor.
A filter used to determine whether an index should be considered when planning queries.
A function which is applied to a record with the help of an index.
The bounds for an index scan.
ScanComparisons for use in an index scan.Deserializer.
The parameterized form of index scan bounds.
TupleRange for an index scan.The way in which an index should be scanned.
Scrub a readable index to validate its consistency.
Index Scrubbing Toolbox for a specific index maintainer.
The specific type of scrubbing.
Different states an index might be in within a given store.
The standard index types.
Validate an index according to the constraints of the index's type.
A registry of
IndexValidators.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.A substitution visitor that pushes a
RecordQueryInJoinPlan below a RecordQueryFetchFromPartialRecordPlan.A
Value that checks if the left child is in the list of values.Deserializer.
The
in function.Helper class which represents a specialized
InSource whose input is an outer binding (a parameter).Deserializer.
A logical version of
RecordQueryInsertPlan.Helper class to describe an IN-list for physical
RecordQueryInJoinPlans and RecordQueryInUnionPlans.A binding matcher that matches the same object as another
BindingMatcher.Wrapper around
Transaction that instruments certain calls to expose their behavior with
FDBStoreTimer metrics.Accumulator state for Integer types.
Interface to allow
RelationalExpressions to rewrite their own
internal graph representation.A cursor that implements an intersection of matching elements from a set of cursors all of whom are ordered compatibly.
A cursor that implements an intersection of matching elements from a set of cursors all of whom are ordered compatibly.
This visitor pulls index fetches after the intersection if possible.
A substitution visitor that pushes a
RecordQueryInJoinPlan below a RecordQueryFetchFromPartialRecordPlan.An invalid index entry including the entry and the reason why it is invalid.
The reason why an index entry is invalid.
The reasons supported in the Record Layer.
Helper class which represents a specialized
InSource whose input is a list of literal values.Deserializer.
Key expression representing an invertible function.
The isolation level for reads from the database.
Helper methods for
Iterables.A cursor that returns the elements of an ordinary synchronous iterator.
Represents a Java user-defined function.
A synthetic record type representing the indexable result of joining stored records.
An equi-join between constituent types.
A constituent type within a joined record type.
A builder for
JoinedRecordType.An equi-join between constituent types.
A constituent type within a joined record type.
Namespace for classes related to
KeyExpression construction and evaluation.Represents the list objects for a key in a secondary index or primary storage.
Values used in index keys in place of missing fields.
Holder class for the static methods for creating Key Expressions.
Hook for checking keys passed to a
Transaction.Wrapper around
Transaction that performs checks on keys passed to various operations.Wrapper around
Transaction that performs checks on keys passed to various operations.Comparators for key expressions.Interface for expressions that evaluate to keys.
Exception thrown when there is a problem deserializing a key expression.
How should repeated fields be handled.
Exception thrown when there is a problem with using a key expression in a certain context.
This is a runtime exception (i.e.
Exception thrown when a function key expression does not have an argument.
Exception thrown when there is a problem serializing a key expression.
Expansion visitor that implements the shared logic between primary scan data access and value index access.
Class that holds the state necessary to expand both primary data access as well as value indexes.
An interface to provide a state-based visitor pattern that can traverse a tree of
KeyExpressions.Tag interface to capture state within this visitor.
A
KeyExpression with exactly one child expression.A
KeyExpression with child expressions.A
KeyExpression with no children.A key expression that can be represented as a single
Value because it meets both of the following criteria:
It's a single value rather than a complex tuple.
It does not produce multiple values because of fan-out.
This is completely unrelated to the (disturbingly) similarly named KeyWithValueExpression.A range within a subspace specified by two byte value endpoints.
A
KeySpace defines a logical directory structure for keys that comprise an FDB row key.Count keys and resolve back to key space paths.
Defines a directory within a
KeySpace.The available data types for directories.
A
KeySpacePath represents a discrete path through a directory tree defined by a KeySpace.Helper class to make it easy to create
KeySpacePath wrapper implementations for use in
KeySpaceDirectory(String, KeySpaceDirectory.KeyType, Object, java.util.function.Function) (String, KeySpaceDirectory.KeyType, Object, Function)}.Resolve trees of key space paths and record store descendants.
The resolved interpretation of the node value.
Result of resolving a
Tuple into a KeySpaceTreeResolver.Resolved key space path or other
resolved element in the tree.A resolved index keyspace.
A resolved field of a record primary key or index key.
KeySpaceTreeResolver.ResolvedRoot with a prefix object.A resolved record store keyspace, such as records or indexes.
A resolved record type key prefix keyspace.
KeySpaceTreeResolver.Resolved to a KeySpace root.The basic cursor for scanning ranges of the FDB database.
A builder for
KeyValueCursor.The base class for cursors scanning ranges of the FDB database.
A builder for
KeyValueCursorBase.A formatter for log messages.
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.Wraps a future that supplies a record cursor.
Class to model the concept of a predicate.
A scalar value type that has children.
A rule that lifts the fields of a nested record constructor into the current record constructor.
A
Value that applies a like operator on its child expressions.Deserializer.
The
like operator.A map of items that uses reference equality to determine equivalence for the
purposes of set membership, rather than the
LinkedIdentityMap.equals(Object) method used by the Java Set interface.A set of items that uses reference equality to determine equivalence for the
purposes of set membership, rather than the
LinkedIdentitySet.equals(Object) method used by the Java Set interface.A cursor that returns the elements of a list.
Combine keys from zero or more child keys.
A collection matcher that binds a sub collection of the collection it is being matched by pairing up the items in the
collection (in iteration order) with a list of downstream matchers.
Expression to allow a static value to be utilized in a key expression.
A wrapper around a literal of the given type.
Deserializer.
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.Exception thrown when the locatable resolver is locked.
Tuple-based identifier used to locate a resource in the
LockRegistry.The
LockRegistry keeps track of locking over resources in the context of a single transaction.Subclass of TimeoutException with support for adding logging info in the form of keys and values.
A relational planner expression representing a stream of distinct records.
A relational planner expression that represents an unimplemented filter on the records produced by its inner
relational planner expression.
A query plan that executes by taking the union of records from two or more compatibly-sorted child plans.
A relational planner expression that projects its input values.
A relational planner expression that represents an unimplemented sort on the records produced by its inner
relational planner expression.
A relational planner expression that represents an unimplemented type filter on the records produced by its inner
relational planner expression.
A relational planner expression that represents an unimplemented union of its children.
A relational planner expression representing a stream of unique records.
Common
KeyValueLogMessage keys logged by the Record Layer core.Function key expression representing evaluating arithmetic functions on
longs.Builder for
LongArithmethicFunctionKeyExpressions.Factory for constructing built-in arithmetic functions that operate on
longs.Accumulator state for Long types.
Deprecated.
MappedPool Class Attempts to reuse objects organized by keys.
Function with Exceptions to provide the pool.
A cursor that applies an asynchronous function to the elements of another cursor.
A cursor that applies a function to the elements of another cursor.
Utility functions for manipulating maps.
A
RecordCursor that calls a function that maps the value and can stop the cursor.What to return for
RecordCursorResult.getContinuation() after stopping.A relational planner expression that represents an unimplemented sort on the records produced by its inner
relational planner expression.
Class to used to accumulate the individual match results (the results of applying the
MatchFunction) into
an object of type R.Interface to represent a match candidate.
A rule that matches any
Value (with the argument values) that is a constant expression.A rule that matches a
QuantifiedObjectValue (with the argument values).A rule that matches a
FieldValue over another FieldValue to simplify into
one FieldValue using a concatenated accessor path.An functional interface for a match function that computes a match result (an
Iterable of type M.This interface represents the result of matching one expression against an expression from a
MatchCandidate.Builder for an adjusted
MatchInfo.Implementation of
MatchInfo that represents a match between two expressions.Expression-based transformation rule that matches any non-leaf expression (called an intermediate expression)
to a candidate expression in a
MatchCandidate.Partial match with a quantifier pulled up along with the partial match during matching.
Expression-based transformation rule that matches any leaf expression.
A rule that matches a
FieldValue (with the argument values).Case class to represent a partition of partial matches.
Matchers for
MatchPartition.An predicate that tests for a match between quantifiers also taking into account an equivalence maps between
CorrelationIdentifiers.A rule that matches any simple
FieldValue, i.e.A rule that matches a
Value against the current QuantifiedObjectValue.A rule that matches a
Value (with the argument values).A set of rules for use by the maximum map computation logic.
A memoization interface.
Builder for references.
Collect keyed values into a
LinkedHashMap so that they end up sorted in insertion order.Collect keyed values into an in-memory data structure.
How the
getMaxRecordCountInMemory is interpreted for MemoryScratchpad.load(com.apple.foundationdb.record.RecordCursor<V>, K).Provide various options for
MemorySorter and MemorySortCursor.Stateful comparator supporting insertion order and delegating to a regular
Comparator to establish
equality between the minimum key and a probe.An extended version of a comparator that can be stateful.
Stateful comparator to support orderings based on regular comparisons delegated to a
Comparator.Sort records in memory up to a specified limit, then return them in order.
Collect keyed values into a
TreeMap so that they end up sorted.An abstract class that corresponds to some kind of cursor merging multiple children together.
Common code for handling the continuations of
MergeCursors.A holder for mutable state needed to track one of the children cursors of some merge operation.
A rule that merges a fetch into a covering index scan.
A rule that removes a
LogicalProjectionExpression and a RecordQueryFetchFromPartialRecordPlan
if all fields needed by the projection are already available prior to the fetch.Serialize records using default Protobuf serialization using the supplied message builder for the union message type.
Base class for record serializers that use a supplied union message builder method reference to reconstruct records.
A utility class for extracting data and meta-data from Protocol Buffer
Messages, as used in the Record Layer.Coercion (bi)-function which also is plan hashable.
Trie data structure of
Type.Record.Fields to conversion functions used to coerce an object of a certain type into
an object of another type.Trie data structure of
Type.Record.Fields to Values.A caching hook for
FDBMetaDataStore.This class can be used to validate that the new meta-data for a record store is responsibly evolved from its
existing meta-data.
A builder class for the
MetaDataEvolutionValidator.Exception thrown when there is a problem with something in the
RecordMetaDataProto.MetaData.A
PlanContext where the underlying meta-data comes from RecordMetaData and RecordStoreState
objects, as is generally the case when planning actual queries.A helper class for mutating the meta-data proto.
An exception that is thrown if the type of a field is ambiguous.
Validator for
RecordMetaData.An implementation of the
FDBRecordStoreStateCache that uses the database's
meta-data version-stamp key as the
cache invalidation key.A factory for creating
MetaDataVersionStampStoreStateCaches.Key checker that reports when operations are not limited to a single tuple subspace of a given minimum size.
A key prefix and associated check settings.
Helper functions for index maintainers that use a
RTree.Instrumentation events specific to R-tree index maintenance.
An index maintainer for keeping a
RTree.A factory for
MultidimensionalIndexMaintainer indexes.IndexScanBounds for a multidimensional index scan.Scan bounds that consists of other
MultidimensionalIndexScanBounds.SpatialPredicates to form a logical AND.Scan bounds describing an n-dimensional hypercube.
Scan bounds that consists of other
MultidimensionalIndexScanBounds.SpatialPredicates to form a logical OR.Spatial predicate.
ScanComparisons for use in a multidimensional index scan.Deserializer.
A multi matcher is a
CollectionMatcher and by extension also a BindingMatcher that binds to a sub
collection of objects in the presented collection.A multi matcher that binds to all objects in the collection it is being matched or it does not match anything at all,
i.e.
A multi matcher that binds a sub collection of objects of the collection it is being matched.
A record store that can be modified to reflect changes made to the database.
Narrow-able trait that can safely downcast to a particular implementation.
A
QueryComponent that evaluates a nested component against a Message-valued field.Extension of record type representing a nested message within a larger record type.
Builder class for
NestedRecordTypes.A key expression within a nested subrecord.
NodeIcon Ids.
Explanatory information about the Record Layer's plan operators and storage objects.
A
Pair implementation where both elements are not null.An index maintainer that doesn't do anything.
A factory for
NoOpIndexMaintainer indexes.A rule that transforms a boolean expression into a normal form.
This property collects a
QueryPredicate that represents the entirety of all accumulated residual predicates.Rule to create the conjunctive normal form of the predicates in a
SelectExpression.Exception thrown when a
KeySpaceDirectory does not have the named directory component.A
QueryComponent that is satisfied when its child component is not satisfied.Matcher that matches the current object if its downstream was unable to match and vice versa.
A rule that matches a
NotPredicate (with the argument values) and attempts to push it into a boolean variable
underneath (which can be a comparison).A
QueryPredicate that is satisfied when its child component is not satisfied.Deserializer.
A value that flips the output of its boolean child.
Deserializer.
The
not function.A Utils class that holds logic related to nullable arrays.
A value that evaluates to empty.
Deserializer.
Aggregation over numeric values.
Average aggregation
Value.Deserializer.
The
avg function.Bitmap aggregation
Value.Deserializer.
The
bitmap function.Max aggregation
Value.Deserializer.
The
max function.Min aggregation
Value.Deserializer.
The
min function.Accumulator for aggregation using a type- and function-specific operator.
The function- x type-specific numeric aggregator.
Sum aggregation
Value.Deserializer.
The
sum function.This class implements a planHash for the member classes of the query plan.
A
Value representing any object.Deserializer.
Checks whether a
Value's evaluation conforms to its result type.Deserializer.
Class for matching any value of a repeated field.
A
QueryComponent that evaluates a Comparisons.Comparison against each of the values of a repeated field and is satisfied if any of those are.A
QueryComponent that evaluates a nested component against each of the values of a repeated field and is satisfied if any of those are.Builds an index online, i.e., concurrently with other database operations.
Builder for
OnlineIndexer.A builder for the indexing policy.
Builder for
OnlineIndexer.IndexingPolicy.Possible actions when an index is already partially built.
Possible conversion from one indexing method to another.
This defines in which situations the index should be built.
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.Base class that the
OnlineIndexer.Builder and the OnlineIndexScrubber.Builder can both inherit
from.A holder for the mutable configuration parameters needed to rebuild an online index.
A builder for
OnlineIndexOperationConfig.Scan indexes for problems and optionally report or repair.
Builder for
OnlineIndexScrubber.A builder for the scrubbing policy.
Builder for
OnlineIndexScrubber.ScrubbingPolicy.A matcher that matches an optional if the object is present.
A
QueryComponent that is satisfied when any of its child components is satisfied.A value that produces a binary encoding that is comparable according to certain modes gives by
TupleOrdering.Direction.ORDER_xxx function.Factory for
OrderFunctionKeyExpression for each supported direction.This class captures an ordering property.
A helper class used inside an
Ordering to indicate if a value is considered to be ascending, descending,
or fixed to a comparison/a set of comparisons (which have to be of type ComparisonRange.Type.EQUALITY).Interface that declares that all instances of the implementing class are directly order-preserving.
TODO.
Interface that declares that all instances of the implementing class are inverse order-preserving.
Merge operator for orderings.
Enum to differentiate the different kinds of preserving order.
Interface that declares that this
Value preserves the order of the input value in some way.Abstract static class that represents an ordering that is produced by an ordered set operation such as a union or
intersection operation prior to the application of a comparison key.
TODO.
A class that is used to express ordered-ness.
An
OrderingPart that is bound by a comparison during graph matching.Sort order that can be assigned during index matching.
Functional interface to be used to create instances of a particular kind of
OrderingPart.Final class to tag provided ordering parts and to seal
OrderingPart.Enum implementing
OrderingPart.SortOrder that provides sort orders that for instance a plan can provide to
downstream operators.Final class to tag requested ordering parts and to seal
OrderingPart.Sort order used to model requested orderings, that is orderings that a down stream operator or the client
requires the result set of the upstream operator to adhere to.
A common interface all sort orders have to implement.
A property used for the ordering(s) of a plan.
A property that determines the ordering of a
RecordQueryPlan.A set of rules for simplifying
Value trees used to expression ordering constraints.Handle
OrderFunctionKeyExpression in a query.A cursor that returns the elements of one cursor followed by the elements of another cursor if the first was empty.
A
QueryPredicate that is satisfied when any of its child components is satisfied.Deserializer.
A simple interface for pairs of two elements.
A class to keep track of the relationships of parameters in a query given a
RecordQuery and a set of
pre-bindings.A relationship between two parameter values.
The type of
ParameterRelationshipGraph.Relationship.A class to represent partially ordered set of elements of some type.
Builder for
PartiallyOrderedSet.A class allowing to compute a subset of elements in a partial order that are said to be eligible.
Case class to represent a partial match.
Matchers of
PartialMatch.A rule that splits a
SelectExpression into a new upper and two lower SelectExpression
that can absorb predicates which may prove advantageous for the implementation rules.A rule that splits a
SelectExpression into two SelectExpressions .An implementation of the
FDBRecordStoreStateCache interface that does not actually cache anything.A factory for creating
PassThroughRecordStoreStateCaches.A class to represent the value stored at a particular element of a
KeySpacePath.A
Value that applies a like operator on its child expressions.Deserializer.
The
patternForLike operator.An index that maintains an extremum value in a way that can be enumerated by that value rather than by group.
A factory for
PermutedMinMaxIndexMaintainer indexes.A value representing multiple "alternative" values.
Deserializer.
Kind of asynchronous pipelined operation being performed.
A Placeholder is basically a
PredicateWithValueAndRanges with an alias that is used solely used for index matching.A basic context object that stores all of the metadata about a record store, such as the available indexes.
Interface that needs to be implemented separately for every class that is
PlanSerializable.A more stable version of
Object.hashCode().The "kinds" of planHash calculations.
A mode for a plan hash which captures both kind and version.
A wrapper class to identify groups of that behave the same way from the perspective of the planner.
A map-like structure that supports a map from a binding to a collection of objects, such as
RelationalExpressions and References.A mutable builder for a set of
PlannerBindings which can be used to incrementally build up a set of
bindings without repeatedly calling PlannerBindings.mergedWith(PlannerBindings), which is less efficient.Base interface to capture constraints for the planner.
Lightweight class to save some boilerplate.
Node class for data objects.
Edge class.
Edge class for existential quantifiers.
Edge class for for-each quantifiers.
Specific builder for explain planner graph building.
Node class for logical operators.
Node class for logical operators that also have a
NodeInfo.Node class for logical operators that also have a
NodeInfo.Node class for actual plan operators.
Edge class for modification (delete, insert, update) targets.
Node class functioning as parent for any nodes in the network.
Node class that additionally captures a reference to a
NodeInfo.Node class for actual plan operators.
Edge class for matches that connect a query reference to a match candidate reference.
Edge class for physical quantifiers.
Edge class for
Reference.Node class for
References -- head.Edge class for
Reference.Node class for
Reference - member.Node class for temporary data objects.
Interface to be implemented by all node classes that represent an
RelationalExpression.Interface to be implemented by all node classes that need to externalize an info id for exporting global
information such as names and descriptions.
Class to hold a graph for explain, optimization, and rewrite purposes.
Class to represent an actual sub cluster of inside the planner graph.
Interface to allow
RelationalExpressions to rewrite their own
graph representation.Basic rule interface.
Marker interface for rules that run in pre-order.
A
PlannerRuleCall is a context object that supports a single application of a rule to a particular
expression.A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
The keys that order the results from a plan.
A plan partition used for matching.
Base interface to capture attributes for plans.
A plan selector selects one plan from the given list via some policy.
Base interface to indicate that a java class is reachable through a
RecordQueryPlan and therefore needs to be capable of
serialization/deserialization.Class to facilitate serialization and deserialization of
RecordQueryPlans.Context class defining the state of serialization/deserialization currently in-flight.
Plugin interface to be used by the plan serialization framework to dispatch serialization/deserialiation
invocations properly.
A plan that knows its own {#link PlanOrderingKey}.
A plan that has some, but not all, stored fields.
Tag interface for predicate matchers, that is instances of
FindingMatcher.Predicate map that enforces a constraint that a predicate can only be mapped to at most one candidate.
Builder class for a predicate maps.
Builder class for a predicate maps.
Functional interface to reapply a predicate if necessary.
Functional interface to reapply a predicate if necessary.
Mapping class.
Builder class for
PredicateMultiMap.PredicateMapping.Class to capture the relationship between query predicate and candidate predicate.
Kind of mapping.
Functional interface to finally adjust the shape of the records returned by the index/match.
Transform a
SelectExpression with a set of QueryPredicates into a union operation.Tag interface to announce that the implementing class can provide
Comparisons.Comparisons upon request.A predicate consisting of a
Value.This class associates a
Value with a set of range constraints (RangeConstraints).Deserializer.
An iterator that accesses all elements of a
TreeLike object in pre-order fashion.A formatter for tokens.
Utility class that encapsulates ANSI escape sequences
for colors.
Class to expand primary data access into a candidate.
Represents reading a table directly without using an index plus fetch.
The primary key property that computes the primary key of a sub graph if it exists.
Planner property which indicates if the record flowed as the result of a
RecordQueryPlan flows things stored records flow,
e.g.A logical version of
RecordQueryScanPlan.Case class to represent a match candidate that is backed by an index.
The types of accumulation operations allowed for a primitive accumulator.
Binding matchers (
BindingMatcher) for primitive types.A cursor that returns all results that are probably in all of its children.
A value that promotes an object of a type to an object of another type.
Coercion function for arrays.
Deserializer.
Deserializer.
A coercion function for primitive types.
Deserializer.
Class to manage properties for plans.
Represents a three-valued logic operation.
A interface indicating whether a given type can be serialized into a ProtoBuf
Message.Utility functions for interacting with protobuf.
A dynamic enum when we don't want to worry about actual enum structures/descriptors etc.
Chain to pull up
Value trees through a series of relational expressions.A rewrite rule that splits a
SelectExpression expression that ranges over a child with a Quantifier
that has null-on-empty semantics into two parts:
a lower SelectExpression expression that ranges over the old child with a normal Quantifier,
i.e.A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
A rule that moves a
RecordQueryUnorderedPrimaryKeyDistinctPlan
below a RecordQueryFilterPlan.A rule that pushes a
RecordQueryUnorderedPrimaryKeyDistinctPlan through a
RecordQueryFetchFromPartialRecordPlan in order to reduce the number of records
prior to a potentially expensive fetch operation.A rule that pushes a set of predicates that can be evaluated on a partial record of keys and values that were
retrieved by an index scan underneath a
RecordQueryFetchFromPartialRecordPlan in order to filter out records
not satisfying the pushed predicates prior to a potentially expensive fetch operation.A rule that pushes a
RecordQueryInJoinPlan through a RecordQueryFetchFromPartialRecordPlan.A rule that pushes a map expression containing a
Value that can be evaluated on a partial record of keys and
values that were retrieved by an index scan underneath a RecordQueryFetchFromPartialRecordPlan in order to
eliminate the fetch altogether.A rule that pushes a
ReferencedFieldsConstraint through a LogicalDistinctExpression.A rule that pushes a
ReferencedFieldsConstraint through a LogicalFilterExpression.A rule that pushes a
ReferencedFieldsConstraint through a SelectExpression.A rule that pushes a
ReferencedFieldsConstraint through a LogicalUniqueExpression.A rule that pushes an ordering
RequestedOrderingConstraint through a DeleteExpression.A rule that pushes an
RequestedOrderingConstraint through a LogicalDistinctExpression.Rule that passes sorting requirements from
GROUP BY expression downstream.A rule that pushes an
RequestedOrderingConstraint through a specific SelectExpression.A rule that pushes an ordering
RequestedOrderingConstraint through an InsertExpression.A rule that pushes an ordering
RequestedOrderingConstraint through an TempTableInsertExpression.A rule that pushes an ordering
RequestedOrderingConstraint through a RecursiveUnionExpression.A rule that pushes a
ReferencedFieldsConstraint through a SelectExpression.A rule that pushes a
ReferencedFieldsConstraint through a SelectExpression.A rule that pushes an ordering
RequestedOrderingConstraint through a LogicalSortExpression.A rule that pushes an ordering
RequestedOrderingConstraint through a LogicalUnionExpression.A rule that pushes an
RequestedOrderingConstraint through a LogicalUniqueExpression.A rule that pushes an ordering
RequestedOrderingConstraint through an UpdateExpression.A (prototype) rule that pushes a set operation (e.g.
A rule that moves a
RecordQueryTypeFilterPlan below a RecordQueryFilterPlan.A value representing the quantifier as an object.
Deserializer.
A value representing the quantifier as an object.
Deserializer.
A scalar value type that is directly derived from an alias.
Models the concept of quantification.
Builder class for quantifiers.
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.
Builder subclass for existential quantifiers.
A quantifier that conceptually flows one item at a time from the expression it ranges over to
the owning expression.
Builder subclass to build for-each quantifiers.
Physical quantifier.
Builder subclass for physical quantifiers.
Matchers for
Quantifiers.Auxiliary class containing factory methods and helpers for
Quantifier.Resolver to resolve aliases to quantifiers.
A value representing the source of a value derivation.
Deserializer.
Holder class for creating querying expressions.
Exception thrown when a query expression is not valid in some context.
A
KeyExpression that can be used with a QueryKeyExpressionWithComparison.Base component interface for checking whether a given record matches a query.
Query hash - calculate and return identifying hash values for queries.
The "kinds" of queryHash calculations.
Allow use of a
QueryableKeyExpression in a query.A
QueryComponent that implements a Comparisons.Comparison against a multi-valued QueryableKeyExpression.An executable query plan.
Represents a query plan constraint.
This class holds some additional information regarding the query plan that can be attached to the plan itself, without
impacting its structure.
A Builder for the
QueryPlanInfo class.An implementation of a type-safe Enum.
Container for
QueryPlanInfo.QueryPlanInfoKey static instances used in the planner.A common interface for classes that can plan a
RecordQuery into a RecordQueryPlan.Preference between index scan and record scan.
The result of planning a query.
Utility class for query planning.
Class to model the concept of a predicate.
Intermediate class that fixes the type of the
PlannerRuleCall.A rule call implementation for the computation of a result while traversing
QueryPredicate trees.A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
A
BindingMatcher is an expression that can be matched against a
RelationalExpression tree, while binding certain expressions/references in the tree to expression matcher objects.A scalar value type that has children.
A set of rules for use by a planner that supports quickly finding rules that could match a given
QueryPredicate.A set of rules for use by a planner that supports quickly finding rules that could match a given
QueryPredicate.Class that provides context for asserting about a specially calculated value.
A
Comparisons.Comparison whose value from the record,
to be compared with the comparison's value, is the result of applying a RecordFunction to the record.QueryResult is the general result that encapsulates the data that is flowed up from plan to plan as well as from
plan to consumer.
Match a query filter, represented by a
QueryComponent, to a KeyExpression.The result of matching a particular
KeyExpression.Whether a match was a successful, and if it was, whether the resulting keys have a single value.
Represents a compile-time range that can be evaluated against other compile-time ranges with an optional list
of deferred ranges that cannot be evaluated at compile-time but can still be used as scan index prefix.
Builds an instance of
RangeConstraints.Represents a range that comprises an intersection of a set of
Comparisons.Comparison with reference operands
(i.e.A cursor that returns a sequence from 0 to an (exclusive) limit.
Track comparisons involving rank-type functions.
A single rank function comparison.
Known hash functions available as index options.
Helper functions for index maintainers that use a
RankedSet.Instrumentation events specific to rank index maintenance.
A
RankedSet that adds StoreTimer instrumentation.An index maintainer for keeping a
RankedSet of record field values.A factory for
RankIndexMaintainer indexes.A windowed value that computes the RANK of a list of expressions which can optionally be partitioned by expressions
defining a window.
Deserializer.
An implementation of the
FDBRecordStoreStateCache that uses the read-version of the associated transaction
as the cache invalidation key.A factory for creating
ReadVersionRecordStoreStateCaches.Exception thrown when
FDBRecordStoreBase.insertRecord(M) is called, but the record already exists.Deserializer.
The
record function.Functional equivalent of
IllegalArgumentException.An exception thrown by the core of the Record Layer.
Functional equivalent of
InterruptedException.An exception from transaction processing that ought to be retried.
Exceptions due to problems with the state of or connection to a particular record store.
An asynchronous iterator that supports continuations.
Transformation to apply to a continuation.
The reason that
RecordCursorResult.hasNext() returned false.An interface for types that represent the continuation of a
RecordCursor.A concrete continuation representing that a
RecordCursor has returned all of the records that it ever will.An asynchronous iterator that wraps a
RecordCursor and presents an iterator-style interface for advancing
the cursor.A result obtained when a
RecordCursor advances.An exception thrown when
RecordCursorResult.getNoNextReason() is called on a result that has a next value.An exception thrown when
RecordCursorResult.get() is called on a result without a next value.A continuation representing the start of a cursor's execution.
A hierarchical visitor for record cursor trees designed mostly to allow tests to gather information without adding
invasive query methods to the
RecordCursor interface.Exception thrown when
FDBRecordStoreBase.updateRecord(M) is called, but the record does not exist yet.A function to be applied to a record as part of query execution.
An exception thrown when there is an attempt to store a duplicate value in a unique index.
A key for a property that adopter configures for Record Layer.
Adopter can use this mapping of
RecordLayerPropertyKeys to RecordLayerPropertyValues to configure Record Layer parameters.Builder for
RecordLayerPropertyStorage.A value and its associated
RecordLayerPropertyKey for a property that adopter configures for Record Layer.Meta-data for Record Layer record stores.
A builder for
RecordMetaData.Exception thrown when meta-data cannot be loaded from serialized form.
A source of
RecordMetaData.The logical form of a query.
A builder for
RecordQuery.A query plan that performs transformations on the incoming record according to a set of transformation instructions
in conjunction with a target
Type and a target Descriptors.Descriptor which both
together define a set of instructions for type promotion and for protobuf coercion.A query plan that reconstructs records from the entries in an aggregate index.
Deserializer.
A
RecordQueryChooserPlanBase is a plan that, at runtime, chooses to execute plans from multiple alternatives.A
RecordQueryChooserPlanBase that executes all child plans and compares their results using the provided
comparison key.A query plan that reconstructs records from the entries in a covering index.
Deserializer.
A query plan implementing a dam in-memory.
Deserializer.
A query plan that only flows all the records it processes from its inner.
Deserializer.
A query plan that deletes records.
Deserializer.
A query plan that applies the values it contains over the incoming ones.
Deserializer.
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.Deserializer.
Enum to govern how to interpret the primary key of an index entry when accessing its base record(s).
The function to apply.
A query plan that filters out records from a child plan that do not satisfy a filter component.
A base class for all query plans that filter based on predicates.
A query plan that only flows the first record it processes from its inner and then stops.
Deserializer.
A query plan that applies the values it contains over the incoming ones.
Deserializer.
A query plan that executes a child plan once for each of the elements extracted from a
Comparison object's
comparand.Deserializer.
A query plan that outputs records pointed to by entries in a secondary index within some range.
Deserializer.
A query plan that executes a child plan once for each of the elements of some
IN list.A query plan that executes a child plan once for each of the elements of an
IN list taken from a parameter.Deserializer.
A query plan that inserts records into the database.
Deserializer.
Intersection plan that compares using a
KeyExpression.Deserializer.
Intersection plan that compares using a
Value.Deserializer.
A query plan that executes by taking the union of records from two or more compatibly-sorted child plans.
Union plan that compares using a
KeyExpression.Deserializer.
Union plan that compares using a
Value.Deserializer.
A query plan that executes union over instantiations of a child plan for each of the elements of some
IN list(s).A query plan that executes a child plan once for each of the elements of a constant
IN list.Deserializer.
A query plan that returns records whose primary keys are taken from some list.
A source for the primary keys for records.
A query plan that applies the values it contains over the incoming ones.
Deserializer.
An executable query plan for producing records.
Exception thrown when a query plan is more complex than the configured limit.
Matchers for descendants of
RecordQueryPlan.The query planner.
A set of configuration options for the
RecordQueryPlanner.A builder for
RecordQueryPlannerConfiguration.Configuration for planning of non-index sort queries.
Visitor interface for performing substitution-type rules on
RecordQueryPlans.A query plan with a single child plan.
A query plan with child plans.
Interface to be implemented by plans that provide comparison key values.
A query plan that uses
ScanComparisons or Comparisons.Comparison to drive some scan of
the record store.Mixin for a
RecordQueryPlan that has a QueryPlanConstraint.Interface for plans in downstream modules to implement explain functionality.
A query plan that uses a single index.
A query plan that was created using a
MatchCandidate to match a physical access path.A query plan that does not have any child plans.
A query plan that filters out records from a child plan that do not satisfy a
QueryPredicate.Deserializer.
A query plan that produced a stream of integers for
0(inclusive) to some limit (exclusive).Deserializer.
A physical representation of a recursive union.
Deserializer of
RecordQueryRecursiveUnionPlan.A query plan that scans records directly from the main tree within a range of primary keys.
Deserializer.
A query plan that converts ranks to scores and executes a child plan with the conversion results bound in named parameters.
Deserializer.
A single conversion of a rank to a score to be bound to some name.
A
RecordQueryChooserPlanBase that selects one of its children to be executed.Interface for query plans that represent set-based operators such as union or intersection.
A comparison key function that extracts a comparison key for binary comparison by some set operations which
also provides a stable plan hash and hash code.
Class to encapsulate the functionality of extracting a comparison key from a
QueryResult while
also providing comparability and the ability to compute a stable plan hash.Deserializer.
Class to encapsulate the functionality of extracting a comparison key from a
QueryResult while
also providing comparability and the ability to compute a stable plan hash.Deserializer.
Defines, logically, how
RecordQuerySortPlan should sort the records.A query plan implementing sorting in-memory, possibly spilling to disk.
Deserializer.
A query plan that applies an aggregate function(s) to its inputs and also places them into groups.
Deserializer.
A query plan that can scan text indexes.
A query plan that filters out records from a child plan that are not of the designated record type(s).
Deserializer.
Union plan that compares using a
KeyExpression.Deserializer.
Union plan that compares using a
Value.Deserializer.
A query plan that executes by taking the union of records from two or more compatibly-sorted child plans.
Common base class for plans that perform stream union operations.
A query plan that removes duplicates by means of a hash table of previously seen values.
Deserializer.
A query plan that removes duplicates by means of a hash table of primary keys already seen.
Deserializer.
A query plan that returns results from two-or-more cursors as they as ready.
Deserializer.
A query plan that updates records in the database using a stream of incoming records, that are transformed according
to a transformation map, then coerced into a target type, and then saved using
FDBRecordStoreBase.saveRecord(Message).Deserializer.
Track number of records scanned up to some limit, after which record scans should not be allowed.
A factory that produces implementations of
RecordScanLimiters.Exception thrown when there is a problem serializing or deserializing a record.
Exception class thrown by
RecordSerializer.validateSerialization(RecordMetaData, RecordType, Message, byte[], StoreTimer).A converter between a Protobuf record and a byte string stored in one or more values in the FDB key-value store.
Instrumentation counts related to record serialization.
Instrumentation events related to record serialization.
Exception thrown when
FDBRecordStoreBase.BaseBuilder.create() is called, but the record store already exists.Exception thrown when
FDBRecordStoreBase.BaseBuilder.open() is called, but the record store does not exist yet.Exception thrown when
FDBRecordStoreBase.BaseBuilder.createOrOpen() is called, and the record store does
not have a store info header, but does have something else.Exception thrown when the record store has a newer meta-data version than the one from the given
RecordMetaDataProvider.Exception thrown when the record store has a newer user version than the one from the given
FDBRecordStoreBase.UserVersionChecker.The
RecordStoreState interface handles information that might differ between otherwise identical
record stores.Record type meta-data.
A builder for
RecordType.Exception thrown when a
RecordTypeBuilder is not yet in a state where it can be built.Exception thrown when
FDBRecordStoreBase.updateRecord(M) is called, but the existing record has a different record type.A base builder for
RecordType.A
QueryComponent that implements checking for a given record type.Equality comparison to check for records of a particular record type.
Deserializer.
A key expression that indicates that a unique record type identifier should
be contained within the key.
Common interface implemented by the
RecordType and RecordTypeBuilder
classes that contains accessors that they are both expected to have.A property visitor that determines the set of record type names (as Strings) that a
RelationalExpression
could produce.A value which is unique for each record type produced by its quantifier.
Deserializer.
A cursor that repeatedly executes its children until reaching a fix-point.
Continuation that captures the state of execution of a
RecursiveUnionCursor that is orchestrated by
RecordQueryRecursiveUnionPlan through a RecursiveUnionCursor.RecursiveStateManager.Interface for recursive state management, the caller is expected to invoke respective callbacks when certain
events occur so the internal state mutates accordingly, it also offers a set of methods that enable examining
current state and whether the execution can proceed to a subsequent recursive state or not.
This is a logical representation of a recursive union, a recursive union is similar to a normal unordered union, however
its legs have special execution semantics; just like a union, it returns the results verbatim of one particular
leg called the "initial state" leg.
The memo data structure can compactly represent a large set of similar
RelationalExpressions through
careful memoization.An exception thrown when
Reference.get() is called on a reference that does not support it,
such as a reference containing more than one expression.A constraint holding a set of referenced field values.
A set of referenced field values.
Matchers for
References.A utility class for printing out a
Reference in a readable form.Utility methods for
References.This property establishes a partial order over the expressions contained in a subgraph.
A relational expression is a
RelationalExpression that represents a stream of records.A functional interface to combine the matches computed over pairs of quantifiers during matching into a
result (for the bound correlatedTo set handed into
RelationalExpression.CombineFunction.combine(com.apple.foundationdb.record.query.plan.cascades.AliasMap, java.lang.Iterable<com.apple.foundationdb.record.query.plan.cascades.matching.graph.BoundMatch<com.apple.foundationdb.record.query.combinatorics.EnumeratingIterable<R>>>)).A functional interface to combine the matches computed over pairs of quantifiers during matching into a
boolean result (for the bound correlatedTo set handed into
RelationalExpression.CombinePredicate.combine(com.apple.foundationdb.record.query.plan.cascades.AliasMap, java.lang.Iterable<com.apple.foundationdb.record.query.plan.cascades.AliasMap>)).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.
Matchers for descendants of
RelationalExpression.A parent interface for
RelationalExpressions that have relational children (as opposed to non-relation
children, such as QueryComponents).Tag interface to signal that the children this expression owns, that is the owned
Quantifiers, are
to be treated as an unordered set.A (relational) expression that has a predicate on it.
A utility class to implement an algorithm to make a random selection based off of relative probabilities.
A
Value that returns the comparison result between its children.Binary rel ops.
Deserializer.
The
equals function.The
gte function.The
gt function.The
isNull function.The
lte function.The
lt function.The
notequals function.The
notNull function.Unary rel ops.
Deserializer.
A rule that removes a
LogicalProjectionExpression and if appropriate a RecordQueryFetchFromPartialRecordPlan
if all fields needed by the projection are already available prior to the fetch.A rule that implements a sort expression by removing this expression if appropriate.
This class captures a requested ordering.
Whether the ordered records are distinct.
A constraint requesting a set of sort orderings.
A set of rules for simplifying
Value trees used to expression ordering constraints.A
KeySpacePath that has been resolved into the value that will be physically stored to
represent the path element in the FDB keyspace.Set of hooks to be run only when creating a mapping in a
LocatableResolver.Functional interface for the safety check that will be run before writing a mapping in the
LocatableResolver.Functional interface for the safety check that will be run before writing a mapping in the
LocatableResolver.Encapsulates both the key and its resolved value from a
LocatableResolver.Computes a message digest for all of the string to integer mappings in the provided
LocatableResolver.Copies the contents of one
LocatableResolver to another.A class containing the result of resolving a key with
LocatableResolver.Validator that ensures that the resolver mappings are consistent with the reverse directory mappings.
Represents a bad/incorrect entry in the resolvers mapping.
The type of bad entry discovered when validating a
LocatableResolver's mappings.Tag-exception that is specifically thrown by implementations of
Debugger to signal the planner to restart
planning.A struct representing the result of an operation, containing either the return value or an error.
A cursor that limits the number of elements that it allows through.
Visitor that translates a
KeyExpression into a Value, keeping a state of the currently processed
input type while it is processing the KeyExpression.State class.
A set of
Comparisons.Comparison for scanning an index.A builder for
ScanComparisons.The type of a comparison.
Exception thrown when a transaction tries to scan more than the allowed number of key-value pairs.
An exception that can be thrown by
FDBRecordStores if they are scanning non-readable indexes.A group of properties that pertain to a single scan.
Interface to represent a candidate that replaces with an index scan.
Helper structure that allows us to precompute the mapping from index entry to the logical (partial record).
An implementation of
LocatableResolver that uses the FDB directory layer to keep track of the allocation of
strings to integers.An implementation of
LocatableResolver that is backed by the StringInterningLayer.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.
A rule that utilizes index matching information compiled by
CascadesPlanner to create one or more
expressions for data access specifically for a SelectExpression.A select expression.
Semantic exceptions that could occur e.g.
Semantic error codes.
A singleton that supports alternatives to
ServiceLoader, for example if you want to
use a dependency injection framework.A multi matcher that binds a sub collection of the collection it is being matched by pairing up the items in the
collection (in iteration order) with a list of downstream matchers.
Main class of a mini rewrite engine to simplify (or to compute over)
Value trees.Functional interface to create a specific rule call object.
A cursor that collects various distribution statistics on the keys and values within a record store or within
an index.
Encapsulates the distribution statistics returned by a SizeStatisticsCollectorCursor.
A cursor that skips a specified number of initial elements.
Read values from files written by
FileSorter.Variation of
InComparandSource where the values should be returned in a sorted order.Deserializer.
Helper class which represents a specialized
InSource whose input is an outer binding (a parameter).Deserializer.
Helper class which represents a specialized
InSource whose input is a list of literal values.Deserializer.
Serialize records during sorting, either in a continuation or in a file.
StoreTimer events related to sorting.Instrumentation counts related to sorting.
Events related to sorting.
Helper classes for splitting records across multiple key-value pairs.
Exception thrown when only part of a split record is found.
This cursor may exceed out-of-band limits in order to ensure that it only ever stops in between (split) records.
Unsplit a single record from a given range scan.
Accumulator for key-value sizes while loading / saving split records.
Turn a key with repeated single values into multiple
Key.Evaluated containing several of the values.A rule that splits a
SelectExpression into two SelectExpressions if one or more quantifiers this
expression owns satisfy the following criteria:
the quantifier is not correlated to any other quantifier in this SelectExpression
the quantifier ranges over a sub expression of limited cardinality.This is mostly a copy of
StandardMutableNetwork that delegates the construction of its underlying
connections to a class providing stable iteration order over them.Base class for
IndexMaintainer implementation.An attribute used to communicate to the planner that a plan flows instances of
FDBQueriedRecord (and its subclasses) which can only
represent records that reside stored on disk and were retrieved by this query.Planner property which indicates if the record flowed as the result of a
RecordQueryPlan flows things stored records flow,
e.g.Record function that should be evaluated for some record against
an
FDBRecordStoreBase instance.A
StoreTimer wrapping an underlying StoreTimer that accumulates the events
that are issued to it, as well as sending those events along to the underlying store timer.A context-wide accumulator of timing information.
An aggregate event is an event whose value is computed over the value of another set of events.
StoreTimer.Events that only count occurrences or total size.Contains the number of occurrences and cumulative time spent/cumulative value of all occurrences of the associated
StoreTimer.Event.StoreTimer.Events that are a significant part of a larger process.An identifier for occurrences that need to be timed.
StoreTimer.Events that count the number of occurrences of an operation and also the size of the operation.StoreTimer.Events that can be waited on.An immutable snapshot of a
StoreTimer.An immutable snapshot of a
StoreTimer.Counter.Tag interface used to mark
AggregateValue implementations that can be calculated by a
RecordQueryStreamingAggregationPlan operator.StreamGrouping breaks streams of records into groups, based on grouping criteria.
A persistent bidirectional unique mapping between strings and integers.
Subspace provider can provide a subspace (might be blocking) and logging information to the subspace (non-blocking).
A SubspaceProvider wrapping a key space path.
A SubspaceProvider wrapping a subspace.
An
FDBDatabaseRunner implementation that performs all work in the context of a
SynchronizedSession.A plan for deriving synthetic records from a given record.
A plan for generating synthetic records without an explicit starting point.
A planner for
SyntheticRecordPlan and SyntheticRecordFromStoredRecordPlan plans.A synthetic record type is made up of other record types and not actually stored separately in the record store.
A constituent type of the synthetic record type.
A builder for
SyntheticRecordType.A constituent type within a joined record type.
A mutable, temporary, serializable, and in-memory buffer of
QueryResults.Factory of
TempTable instances.A cursor that returns the items of a child cursor, and as a side effect, it adds the items to a designated
TempTable.A logical expression for inserting into a temporary memory buffer
TempTable.A query plan that inserts records into a temporary in-memory buffer
TempTable.Deserializer.
A logical expression for scanning from a table-valued
Bindings.Internal.CORRELATION
that can correspond to a temporary memory buffer, i.e.Scans records from a table-valued correlation, corresponding for example to a temporary in-memory buffer
TempTable.Deserializer.
Common
KeyValueLogMessage keys logged by the Record Layer core.Predicates that can be applied to a field that has been indexed with a full-text index.
An interface for locale-sensitive text comparison and sorting.
Standard strength values.
Registry for
TextCollators.A text collator registry using the Java Platform's own
Collator implementation.Serializer used by the
TextIndexMaintainer to write entries into a
BunchedMap.The index maintainer class for full-text indexes.
Supplier of
TextIndexMaintainers, that is, of index maintainers for the full text
index type.Encapsulate the information necessary to scan a text-based index.
A utility class for choosing a
TextScan object to satisfy a
text query.An interface to tokenize text fields.
Mode that can be used to alter tokenizer behavior depending on the
the context its used in.
Each implementation of
TextTokenizer should have its own implementation
of this factory interface to provide instances of the tokenizer to a
TextTokenizerRegistry.Registry for
TextTokenizers.Default implementation of the
TextTokenizerRegistry.Combine keys from two or more child keys.
A value that throws an exception if it gets executed.
Deserializer.
Track time remaining until a given time limit, after which record scans should not be allowed.
Evaluate aggregate functions in a certain time window.
Additional function arguments for time window.
A single leaderboard, representing ranks within a time window.
The persisted set of active leaderboard ranked sets.
Get the current directory.
Currently saved directory.
Maintainer for the
TIME_WINDOW_LEADERBOARD index type.Struct containing both the time window leaderboard entry and the rank.
Factory for the
TIME_WINDOW_LEADERBOARD index type.Save a subdirectory to specify direction.
Retain only scores that would be indexed by active time windows.
Scores that would be indexed by active time windows.
Persisted per-group information for leaderboard ranked sets.
Get a sub-directory, which presently only contains information about direction.
A sub-directory, which presently only contains information about direction.
Maintain active set of time windows.
When to completely rebuild an index.
A specification of a set of sliding time windows.
Result of
TimeWindowLeaderboardWindowUpdate.The
TIME_WINDOW_RANK record function.Extend
IndexScanComparisons to have TimeWindowForFunction.Deserializer.
Extend
IndexScanRange to have time window.A value that produces a binary encoding that is comparable according to certain modes gives by
TupleOrdering.Direction.Deserializer.
The
TO_ORDERED_BYTES_ASC_NULLS_FIRST function.The
TO_ORDERED_BYTES_ASC_NULLS_LAST function.The
TO_ORDERED_BYTES_DESC_NULLS_FIRST function.The
TO_ORDERED_BYTES_DESC_NULLS_LAST function.Utility class to provide helpers related to topological sorts.
A simple runner that can be used for opening and committing transactions, and making sure they are all closed.
A class that is notified of events that take place within the scope of a transaction, such as
when the transaction is created, committed, or closed.
A
RecordSerializer implementation that transforms the bytes produced
by another serializer before returning (and likewise performs the reverse
transformation before deserializing).Builder class for the
TransformedRecordSerializer class.An extension of
TransformedRecordSerializer to use JCE to encrypt and decrypt records.Builder class for the
TransformedRecordSerializerJCE class.Utility class to provide helpers related to the computation of the transitive closure of a partial order.
Interface for functions employed by
RecordQueryFetchFromPartialRecordPlan that are used to translate a value
by conceptually pushing it through that operation.Map used to specify translations.
Builder class for a translation map.
Functional interface to specify the translation to take place when a
QuantifiedValue is encountered.Utility class to provide a graph view of a expression reference DAG given by a root expression reference
(to a
RelationalExpression that allows to perform traversal operations that are normally not possible
on instances of Reference such as Traversal.getLeafReferences() and Traversal.getParentRefs(com.apple.foundationdb.record.query.plan.cascades.Reference).Case class to hold information about the path from an expression to another expression reference.
Interface for tree-like structures and helpers for folds and traversals on these tree-like structures of node type
TreeLike.Functional interface for a bi-function whose result is not nullable.
Functional interface for a function whose result is not nullable.
Basic trie implementation that stores values at the trie's leaves.
Basic trie implementation.
Basic trie builder implementation.
Represents a function that accepts three arguments and produces a result.
Static methods for dealing with special field types that are messages in protobuf but single items in
Tuples.A range within a subspace specified by two
Tuple endpoints.Exception thrown when range endpoint is not consistent with
CONTINUATION endpoint type.Provides type information about the output of an expression such as
Value in a QGM.Special
Type that is undefined.Deserializer.
Special
Type.Record that is undefined.Deserializer.
A type representing an array of elements sharing the same type.
Deserializer.
An enumeration type.
Deserializer.
A member value of an enumeration.
Interface for classes that can be erased, i.e.
The none type is an unresolved type meaning that an entity returning a none type should resolve the
type to a regular type as the runtime does not support a none-typed data producer.
Deserializer.
The null type is an unresolved type meaning that an entity returning a null type should resolve the
type to a regular type as the runtime does not support a null-typed data producer.
Deserializer.
A primitive type.
Deserializer.
A structured
Type that contains a list of Type.Record.Field types.Deserializer.
Represents a field type in a
Type.Record type.Represents a relational type.
Deserializer.
All supported
Types.Provides
Type information about result set.A
TypedMatcher matches a data structure that is at least of a certain type.A
TypedMatcher that also extracts an object from the current object and attempts to match that object with
a downstream matcher.A
TypeMatcherWithPredicate extends TypedMatcher in a way that it still only matches objects that
are at least of a certain type but that can be rejected by applying a given predicate to the object that is
attempted ot be matched.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.
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.A relational planner expression that represents a type filter.
A utility class that enables mapping of a structured
Type into a dynamically-generated equivalent Protobuf message
descriptor.A builder that builds a
TypeRepository object.This represents a user-defined function that can be subclassed to extend the planner with extra functionality.
This represents a user-defined
Value that can be subclassed to provide a custom implementation.Interface for the unapply function used in a variety of matchers.
Interface for the unapply function (also using a
RecordQueryPlannerConfiguration used in a variety of matchers.An exception that can be thrown by
FDBRecordStores if they are used before they have been properly
initialized.A cursor that implements a union of all the records from a set of cursors, all of whom are ordered compatibly.
This visitor pulls index fetches after the intersection if possible.
A property for counting the total number of
KeyExpression columns (i.e., field-like KeyExpressions
such as FieldKeyExpression and
RecordTypeKeyExpression) that are not matched with at
least one Comparisons.Comparison in a planner expression
tree.A synthetic record type representing an unnesting of some kind of
repeated, nested structure.
A
SyntheticRecordType.Constituent representing an element in an unnested record.Builder for creating
UnnestedRecordTypes.Builder variant of
UnnestedRecordTypeBuilder.NestedConstituent.This class moves the index fetch up from the index scan to after a distinct operation has been applied to the records.
A cursor that returns the results of two or more cursors that may return elements in any order.
Exception thrown when a record store has a format version in the database that is not supported by this codebase.
Exception thrown when a call is made for an API that is unsupported by the current
APIVersion.Exception thrown when remote fetch is attempted on an index that does not support remote fetch.
A logical version of
RecordQueryUpdatePlan.A property that computes the set of complex (dynamic) types that is used by the graph passed in.
Tag interface to provide a common base for all classes implementing a semantic equals using a
ValueEquivalence.A scalar value type.
A scalar value type that can only fetched from an index, that is the value cannot be fetched from the base record
nor can it be computed "on-the-fly".
A scalar
Value that can be inverted, i.e.Tag interface for marking a
Value that is non-deterministic, i.e.A scalar
Value that cannot be evaluated.A marker interface for
Values that can be used in the context of range construction, it must be evaluable
without being bound to an FDBRecordStoreBase.Functional interface to perform compensation for partially matched
Value-trees.Intermediate class that fixes the type of the
PlannerRuleCall.Functional interface whose
apply method is invoked after using the simplification's results.A rule call implementation for the computation of a result while traversing
Value trees.A set of rules for use by a planner that supports quickly finding rules that could match a given planner expression.
Holder class to easily transform simplification rules and their dependencies into computation rules and
their dependencies.
An interface (together with a set of specific final classes) that captures axiomatic (defined) equivalence between
Values.Equivalence that is being backed by an
AliasMap.Value equivalence implementation that relates bound constant references between
ConstantObjectValues to
LiteralValues.Helper equivalence to compose to equivalences.
Value equivalence based on a map of values.
Builder.
Class to expand value index access into a candidate graph.
Trait to implement some default logic for
MatchCandidates that are defined over value index-like
data structures such as PrimaryScanMatchCandidate and ValueIndexScanMatchCandidate.An index maintainer for an ordinary index by value, implementing ordered enumeration of records within a range of indexed values.
A factory for
ValueIndexMaintainer indexes.Case class to represent a match candidate that is backed by an index.
Index Scrubbing Toolbox for a Value index maintainer.
Index Scrubbing Toolbox for a Value index maintainer.
Matchers for descendants of
Value.A predicate consisting of a
Value and a Comparisons.Comparison.Deserializer.
A range defines the boundaries around a contiguous span of values of some type.
Helper class for dealing with
Values.Intermediate class that fixes the base type of the
AbstractRuleCall to be Value.A rule call implementation for the simplification of
Value trees.A scalar value type that has children.
A
Value that applies an arithmetic operation on its child expressions.The
coalesce function.Logical operator.
Deserializer.
The
greatest function.The
least function.Physical operators.
Implementation of
IndexMaintainer for the "version" index type.A factory for
VersionIndexMaintainer indexes.A key expression that indicates that a serialized
FDBRecordVersion should
be contained within the key.A value representing a version stamp derived from a quantifier.
Deserializer.
The
and function.Class to expand a by-rank index access into a candidate graph.
Case class to represent a match candidate that is backed by a windowed index such as a rank index.
A value merges the input messages given to it into an output message.
Trait for providing alias information.
Trait to implement some default logic for
MatchCandidates that are defined using a base quantifier, that is,
match candidates that are not true join indexes.Interface to represent a candidate that uses a primary key to identify a record.
Trait for classes containing a
Value.Use this as a way to use existing byte arrays when converting to ByteString for
protobuf conversion.
RecordCursor.map(java.util.function.Function<T, V>)orMapResultCursorinstead