All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary Annotation Types Summary
| Class |
Description |
| AbstractAllocatorMemtable |
A memtable that uses memory tracked and maybe allocated via a MemtableAllocator from a MemtablePool.
|
| AbstractAnalyzer |
|
| AbstractAnalyzer |
|
| AbstractAnalyzer.AnalyzerFactory |
|
| AbstractArrayClusteringPrefix |
|
| AbstractBlockPackedReader |
|
| AbstractBlockPackedWriter |
Modified copy of org.apache.lucene.util.packed.AbstractBlockPackedWriter to use DirectWriter for
optimised reads that doesn't require seeking through the whole file to open a thread-exclusive reader.
|
| AbstractBounds<T extends RingPosition<T>> |
|
| AbstractBounds.AbstractBoundsSerializer<T extends RingPosition<T>> |
|
| AbstractBounds.Boundary<T extends RingPosition<T>> |
|
| AbstractBTreePartition |
|
| AbstractBufferClusteringPrefix |
|
| AbstractCell<V> |
Base abstract class for Cell implementations.
|
| AbstractCIDRAuthorizer |
Abstract CIDR authorizer, contains code common to all implementations of ICIDRAuthorizer
|
| AbstractClusteringIndexFilter |
|
| AbstractCommitLogSegmentManager |
Performs eager-creation of commit log segments in a background thread.
|
| AbstractCommitLogService |
|
| AbstractCompactionController |
AbstractCompactionController allows custom implementations of the CompactionController for use in tooling, without being tied to the SSTableReader and local filesystem
|
| AbstractCompactionStrategy |
Pluggable compaction strategy determines how SSTables get merged.
|
| AbstractCompactionStrategy.ScannerList |
|
| AbstractCompactionTask |
|
| AbstractCompletable<I> |
|
| AbstractCompletable.Status |
|
| AbstractCompositeType |
A class avoiding class duplication between CompositeType and
DynamicCompositeType.
|
| AbstractCompositeType.ParsedComparator |
|
| AbstractCryptoProvider |
|
| AbstractEndpointSnitch |
|
| AbstractFunction |
Base class for our native/hardcoded functions.
|
| AbstractFuture<V> |
Our default Future implementation, with all state being managed without locks (except those used by the JVM). |
| AbstractGettableData |
|
| AbstractGuavaIterator<T> |
This is fork of the Guava AbstractIterator, the only difference
is that the next variable is now protected so that the KeyRangeIterator.skipTo
method can avoid early state changed.
|
| AbstractGuavaIterator.State |
|
| AbstractIterator<V> |
|
| AbstractJmxClient |
|
| AbstractMarker |
A single bind marker.
|
| AbstractMarker.INRaw |
A raw placeholder for multiple values of the same type for a single column.
|
| AbstractMarker.MultiColumnRaw |
A MultiColumnRaw version of AbstractMarker.Raw
|
| AbstractMarker.Raw |
A parsed, but non prepared, bind marker.
|
| AbstractMemtable |
|
| AbstractMemtable.ColumnsCollector |
|
| AbstractMemtable.StatsCollector |
|
| AbstractMemtableWithCommitlog |
Memtable that uses a commit log for persistence.
|
| AbstractMessageHandler |
Core logic for handling inbound message deserialization and execution (in tandem with FrameDecoder). |
| AbstractMessageHandler.OnHandlerClosed |
|
| AbstractMessageHandler.WaitQueue |
A special-purpose wait queue to park inbound message handlers that failed to allocate
reserve capacity for a message in.
|
| AbstractMetrics |
|
| AbstractMetricsProviders<R extends SSTableReader> |
|
| AbstractMutableVirtualTable |
An abstract virtual table implementation that builds the resultset on demand and allows fine-grained source
modification via INSERT/UPDATE, DELETE and TRUNCATE operations.
|
| AbstractMutableVirtualTable.ColumnValue |
A regular column value.
|
| AbstractMutableVirtualTable.ColumnValues |
A set of partition key or clustering column values.
|
| AbstractNetworkTopologySnitch |
An endpoint snitch tells Cassandra information about network topology that it can use to route
requests more efficiently.
|
| AbstractOnHeapClusteringPrefix<V> |
|
| AbstractPaxosCallback<T> |
|
| AbstractPaxosRepair |
|
| AbstractPaxosRepair.Failure |
|
| AbstractPaxosRepair.Listener |
|
| AbstractPaxosRepair.Result |
|
| AbstractPaxosRepair.State |
|
| AbstractPaxosRepair.StateUpdater<S,I,T extends java.lang.Throwable> |
|
| AbstractRangeTombstoneMarker<B extends ClusteringBoundOrBoundary<?>> |
|
| AbstractReadCommandBuilder |
|
| AbstractReadCommandBuilder.PartitionRangeBuilder |
|
| AbstractReadCommandBuilder.SinglePartitionBuilder |
|
| AbstractReaderFileProxy |
|
| AbstractReadExecutor |
Sends a read request to the replicas needed to satisfy a given ConsistencyLevel.
|
| AbstractReadExecutor.NeverSpeculatingReadExecutor |
|
| AbstractReadRepair<E extends Endpoints<E>,P extends ReplicaPlan.ForRead<E,P>> |
|
| AbstractRepairTask |
|
| AbstractReplicaCollection<C extends AbstractReplicaCollection<C>> |
A collection like class for Replica objects.
|
| AbstractReplicaCollection.ReplicaList |
A simple list with no comodification checks and immutability by default (only append permitted, and only one initial copy)
this permits us to reduce the amount of garbage generated, by not wrapping iterators or unnecessarily copying
and reduces the amount of indirection necessary, as well as ensuring monomorphic callsites
TODO flatten into AbstractReplicaCollection?
|
| AbstractReplicaCollection.ReplicaMap<K> |
A simple map that ensures the underlying list's iteration order is maintained, and can be shared with
subLists (either produced via subList, or via filter that naturally produced a subList).
|
| AbstractReplicationStrategy |
A abstract parent for all replication strategies.
|
| AbstractRow |
Base abstract class for Row implementations.
|
| AbstractRowIndexEntry |
The base RowIndexEntry is not stored on disk, only specifies a position in the data file
|
| AbstractShardedMemtable |
|
| AbstractSslContextFactory |
Abstract class implementing ISslContextFacotry to provide most of the functionality that any
implementation might need.
|
| AbstractSSTableFormat<R extends SSTableReader,W extends SSTableWriter> |
|
| AbstractSSTableIterator<RIE extends AbstractRowIndexEntry> |
|
| AbstractSSTableIterator.Reader |
|
| AbstractState<T extends java.lang.Enum<T>,I> |
|
| AbstractState.UpdateType |
|
| AbstractStrategyHolder |
Wrapper that's aware of how sstables are divided between separate strategies,
and provides a standard interface to them
not threadsafe, calls must be synchronized by caller
|
| AbstractStrategyHolder.DestinationRouter |
|
| AbstractStrategyHolder.GroupedSSTableContainer |
Maps sstables to their token partition bucket
|
| AbstractStrategyHolder.TaskSupplier |
|
| AbstractTextSerializer |
|
| AbstractTimeUUIDType<T> |
|
| AbstractTokenTreeBuilder |
|
| AbstractTokenTreeBuilder.LevelIterator |
|
| AbstractType<T> |
Specifies a Comparator for a specific type of ByteBuffer.
|
| AbstractType.ComparisonType |
|
| AbstractType.DefaultArgumentDeserializer |
|
| AbstractTypeSerializer |
|
| AbstractUnfilteredPartitionIterator |
|
| AbstractUnfilteredRowIterator |
|
| AbstractVirtualTable |
An abstract virtual table implementation that builds the resultset on demand.
|
| AbstractVirtualTable.AbstractDataSet |
An abstract, map-backed DataSet implementation.
|
| AbstractVirtualTable.DataSet |
|
| AbstractVirtualTable.Partition |
|
| AbstractVirtualTable.SimpleTable |
|
| AbstractWriteResponseHandler<T> |
|
| Accumulator<E> |
A simple append-only collection supporting an unbounded number of concurrent readers/writers,
but a bounded number of items.
|
| ActiveCompactions |
|
| ActiveCompactionsTracker |
|
| ActiveRepairService |
ActiveRepairService is the starting point for manual "active" repairs.
|
| ActiveRepairService.ConsistentSessions |
|
| ActiveRepairService.ParentRepairSession |
We keep a ParentRepairSession around for the duration of the entire repair, for example, on a 256 token vnode rf=3 cluster
we would have 768 RepairSession but only one ParentRepairSession.
|
| ActiveRepairService.ParentRepairStatus |
|
| ActiveRepairService.RepairCommandExecutorHandle |
|
| ActiveRepairServiceMBean |
|
| AddIdentityStatement |
Cqlsh statement to add identity into roles_to_identity table for storing authorized identities for mTLS connections.
|
| AggregateFcts |
Factory methods for aggregate functions.
|
| AggregateFcts.CountRowsFunction |
|
| AggregateFunction |
Performs a calculation on a set of values and return a single value.
|
| AggregateFunction.Aggregate |
An aggregation operation.
|
| AggregationQueryPager |
QueryPager that takes care of fetching the pages for aggregation queries.
|
| AggregationSpecification |
Defines how rows should be grouped for creating aggregates.
|
| AggregationSpecification.Factory |
Factory for AggregationSpecification.
|
| AggregationSpecification.Kind |
The AggregationSpecification kinds.
|
| AggregationSpecification.Serializer |
|
| AlibabaCloudSnitch |
A snitch that assumes an ECS region is a DC and an ECS availability_zone
is a rack.
|
| AllowAllAuthenticator |
|
| AllowAllAuthorizer |
|
| AllowAllCIDRAuthorizer |
AllowAllCIDRAuthorizer allows any user to access from any CIDR
i.e, disables CIDR authorization
|
| AllowAllInternodeAuthenticator |
|
| AllowAllNetworkAuthorizer |
|
| AlreadyExistsException |
|
| AlterKeyspaceStatement |
|
| AlterKeyspaceStatement.Raw |
|
| AlterRoleStatement |
|
| AlterSchemaStatement |
|
| AlterTableStatement |
|
| AlterTableStatement.AlterColumn |
ALTER TABLE [IF EXISTS] <table> ALTER <column> TYPE <newtype>;
No longer supported.
|
| AlterTableStatement.MaskColumn |
ALTER TABLE [IF EXISTS] <table> ALTER [IF EXISTS] <column> ( MASKED WITH <newMask> | DROP MASKED )
|
| AlterTableStatement.Raw |
|
| AlterTypeStatement |
|
| AlterTypeStatement.Raw |
|
| AlterViewStatement |
|
| AlterViewStatement.Raw |
|
| AlwaysSpeculativeRetryPolicy |
|
| ApplicationState |
The various "states" exchanged through Gossip.
|
| Architecture |
|
| ArgumentDeserializer |
Utility used to deserialize function arguments.
|
| Arguments |
The input arguments to a function.
|
| ArrayCell |
|
| ArrayClustering |
|
| ArrayClusteringBound |
|
| ArrayClusteringBoundary |
|
| ArrayClusteringBoundOrBoundary |
|
| ArrayLiteral |
Represents [a, b, c, d] in CQL.
|
| ArtificialBoundMarker |
|
| AsciiSerializer |
|
| AsciiType |
|
| Assassinate |
|
| AssignmentTestable |
|
| AssignmentTestable.TestResult |
|
| AsymmetricOrdering<T1,T2> |
|
| AsymmetricOrdering.Op |
|
| AsymmetricRemoteSyncTask |
AsymmetricRemoteSyncTask sends SyncRequest to target node to repair(stream)
data with other target replica. |
| AsyncChannelOutputPlus |
|
| AsyncChannelOutputPlus.FlushException |
|
| AsyncChannelPromise |
See AsyncPromise and ChannelPromise
This class is all boiler plate, just ensuring we return ourselves and invoke the correct Promise method. |
| AsyncFuture<V> |
Our default Future implementation, with all state being managed without locks (except those used by the JVM). |
| AsyncMessageOutputPlus |
|
| AsyncOneResponse<T> |
A callback specialized for returning a value from a single target; that is, this is for messages
that we only send to one recipient.
|
| AsyncPromise<V> |
|
| AsyncPromise.WithExecutor<V> |
|
| AsyncStreamingInputPlus |
|
| AsyncStreamingInputPlus.Consumer |
|
| AsyncStreamingOutputPlus |
|
| AtomicBTreePartition |
A thread-safe and atomic Partition implementation.
|
| AtomicRatio |
AtomicRatio provides thread safe operations to maintain a AtomicRatio.Ratio of a numerator and denominator.
|
| Attributes |
Utility class for the Parser to gather attributes for modification
statements.
|
| Attributes.Raw |
|
| AuditEvent |
|
| AuditLogContext |
|
| AuditLogEntry |
|
| AuditLogEntry.Builder |
|
| AuditLogEntryCategory |
Enum to categorize AuditLogEntries
|
| AuditLogEntryType |
|
| AuditLogManager |
Central location for managing the logging of client/user-initated actions (like queries, log in commands, and so on).
|
| AuditLogManagerMBean |
|
| AuditLogOptions |
|
| AuditLogOptions.Builder |
|
| AuditLogOptionsCompositeData |
|
| AuditLogOptionsCompositeData.AuditLogOption |
|
| AuditLogViewer |
Tool to view the contenst of AuditLog files in human readable format.
|
| AuthCache<K,V> |
|
| AuthCache.BulkLoader<K,V> |
|
| AuthCacheMBean |
|
| AuthCacheService |
|
| AuthChallenge |
SASL challenge sent from client to server
|
| AuthConfig |
|
| AuthenticatedUser |
Returned from IAuthenticator#authenticate(), represents an authenticated user everywhere internally.
|
| AuthenticateMessage |
Message to indicate that the server is ready to receive requests.
|
| AuthenticationException |
|
| AuthenticationProxy |
An alternative to the JAAS based implementation of JMXAuthenticator provided
by the JDK (JMXPluggableAuthenticator).
|
| AuthenticationStatement |
|
| AuthEvents |
|
| AuthEvents.Listener |
|
| AuthKeyspace |
|
| AuthorizationProxy |
Provides a proxy interface to the platform's MBeanServer instance to perform
role-based authorization on method invocation.
|
| AuthorizationProxy.JmxPermissionsCache |
|
| AuthorizationProxy.JmxPermissionsCacheMBean |
|
| AuthorizationStatement |
|
| AuthProperties |
|
| AuthPropertiesMXBean |
|
| AuthResponse |
A SASL token message sent from client to server.
|
| AuthSchemaChangeListener |
SchemaChangeListener implementation that cleans up permissions on dropped resources.
|
| AuthSuccess |
Indicates to the client that authentication has succeeded.
|
| AutoSavingCache<K extends CacheKey,V> |
|
| AutoSavingCache.CacheSerializer<K extends CacheKey,V> |
A base cache serializer that is used to serialize/deserialize a cache to/from disk.
|
| AutoSavingCache.IStreamFactory |
|
| Awaitable |
A generic signal consumer, supporting all of the typical patterns used in Cassandra.
|
| Awaitable.AbstractAwaitable |
|
| Awaitable.AsyncAwaitable |
|
| Awaitable.Defaults |
|
| Awaitable.SyncAwaitable |
A barebones Awaitable that uses mutual exclusion. |
| AzureSnitch |
AzureSnitch will resolve datacenter and rack by calling /metadata/instance/compute endpoint returning
the response in JSON format for API version 2021-12-13.
|
| Backoff |
|
| Backoff.ExponentialBackoff |
|
| Backoff.None |
|
| Ballot |
|
| Ballot.Flag |
|
| Ballot.Serializer |
|
| BallotGenerator |
|
| BallotGenerator.Default |
|
| BallotGenerator.Global |
|
| BasePartitionIterator<I extends BaseRowIterator<?>> |
|
| BasePartitions<R extends BaseRowIterator<?>,I extends BasePartitionIterator<? extends BaseRowIterator<?>>> |
|
| BaseRowIterator<U extends Unfiltered> |
A common interface for Row and Unfiltered, that permits sharing of the (majority) common
methods and functionality
|
| BaseRows<R extends Unfiltered,I extends BaseRowIterator<? extends Unfiltered>> |
|
| BasicFilters |
|
| BasicFilters.Ascii |
|
| BasicFilters.LowerCase |
|
| BasicFilters.NoOperation |
|
| BasicFilters.Normalize |
|
| BasicResultFilters |
Basic/General Token Filters
|
| BasicResultFilters.LowerCase |
|
| BasicResultFilters.NoOperation |
|
| BasicResultFilters.UpperCase |
|
| Batch |
|
| Batch.Serializer |
|
| BatchlogManager |
|
| BatchlogManagerMBean |
|
| BatchlogResponseHandler<T> |
|
| BatchlogResponseHandler.BatchlogCleanup |
|
| BatchlogResponseHandler.BatchlogCleanupCallback |
|
| BatchMessage |
|
| BatchMetrics |
|
| BatchMetricsTable |
|
| BatchQueryOptions |
|
| BatchRemoveVerbHandler |
|
| BatchStatement |
A BATCH statement parsed from a CQL query.
|
| BatchStatement.Parsed |
|
| BatchStatement.Type |
|
| BatchStoreVerbHandler |
|
| BigFormat |
Legacy bigtable format
|
| BigFormat.BigFormatFactory |
|
| BigFormat.Components |
|
| BigFormat.Components.Types |
|
| BigFormatPartitionWriter |
|
| BigSSTableReaderLoadingBuilder |
|
| BigTableKeyReader |
|
| BigTableReader |
SSTableReaders are open()ed by Keyspace.onStart; after that they are created by SSTableWriter.renameAndOpen.
|
| BigTableReader.Builder |
|
| BigTableScanner |
|
| BigTableScrubber |
|
| BigTableVerifier |
|
| BigTableWriter |
|
| BigTableWriter.Builder |
|
| BigTableWriter.IndexWriter |
Encapsulates writing the index and filter for an SSTable.
|
| BiLongAccumulator<T,A> |
|
| BiMultiValMap<K,V> |
A variant of BiMap which does not enforce uniqueness of values.
|
| BinAuditLogger |
|
| BinAuditLogger.Message |
|
| BinLog |
Bin log is a is quick and dirty binary log that is kind of a NIH version of binary logging with a traditional logging
framework.
|
| BinLog.Builder |
|
| BinLog.ReleaseableWriteMarshallable |
|
| BinLogArchiver |
|
| BinLogOptions |
|
| BitsUtil |
|
| BlockBalancedTreePostingsWriter |
Writes leaf postings and auxiliary posting lists for bbtree nodes.
|
| BlockBalancedTreeQueries |
|
| BlockBalancedTreeReader |
Handles intersection of a point or point range with a block balanced tree previously written with
BlockBalancedTreeWriter. |
| BlockBalancedTreeReader.IntersectVisitor |
We recurse the balanced tree, using a provided instance of this to guide the recursion.
|
| BlockBalancedTreeWalker |
|
| BlockBalancedTreeWriter |
This is a specialisation of the Lucene BKDWriter that only writes a single dimension
balanced tree.
|
| BlockingPartitionRepair |
|
| BlockingQueues |
|
| BlockingQueues.Sync<T> |
|
| BlockingReadRepair<E extends Endpoints<E>,P extends ReplicaPlan.ForRead<E,P>> |
'Classic' read repair.
|
| BlockingReadRepairs |
|
| BlockPackedReader |
|
| BlockPackedWriter |
A writer for large sequences of longs.
|
| BloomCalculations |
The following calculations are taken from:
http://www.cs.wisc.edu/~cao/papers/summary-cache/node8.html
"Bloom Filters - the math"
This class's static methods are meant to facilitate the use of the Bloom
Filter class by helping to choose correct values of 'bits per element' and
'number of hash functions, k'.
|
| BloomCalculations.BloomSpecification |
A wrapper class that holds two key parameters for a Bloom Filter: the
number of hash functions used, and the number of buckets per element used.
|
| BloomFilter |
|
| BloomFilterMetrics<R extends SSTableReaderWithFilter> |
|
| BloomFilterSerializer |
|
| BloomFilterTracker |
|
| BooleanSerializer |
|
| BooleanSerializer |
|
| BooleanType |
|
| BootstrapMonitor |
|
| BootStrapper |
|
| BootstrapResume |
|
| Bound |
|
| Bounds<T extends RingPosition<T>> |
AbstractBounds containing both its endpoints: [left, right].
|
| BreaksJMX |
Annotation to have JMX breaking APIs not trigger test failures, each example must explain why it is ok to expose a
JMX breaking API
|
| BtiFormat |
Bigtable format with trie indices.
|
| BtiFormat.BtiFormatFactory |
|
| BtiFormat.Components |
|
| BtiFormat.Components.Types |
|
| BtiTableReader |
|
| BtiTableReader.Builder |
|
| BtiTableReaderLoadingBuilder |
|
| BtiTableScanner |
|
| BtiTableScrubber |
|
| BtiTableVerifier |
|
| BtiTableWriter |
|
| BtiTableWriter.Builder |
|
| BtiTableWriter.IndexWriter |
Encapsulates writing the index and filter for an SSTable.
|
| BTree |
|
| BTree.Builder<V> |
|
| BTree.Builder.QuickResolver<V> |
|
| BTree.Builder.Resolver |
|
| BTree.Dir |
Represents the direction of iteration.
|
| BTree.FastBuilder<V> |
A pooled builder for constructing a tree in-order, and without needing any reconciliation.
|
| BTreePartitionData |
|
| BTreePartitionUpdater |
the function we provide to the trie and btree utilities to perform any row and column replacements
|
| BTreeRemoval |
|
| BTreeRow |
Immutable implementation of a Row object.
|
| BTreeRow.Builder |
|
| BTreeSearchIterator<K,V> |
|
| BTreeSet<V> |
|
| BTreeSet.BTreeDescRange<V> |
|
| BTreeSet.BTreeRange<V> |
|
| BTreeSet.Builder<V> |
|
| BufferCell |
|
| BufferClustering |
The clustering column values for a row.
|
| BufferClusteringBound |
|
| BufferClusteringBoundary |
|
| BufferClusteringBoundOrBoundary |
|
| BufferDecoratedKey |
|
| BufferedDataOutputStreamPlus |
An implementation of the DataOutputStreamPlus interface using a ByteBuffer to stage writes
before flushing them to an underlying channel.
|
| BufferManagingRebufferer |
Buffer manager used for reading from a ChunkReader when cache is not in use.
|
| BufferManagingRebufferer.Aligned |
|
| BufferManagingRebufferer.Unaligned |
|
| BufferPool |
A pool of ByteBuffers that can be recycled to reduce system direct memory fragmentation and improve buffer allocation
performance.
|
| BufferPool.DebugLeaks |
|
| BufferPoolAllocator |
A trivial wrapper around BufferPool for integrating with Netty, but retaining ownership of pooling behaviour
that is integrated into Cassandra's other pooling.
|
| BufferPoolAllocator.Wrapped |
A simple extension to UnpooledUnsafeDirectByteBuf that returns buffers to BufferPool on deallocate,
and permits extracting the buffer from it to take ownership and use directly.
|
| BufferPoolMetrics |
|
| BufferPools |
|
| BufferType |
|
| BulkIterator<V> |
|
| BulkIterator.Adapter<V> |
|
| BulkIterator.FromArray<V> |
|
| BulkLoadConnectionFactory |
|
| BulkLoader |
|
| BulkLoader.CmdLineOptions |
|
| BulkLoadException |
|
| ByteArrayAccessor |
|
| ByteArrayUtil |
|
| ByteBufferAccessor |
Accessor for ByteBuffer values.
|
| ByteBufferCloner |
Cloner class that can be use to clone partition elements using on-heap or off-heap buffers.
|
| ByteBufferUtil |
Utility methods to make ByteBuffers less painful
The following should illustrate the different ways byte buffers can be used
public void testArrayOffet()
{
byte[] b = "test_slice_array".getBytes();
ByteBuffer bb = ByteBuffer.allocate(1024);
assert bb.position() == 0;
assert bb.limit() == 1024;
assert bb.capacity() == 1024;
bb.put(b);
assert bb.position() == b.length;
assert bb.remaining() == bb.limit() - bb.position();
ByteBuffer bb2 = bb.slice();
assert bb2.position() == 0;
//slice should begin at other buffers current position
assert bb2.arrayOffset() == bb.position();
//to match the position in the underlying array one needs to
//track arrayOffset
assert bb2.limit()+bb2.arrayOffset() == bb.limit();
assert bb2.remaining() == bb.remaining();
}
}
|
| ByteComparable |
Interface indicating a value can be represented/identified by a comparable ByteSource. |
| ByteComparable.Version |
|
| ByteOrderedPartitioner |
|
| ByteOrderedPartitioner.BytesToken |
|
| Bytes |
Simple utility methods to make working with bytes (blob) easier.
|
| BytesConversionFcts |
|
| BytesConversionFcts.FromBlobFunction |
|
| BytesConversionFcts.ToBlobFunction |
|
| ByteSerializer |
|
| ByteSource |
A stream of bytes, used for byte-order-comparable representations of data, and utilities to convert various values
to their byte-ordered translation.
|
| ByteSource.AbstractEscaper |
Variable-length encoding.
|
| ByteSource.AccessorEscaper<V> |
|
| ByteSource.ArrayEscaper |
|
| ByteSource.BufferEscaper |
|
| ByteSource.MemoryEscaper |
|
| ByteSource.Multi |
Combination of multiple byte sources.
|
| ByteSource.Number |
|
| ByteSource.Peekable |
|
| ByteSource.Separator |
Construct the shortest common prefix of prevMax and currMin that separates those two byte streams.
|
| ByteSource.SignedFixedLengthFloat<V> |
Fixed length signed floating point number encoding.
|
| ByteSource.SignedFixedLengthNumber<V> |
Fixed length signed number encoding.
|
| ByteSource.VariableLengthInteger |
Variable-length encoding for signed integers.
|
| ByteSource.VariableLengthUnsignedInteger |
Variable-length encoding for unsigned integers.
|
| ByteSourceInverse |
Contains inverse transformation utilities for ByteSources. |
| BytesReadTracker |
|
| BytesSerializer |
|
| BytesType |
|
| ByteTerm |
|
| ByteType |
|
| CachedBTreePartition |
|
| CachedHashDecoratedKey |
|
| CachedPartition |
A partition stored in the partition cache.
|
| CacheKey |
|
| CacheMetrics |
Metrics for ICache.
|
| CacheProvider<K,V> |
|
| CacheRefresher<K,V> |
|
| CacheService |
|
| CacheService.CacheType |
|
| CacheService.CounterCacheSerializer |
|
| CacheService.KeyCacheSerializer |
|
| CacheService.RowCacheSerializer |
|
| CacheServiceMBean |
|
| CacheSize |
|
| CachingParams |
|
| CachingParams.Option |
|
| CaffeineCache<K extends IMeasurableMemory,V extends IMeasurableMemory> |
An adapter from a Caffeine cache to the ICache interface.
|
| CASClientRequestMetrics |
|
| CASClientWriteRequestMetrics |
Metrics for tracking information about CAS write requests.
|
| CASRequest |
Abstract the conditions and updates for a CAS operation.
|
| CassandraAuthorizer |
CassandraAuthorizer is an IAuthorizer implementation that keeps
user permissions internally in C* using the system_auth.role_permissions
table.
|
| CassandraCIDRAuthorizer |
CassandraCIDRAuthorizer is backend for CIDR authorization checks
1, Provides functionality to populate Role to CIDR permisssions cache and
2, Uses CIDR groups mapping cache as backend to lookup CIDR groups of an IP
|
| CassandraCompressedStreamReader |
CassandraStreamReader that reads from streamed compressed SSTable
|
| CassandraCompressedStreamWriter |
CassandraStreamWriter for compressed SSTable.
|
| CassandraDaemon |
|
| CassandraDaemon.Server |
|
| CassandraEntireSSTableStreamReader |
CassandraEntireSSTableStreamReader reads SSTable off the wire and writes it to disk.
|
| CassandraEntireSSTableStreamWriter |
CassandraEntireSSTableStreamWriter streams the entire SSTable to given channel.
|
| CassandraException |
|
| CassandraIncomingFile |
used to receive the part(or whole) of a SSTable data file.
|
| CassandraIndex |
Index implementation which indexes the values for a single column in the base
table and which stores its index data in a local, hidden table.
|
| CassandraIndexFunctions |
|
| CassandraIndexSearcher |
|
| CassandraKeyspaceRepairManager |
|
| CassandraKeyspaceWriteHandler |
|
| CassandraLoginModule |
LoginModule which authenticates a user towards the Cassandra database using
the internal authentication mechanism.
|
| CassandraMetricsRegistry |
Makes integrating 3.0 metrics API with 2.0.
|
| CassandraMetricsRegistry.JmxCounterMBean |
|
| CassandraMetricsRegistry.JmxGaugeMBean |
|
| CassandraMetricsRegistry.JmxHistogramMBean |
|
| CassandraMetricsRegistry.JmxMeterMBean |
|
| CassandraMetricsRegistry.JmxTimerMBean |
|
| CassandraMetricsRegistry.MetricMBean |
|
| CassandraMetricsRegistry.MetricName |
A value class encapsulating a metric's owning class and name.
|
| CassandraNetworkAuthorizer |
|
| CassandraOutgoingFile |
used to transfer the part(or whole) of a SSTable data file
|
| CassandraPrincipal |
This class implements the Principal interface
and represents a user.
|
| CassandraRelevantEnv |
|
| CassandraRelevantProperties |
A class that extracts system properties for the cassandra node it runs within.
|
| CassandraRelevantProperties.PropertyConverter<T> |
|
| CassandraRoleManager |
Responsible for the creation, maintenance and deletion of roles
for the purposes of authentication and authorization.
|
| CassandraStreamHeader |
|
| CassandraStreamHeader.Builder |
|
| CassandraStreamHeader.CassandraStreamHeaderSerializer |
|
| CassandraStreamManager |
Implements the streaming interface for the native cassandra storage engine.
|
| CassandraStreamReader |
CassandraStreamReader reads from stream and writes to SSTable.
|
| CassandraStreamReader.StreamDeserializer |
|
| CassandraStreamReceiver |
|
| CassandraStreamWriter |
CassandraStreamWriter writes given section of the SSTable to given channel.
|
| CassandraTableRepairManager |
|
| CassandraTableWriteHandler |
|
| CassandraUInt |
This class packages several UInt utility methods so we can easily change it's implementation when needed.
|
| CassandraValidationIterator |
|
| CassandraVersion |
Implements versioning used in Cassandra and CQL.
|
| CassandraWriteContext |
|
| CastFcts |
Casting functions
|
| CasWriteTimeoutException |
|
| CasWriteUnknownResultException |
|
| CBCodec<T> |
|
| CBuilder |
Allows to build ClusteringPrefixes, either Clustering or ClusteringBound.
|
| CBUtil |
ByteBuf utility methods.
|
| CDCWriteException |
|
| Cell<V> |
A cell is our atomic unit for a single value of a single column.
|
| Cell.Factory<V> |
|
| CellPath |
A path for a cell belonging to a complex column type (non-frozen collection or UDT).
|
| CellPath.Serializer |
|
| Cells |
Static methods to work on cells.
|
| ChannelProxy |
A proxy of a FileChannel that:
- implements reference counting
- exports only thread safe FileChannel operations
- wraps IO exceptions into runtime exceptions
Tested by RandomAccessReaderTest.
|
| CharTerm |
|
| CheckedFunction<T,R,E extends java.lang.Exception> |
|
| ChecksummedDataInput |
|
| ChecksummedRandomAccessReader |
|
| ChecksummedSequentialWriter |
|
| ChecksumMismatchException |
|
| ChecksumType |
|
| ChecksumWriter |
|
| ChunkCache |
|
| ChunkCacheMetrics |
Metrics for ICache.
|
| ChunkReader |
RandomFileReader component that reads data from a file into a provided buffer and may have requirements over the
size and alignment of reads.
|
| CIDR |
Contains a CIDR, and operations on it
|
| CIDRAuthorizerMetrics |
Captures metrics of CIDR authorizer
|
| CIDRFilteringMetricsTable |
Virtual tables capturing metrics related to CIDR filtering
|
| CIDRFilteringMetricsTable.CIDRFilteringMetricsCountsTable |
Virtual table capturing counts i.e, non-latency metrics related to CIDR filtering
|
| CIDRFilteringMetricsTable.CIDRFilteringMetricsLatenciesTable |
Virtual table capturing latency metrics related to CIDR filtering
|
| CIDRFilteringMetricsTableMBean |
mbean to expose CIDR filtering metrics virtual table to JMX/nodetool
|
| CIDRFilteringStats |
Nodetool command to view stats related to CIDR filtering
|
| CIDRGroupsMappingCache |
CIDR groups mapping cache.
|
| CIDRGroupsMappingIntervalTree<V> |
This class implements CIDR Interval tree and the ability to find longest matching CIDR for the given IP.
|
| CIDRGroupsMappingLoader |
|
| CIDRGroupsMappingManager |
|
| CIDRGroupsMappingManagerMBean |
This class provides utility functions to list/update/drop CIDR groups mappings.
|
| CIDRGroupsMappingTable<V> |
This interface defines functionality to be provided by algorithm(s) implementing CIDR to CIDR groups mappings,
to facilitate the efficient way to find the longest matching CIDR for a given IP
|
| CIDRGroupsMappingTable.Builder<V> |
Builder to add CIDR to CIDR groups mappings and construct a mapping table with them
|
| CIDRPermissions |
Contains CIDR permissions of a role
|
| CIDRPermissions.Builder |
Builder to generate CIDR Permissions
|
| CIDRPermissionsCache |
|
| CIDRPermissionsManager |
Provides functionality to list/update/drop CIDR permissions of a role
Backend to build Role to CIDR permissions cache
|
| CIDRPermissionsManagerMBean |
JMX functions related to CIDR permissions cache and table
|
| CipherFactory |
A factory for loading encryption keys from KeyProvider instances. |
| Cleanup |
|
| CleanupMessage |
Message to cleanup repair resources on replica nodes.
|
| CleanupSummary |
|
| CleanupTransaction |
Performs garbage collection of index entries during a cleanup.
|
| ClearableHistogram |
Adds ability to reset a histogram
|
| ClearSnapshot |
|
| Client |
|
| ClientMessageSizeMetrics |
Metrics to track the size of incoming and outgoing bytes at Cassandra server.
|
| ClientMetrics |
|
| ClientRangeRequestMetrics |
Metrics for tracking information about range requests.
|
| ClientRequestMetrics |
|
| ClientRequestSizeMetrics |
|
| ClientRequestsMetricsHolder |
|
| ClientResourceLimits |
|
| ClientResourceLimits.Overload |
|
| ClientStat |
|
| ClientState |
State related to a client connection.
|
| ClientStats |
|
| ClientWarn |
|
| ClientWarn.State |
|
| ClientWriteRequestMetrics |
Metrics for tracking information about write requests.
|
| Clock |
Wrapper around time related functions that are either implemented by using the default JVM calls
or by using a custom implementation for testing purposes.
|
| Clock.Default |
|
| Clock.Global |
|
| ClockAndCount |
|
| Cloner |
Allow cloning of partition elements
|
| Closeable |
|
| CloseableIterator<T> |
|
| CloudstackSnitch |
Deprecated.
|
| Clusterable<T> |
Common class for objects that are identified by a clustering prefix, and can be thus sorted by a
ClusteringComparator. |
| Clustering<V> |
|
| Clustering.Serializer |
Serializer for Clustering object.
|
| ClusteringBound<V> |
The start or end of a range of clusterings, either inclusive or exclusive.
|
| ClusteringBoundary<V> |
The threshold between two different ranges, i.e.
|
| ClusteringBoundOrBoundary<V> |
This class defines a threshold between ranges of clusterings.
|
| ClusteringBoundOrBoundary.Serializer |
|
| ClusteringColumnIndex |
Index on a CLUSTERING_COLUMN column definition.
|
| ClusteringComparator |
A comparator of clustering prefixes (or more generally of Clusterable}. |
| ClusteringIndexFilter |
A filter that selects a subset of the rows of a given partition by using the "clustering index".
|
| ClusteringIndexFilter.InternalDeserializer |
|
| ClusteringIndexFilter.Kind |
|
| ClusteringIndexFilter.Serializer |
|
| ClusteringIndexNamesFilter |
A filter selecting rows given their clustering value.
|
| ClusteringIndexSliceFilter |
A filter over a single partition.
|
| ClusteringPrefix<V> |
|
| ClusteringPrefix.Deserializer |
Helper class that makes the deserialization of clustering prefixes faster.
|
| ClusteringPrefix.Kind |
The kind of clustering prefix this actually is.
|
| ClusteringPrefix.Serializer |
|
| CodecNotFoundException |
|
| CodecRegistry |
|
| CodecUtils |
A set of utility methods to deal with type conversion and serialization.
|
| CollatedViewIndexBuilder |
Manages building an entire index from column family data.
|
| CollectionEntryIndex |
Index on the element and value of cells participating in a collection.
|
| CollectionFcts |
Native CQL functions for collections (sets, list and maps).
|
| CollectionKeyIndex |
Index on the collection element of the cell name of a collection.
|
| CollectionKeyIndexBase |
Common superclass for indexes that capture collection keys, including
indexes on such keys themselves.
|
| CollectionSerializer<T> |
|
| CollectionSerializer |
|
| CollectionType<T> |
The abstract validator that is the base for maps, sets and lists (both frozen and non-frozen).
|
| CollectionType.Kind |
|
| CollectionValueIndex |
Index the value of a collection cell.
|
| Collectors3 |
Some extra Collector implementations.
|
| ColumnCompletionMarkerUtil |
|
| ColumnCondition |
A CQL3 condition on the value of a column or collection element.
|
| ColumnCondition.Bound |
|
| ColumnCondition.Raw |
|
| ColumnConditions |
A set of ColumnConditions.
|
| ColumnConditions.Builder |
A Builder for ColumnConditions.
|
| ColumnData |
Generic interface for the data of a given column (inside a row).
|
| ColumnData.PostReconciliationFunction |
|
| ColumnData.Reconciler |
|
| ColumnFamilyStore |
|
| ColumnFamilyStore.FlushReason |
Reason for initiating a memtable flush.
|
| ColumnFamilyStore.RefViewFragment |
|
| ColumnFamilyStore.VersionedLocalRanges |
|
| ColumnFamilyStore.ViewFragment |
|
| ColumnFamilyStoreMBean |
The MBean interface for ColumnFamilyStore
|
| ColumnFilter |
Represents which (non-PK) columns (and optionally which sub-part of a column for complex columns) are selected
by a query.
|
| ColumnFilter.Builder |
A builder for a ColumnFilter object.
|
| ColumnFilter.SelectionColumnFilter |
ColumnFilter sub-class for queries with selected columns.
|
| ColumnFilter.Serializer |
|
| ColumnFilter.Tester |
|
| ColumnFilter.WildCardColumnFilter |
ColumnFilter sub-class for wildcard queries.
|
| ColumnIdentifier |
Represents an identifer for a CQL column definition.
|
| ColumnIndex |
|
| ColumnIndexesSystemView |
A VirtualTable providing a system view of per-column storage-attached index metadata. |
| ColumnMask |
Dynamic data mask that can be applied to a schema column.
|
| ColumnMask.Masker |
|
| ColumnMask.Raw |
A parsed but not prepared column mask.
|
| ColumnMetadata |
|
| ColumnMetadata.ClusteringOrder |
|
| ColumnMetadata.Kind |
The type of CQL3 column this definition represents.
|
| ColumnQueryMetrics |
|
| ColumnQueryMetrics.BalancedTreeIndexMetrics |
|
| ColumnQueryMetrics.TrieIndexMetrics |
|
| Columns |
An immutable and sorted list of (non-PK) columns for a given table.
|
| Columns.Serializer |
|
| ColumnSpecification |
|
| ColumnSubselection |
Handles the selection of a subpart of a column.
|
| ColumnSubselection.Serializer |
|
| CombinedTerm |
|
| CombinedTermIterator |
|
| CombinedValue<V> |
|
| Commit |
|
| Commit.Accepted |
|
| Commit.AcceptedWithTTL |
|
| Commit.Agreed |
|
| Commit.CommitSerializer<T extends Commit> |
|
| Commit.Committed |
|
| Commit.CommittedWithTTL |
|
| Commit.Proposal |
|
| CommitLog |
|
| CommitLog.Configuration |
|
| CommitLogArchiver |
|
| CommitLogDescriptor |
|
| CommitLogMBean |
|
| CommitLogMetrics |
Metrics for commit log
|
| CommitLogPosition |
Contains a segment id and a position for CommitLogSegment identification.
|
| CommitLogPosition.CommitLogPositionSerializer |
|
| CommitLogReader |
|
| CommitLogReadHandler |
|
| CommitLogReadHandler.CommitLogReadErrorReason |
|
| CommitLogReadHandler.CommitLogReadException |
|
| CommitLogReplayer |
|
| CommitLogReplayer.CommitLogReplayException |
|
| CommitLogReplayer.MutationInitiator |
|
| CommitLogSegment |
|
| CommitLogSegment.Allocation |
A simple class for tracking information about the portion of a segment that has been allocated to a log write.
|
| CommitLogSegment.Builder |
|
| CommitLogSegment.CDCState |
|
| CommitLogSegment.CommitLogSegmentFileComparator |
|
| CommitLogSegmentManagerCDC |
|
| CommitLogSegmentManagerStandard |
|
| CommitLogSegmentReader |
Read each sync section of a commit log, iteratively.
|
| CommitLogSegmentReader.SegmentReadException |
|
| CommitLogSegmentReader.SyncSegment |
|
| CommonRange |
Groups ranges with identical endpoints/transient endpoints
|
| Compact |
|
| CompactionAwareWriter |
Class that abstracts away the actual writing of files to make it possible to use CompactionTask for more
use cases.
|
| CompactionController |
Manage compaction options.
|
| CompactionHistory |
|
| CompactionHistoryHolder |
|
| CompactionHistoryPrinter |
|
| CompactionHistoryPrinter.DefaultPrinter |
|
| CompactionHistoryTabularData |
|
| CompactionInfo |
|
| CompactionInfo.Holder |
|
| CompactionInfo.Unit |
|
| CompactionInterruptedException |
|
| CompactionIterator |
Merge multiple iterators over the content of sstable into a "compacted" iterator.
|
| CompactionLogger |
|
| CompactionLogger.Strategy |
|
| CompactionLogger.StrategySummary |
This will produce the compaction strategy's starting information.
|
| CompactionLogger.Writer |
This is an interface to allow writing to a different interface.
|
| CompactionManager |
A singleton which manages a private executor of ongoing compactions.
|
| CompactionManager.AllSSTableOpStatus |
|
| CompactionManager.CompactionPauser |
|
| CompactionManager.ValidationExecutor |
|
| CompactionManagerMBean |
|
| CompactionMetadata |
Compaction related SSTable metadata.
|
| CompactionMetadata.CompactionMetadataSerializer |
|
| CompactionMetrics |
Metrics for compaction.
|
| CompactionParams |
|
| CompactionParams.Option |
|
| CompactionParams.TombstoneOption |
|
| CompactionStats |
|
| CompactionStrategyHolder |
|
| CompactionStrategyManager |
Manages the compaction strategies.
|
| CompactionTask |
|
| CompactionTasks |
|
| CompactionTransaction |
Performs garbage collection of stale index entries during a regular compaction.
|
| CompactionVectorValues |
|
| Comparables |
Utility methods linked to comparing comparable values.
|
| Completable<I> |
|
| Completable.Result |
|
| Completable.Result.Kind |
|
| CompletableRemoteSyncTask |
|
| CompleteMessage |
|
| ComplexColumnData |
The data for a complex column, that is it's cells and potential complex
deletion time.
|
| ComplexColumnData.Builder |
|
| Component |
SSTables are made up of multiple components in separate files.
|
| Component.Type |
WARNING: Be careful while changing the names or string representation of the enum
members.
|
| ComponentContext |
|
| ComponentManifest |
SSTable components and their sizes to be tranfered via entire-sstable-streaming
|
| CompositesSearcher |
|
| CompositeType |
|
| CompositeType.Serializer |
|
| CompressedChecksummedDataInput |
|
| CompressedChunkReader |
|
| CompressedChunkReader.Mmap |
|
| CompressedChunkReader.Standard |
|
| CompressedHintsWriter |
|
| CompressedInputStream |
InputStream which reads compressed chunks from the underlying input stream and deals with decompression
and position tracking.
|
| CompressedSegment |
Compressed commit log segment.
|
| CompressedSegment.CompressedSegmentBuilder |
|
| CompressedSequentialWriter |
|
| CompressedSequentialWriter.CompressedFileWriterMark |
Class to hold a mark to the position of the file
|
| CompressionInfo |
Container that carries compression parameters and chunks to decompress data from stream.
|
| CompressionInfoComponent |
|
| CompressionMetadata |
Holds metadata about compressed file
TODO extract interface ICompressionMetadata which will just provide non-resource properties
|
| CompressionMetadata.Chunk |
Holds offset and length of the file chunk
|
| CompressionMetadata.Writer |
|
| CompressionParams |
|
| Compressor |
|
| Compressor.LZ4Compressor |
|
| Compressor.SnappyCompressor |
|
| ConcurrentBiMap<K,V> |
A variant of BiMap that permits concurrent access, and expects uniqueness of values in both domain and range.
|
| ConcurrentVectorValues |
|
| Condition |
Simpler API than java.util.concurrent.Condition; would be nice to extend it, but also nice
to share API with Future, for which Netty's API is incompatible with java.util.concurrent.Condition
Awaitable for explicit external signals. |
| Condition.Async |
|
| Condition.Sync |
|
| ConditionAsConsumer<T> |
|
| ConditionAsConsumer.Async<T> |
|
| Conditions |
Conditions that can be applied to a mutation statement.
|
| Config |
A class that contains configuration properties for the cassandra node it runs within.
|
| Config.CommitFailurePolicy |
|
| Config.CommitLogSync |
|
| Config.CorruptedTombstoneStrategy |
|
| Config.CQLStartTime |
Which timestamp should be used to represent a base for replica-side timeouts.
|
| Config.DiskAccessMode |
|
| Config.DiskFailurePolicy |
|
| Config.DiskOptimizationStrategy |
|
| Config.FlushCompression |
|
| Config.InternodeCompression |
|
| Config.MemtableAllocationType |
|
| Config.MemtableOptions |
|
| Config.PaxosOnLinearizabilityViolation |
A safety mechanism for detecting incorrect paxos state, that may be down either to a bug or incorrect usage of LWTs
(most likely due to unsafe mixing of SERIAL and LOCAL_SERIAL operations), and rejecting
|
| Config.PaxosStatePurging |
Select the kind of paxos state purging to use.
|
| Config.PaxosVariant |
The variants of paxos implementation and semantics supported by Cassandra.
|
| Config.RepairCommandPoolFullStrategy |
|
| Config.SSTableConfig |
|
| Config.UserFunctionTimeoutPolicy |
|
| ConfigurationException |
|
| ConfigurationLoader |
|
| ConnectedClient |
|
| Connection |
|
| Connection.Factory |
|
| Connection.Tracker |
|
| ConnectionCategory |
|
| ConnectionStage |
|
| ConnectionType |
|
| ConsistencyLevel |
|
| ConsistentSession |
Base class for consistent Local and Coordinator sessions
|
| ConsistentSession.State |
The possible states of a ConsistentSession.
|
| Constants |
Static helper methods and classes for constants.
|
| Constants.Adder |
|
| Constants.Deleter |
|
| Constants.Literal |
|
| Constants.Marker |
|
| Constants.Setter |
|
| Constants.Substracter |
|
| Constants.Type |
|
| Constants.Value |
A constant value, i.e.
|
| ContentionStrategy |
A strategy for making back-off decisions for Paxos operations that fail to make progress because of other paxos operations.
|
| ContentionStrategy.Type |
|
| Controller |
The controller provides compaction parameters to the unified compaction strategy
|
| Converters |
Converters for backward compatibility with the old cassandra.yaml where duration, data rate and
data storage configuration parameters were provided only by value and the expected unit was part of the configuration
parameter name(suffix).
|
| CoordinatedRepairResult |
|
| CoordinatorSession |
Coordinator side logic and state of a consistent repair session.
|
| CoordinatorSession.Builder |
|
| CoordinatorSessions |
Container for all consistent repair sessions a node is coordinating
|
| CoordinatorState |
|
| CoordinatorState.State |
|
| CoordinatorWarnings |
|
| CorruptBlockException |
|
| CorruptFileException |
|
| CorruptSSTableException |
|
| CountDownLatch |
|
| CountDownLatch.Async |
|
| CountDownLatch.Sync |
|
| CounterCacheKey |
|
| CounterCells |
|
| CounterColumnType |
|
| CounterContext |
An implementation of a partitioned counter context.
|
| CounterContext.ContextState |
Helper class to work on contexts (works by iterating over them).
|
| CounterContext.Relationship |
|
| CounterId |
|
| CounterMutation |
|
| CounterMutation.CounterMutationSerializer |
|
| CounterMutationVerbHandler |
|
| CounterSerializer |
|
| CQL3CasRequest |
Processed CAS conditions and update on potentially multiple rows of the same partition.
|
| CQL3Type |
|
| CQL3Type.Collection |
|
| CQL3Type.Custom |
|
| CQL3Type.Native |
|
| CQL3Type.Raw |
|
| CQL3Type.Tuple |
|
| CQL3Type.UserDefined |
|
| CQL3Type.Vector |
|
| CqlBuilder |
Utility class to facilitate the creation of the CQL representation of SchemaElements.
|
| CqlBuilder.Appender<T> |
|
| CQLFragmentParser |
Helper class to encapsulate common code that calls one of the generated methods in CqlParser.
|
| CQLFragmentParser.CQLParserFunction<R> |
|
| CQLMessageHandler<M extends Message> |
|
| CQLMetrics |
|
| CQLSSTableWriter |
Utility to write SSTables.
|
| CQLSSTableWriter.Builder |
A Builder for a CQLSSTableWriter object.
|
| CQLStatement |
|
| CQLStatement.Raw |
|
| CQLStatement.SingleKeyspaceCqlStatement |
|
| CQLTypeParser |
|
| Crc |
|
| Crc.InvalidCrc |
|
| CreateAggregateStatement |
|
| CreateAggregateStatement.Raw |
|
| CreateFunctionStatement |
|
| CreateFunctionStatement.Raw |
|
| CreateIndexStatement |
|
| CreateIndexStatement.Raw |
|
| CreateKeyspaceStatement |
|
| CreateKeyspaceStatement.Raw |
|
| CreateRoleStatement |
|
| CreateTableStatement |
|
| CreateTableStatement.Raw |
|
| CreateTriggerStatement |
|
| CreateTriggerStatement.Raw |
|
| CreateTypeStatement |
|
| CreateTypeStatement.Raw |
|
| CreateViewStatement |
|
| CreateViewStatement.Raw |
|
| Cursor<K,V> |
A Cursor can be used to traverse a Trie, visit each node
step by step and make Cursor.Decisions on each step how to continue with
traversing the Trie. |
| Cursor.Decision |
|
| CustomClassLoader |
Custom class loader will load the classes from the class path, CCL will load
the classes from the URL first, if it cannot find the required class it
will let the parent class loader do its job.
|
| CustomIndexExpression |
|
| CustomPayloadMirroringQueryHandler |
Custom QueryHandler that sends custom request payloads back with the result.
|
| DatabaseDescriptor |
|
| Datacenters |
|
| DatacenterSyncWriteResponseHandler<T> |
This class blocks for a quorum of responses _in all datacenters_ (CL.EACH_QUORUM).
|
| DatacenterWriteResponseHandler<T> |
This class blocks for a quorum of responses _in the local datacenter only_ (CL.LOCAL_QUORUM).
|
| DataComponent |
|
| DataInputBuffer |
Input stream around a single ByteBuffer.
|
| DataInputPlus |
Extension to DataInput that provides support for reading varints
|
| DataInputPlus.DataInputStreamPlus |
Wrapper around an InputStream that provides no buffering but can decode varints
|
| DataIntegrityMetadata |
|
| DataIntegrityMetadata.ChecksumValidator |
|
| DataIntegrityMetadata.FileDigestValidator |
|
| DataLimits |
Object in charge of tracking if we have fetch enough data for a given query.
|
| DataLimits.Counter |
|
| DataLimits.Kind |
|
| DataLimits.Serializer |
|
| DataOutputBuffer |
An implementation of the DataOutputStream interface using a FastByteArrayOutputStream and exposing
its buffer so copies can be avoided.
|
| DataOutputBufferFixed |
An implementation of the DataOutputStream interface using a FastByteArrayOutputStream and exposing
its buffer so copies can be avoided.
|
| DataOutputPlus |
Extension to DataOutput that provides for writing ByteBuffer and Memory, potentially with an efficient
implementation that is zero copy or at least has reduced bounds checking overhead.
|
| DataOutputStreamPlus |
Abstract base class for DataOutputStreams that accept writes from ByteBuffer or Memory and also provide
access to the underlying WritableByteChannel associated with their output stream.
|
| DataPaths |
|
| DataPathsHolder |
|
| DataPathsPrinter<T extends StatsHolder> |
|
| DataPathsPrinter.DefaultPrinter |
|
| DataPosition |
|
| DataRange |
Groups both the range of partitions to query, and the clustering index filter to
apply for each partition (for a (partition) range query).
|
| DataRange.Paging |
Specialized DataRange used for the paging case.
|
| DataRange.Serializer |
|
| DataRateSpec |
Represents a data rate type used for cassandra configuration.
|
| DataRateSpec.DataRateUnit |
|
| DataRateSpec.LongBytesPerSecondBound |
Represents a data rate used for Cassandra configuration.
|
| DataResolver<E extends Endpoints<E>,P extends ReplicaPlan.ForRead<E,P>> |
|
| DataResource |
The primary type of resource in Cassandra.
|
| DataResurrectionCheck |
|
| DataResurrectionCheck.Heartbeat |
|
| DataStorageSpec |
Represents an amount of data storage.
|
| DataStorageSpec.DataStorageUnit |
|
| DataStorageSpec.IntBytesBound |
Represents a data storage quantity used for Cassandra configuration.
|
| DataStorageSpec.IntKibibytesBound |
Represents a data storage quantity used for Cassandra configuration.
|
| DataStorageSpec.IntMebibytesBound |
Represents a data storage quantity used for Cassandra configuration.
|
| DataStorageSpec.LongBytesBound |
Represents a data storage quantity used for Cassandra configuration.
|
| DataStorageSpec.LongMebibytesBound |
Represents a data storage quantity used for Cassandra configuration.
|
| DataTracker |
a pared-down version of DataTracker and DT.View.
|
| DataType |
Data types supported by cassandra.
|
| DataType |
|
| DataType.Codec |
|
| DataType.CollectionType |
Instances of this class represent collection types, that is, lists, sets or maps.
|
| DataType.CustomType |
A "custom" type is a type that cannot be expressed as a CQL type.
|
| DataType.Name |
The CQL type name.
|
| DataType.NativeType |
Instances of this class represent CQL native types, also known as CQL primitive types.
|
| DataTypeClassNameParser |
|
| DateType |
Deprecated.
|
| DCPermissions |
|
| DCPermissions.Builder |
|
| DebuggableTask |
Interface to include on a Runnable or Callable submitted to the SharedExecutorPool to provide more
detailed diagnostics. |
| DebuggableTask.CallableDebuggableTask<T> |
|
| DebuggableTask.RunnableDebuggableTask |
|
| DebuggableTask.RunningDebuggableTask |
|
| DecayingEstimatedHistogramReservoir |
A decaying histogram reservoir where values collected during each minute will be twice as significant as the values
collected in the previous minute.
|
| DecimalSerializer |
|
| DecimalType |
|
| Decommission |
|
| DecoratedKey |
Represents a decorated key, handy for certain operations
where just working with strings gets slow.
|
| DefaultCompactionWriter |
The default compaction writer - creates one output file in L0
|
| DefaultCryptoProvider |
Default crypto provider tries to install AmazonCorrettoCryptoProvider.
|
| DefaultFSErrorHandler |
|
| DefaultLoader |
|
| DefaultMaskingFunction |
A MaskingFunction that returns a fixed replacement value for the data type of its single argument. |
| DefaultNameFactory |
MetricNameFactory that generates default MetricName of metrics.
|
| DefaultSchemaUpdateHandler |
|
| DefaultSchemaUpdateHandlerFactory |
|
| DefaultSslContextFactory |
Cassandra's default implementation class for the configuration key ssl_context_factory.
|
| DefaultValue<T> |
|
| DeflateCompressor |
|
| DeleteStatement |
A DELETE parsed from a CQL query statement.
|
| DeleteStatement.Parsed |
|
| DeletingArchiver |
|
| DeletionInfo |
A combination of a top-level (partition) tombstone and range tombstones describing the deletions
within a partition.
|
| DeletionPurger |
|
| DeletionTime |
Information on deletion of a storage engine object.
|
| DeletionTime.InvalidDeletionTime |
|
| DeletionTime.LegacySerializer |
|
| DeletionTime.Serializer |
|
| DelimiterAnalyzer |
|
| DelimiterTokenizingOptions |
Simple tokenizer based on a specified delimiter (rather than whitespace).
|
| DenylistMetrics |
|
| DescribeCluster |
|
| DescribeRing |
|
| DescribeStatement<T> |
The differents DESCRIBE statements parsed from a CQL statement.
|
| DescribeStatement.Element |
DescribeStatement implementation used for describe queries for a single schema element.
|
| DescribeStatement.Listing |
DescribeStatement implementation used for describe queries that only list elements names.
|
| Descriptor |
Object descriptor for SASIIndex files.
|
| Descriptor |
A SSTable is described by the keyspace and column family it contains data
for, an id (generation - where higher generations contain more recent data) and
an alphabetic version string.
|
| Descriptor.Version |
|
| DeserializationHelper |
|
| DeserializationHelper.Flag |
Flag affecting deserialization behavior (this only affect counters in practice).
|
| DiagnosticEvent |
Base class for internally emitted events used for diagnostics and testing.
|
| DiagnosticEventAuditLogger |
|
| DiagnosticEventMemoryStore |
Simple on-heap memory store that allows to buffer and retrieve a fixed number of events.
|
| DiagnosticEventPersistence |
|
| DiagnosticEventService |
|
| DiagnosticEventServiceMBean |
|
| DiagnosticEventStore<T extends java.lang.Comparable<T>> |
|
| DiagnosticSnapshotService |
Provides a means to take snapshots when triggered by anomalous events or when the breaking of invariants is
detected.
|
| Diff<T extends java.lang.Iterable,S> |
|
| Diff.Altered<T> |
|
| Difference |
|
| DifferenceHolder |
Just holds all differences between the hosts involved in a repair
|
| Digest |
|
| DigestResolver<E extends Endpoints<E>,P extends ReplicaPlan.ForRead<E,P>> |
|
| DigestResolver.DigestResolverDebugResult |
|
| DirectIOSegment |
|
| DirectIOSegment.DirectIOSegmentBuilder |
|
| Directories |
Encapsulate handling of paths to the data files.
|
| Directories.DataDirectories |
Data directories used to store keyspace data.
|
| Directories.DataDirectory |
|
| Directories.FileAction |
|
| Directories.FileType |
The type of files that can be listed by SSTableLister, we never return txn logs,
use LifecycleTransaction.getFiles() if you need txn logs.
|
| Directories.OnTxnErr |
How to handle a failure to read a txn log file.
|
| Directories.SSTableLister |
|
| DirectorySizeCalculator |
Walks directory recursively, summing up total contents of files within.
|
| DirectReaders |
|
| DisableAuditLog |
|
| DisableAutoCompaction |
|
| DisableBackup |
|
| DisableBinary |
|
| DisableFullQueryLog |
|
| DisableGossip |
|
| DisableHandoff |
|
| DisableHintsForDC |
|
| DisableOldProtocolVersions |
|
| DisableSslContextFactory |
|
| DisallowedDirectories |
|
| DisallowedDirectoriesMBean |
|
| DiskAnn |
|
| DiskBinarySearch |
|
| DiskBoundaries |
|
| DiskBoundaryManager |
|
| DiskOptimizationStrategy |
|
| DiskUsageBroadcaster |
Starts DiskUsageMonitor to monitor local disk usage state and broadcast new state via Gossip. |
| DiskUsageMonitor |
Schedule periodic task to monitor local disk usage and notify DiskUsageBroadcaster if local state changed. |
| DiskUsageState |
|
| Dispatcher |
|
| Dispatcher.RequestTime |
|
| DistributedSchema |
Immutable snapshot of the current schema along with its version.
|
| DoubleSerializer |
|
| DoubleType |
|
| Downsampling |
|
| Drain |
|
| DriverException |
Top level class for exceptions thrown by the driver.
|
| DriverInternalError |
An unexpected error happened internally.
|
| DropAggregateStatement |
|
| DropAggregateStatement.Raw |
|
| DropCIDRGroup |
|
| DropFunctionStatement |
|
| DropFunctionStatement.Raw |
|
| DropIdentityStatement |
Cqlsh statement to remove identity from identity_to_roles table.
|
| DropIndexStatement |
|
| DropIndexStatement.Raw |
|
| DropKeyspaceStatement |
|
| DropKeyspaceStatement.Raw |
|
| DroppedColumn |
|
| DroppedMessageMetrics |
Metrics for dropped messages by verb.
|
| DropRoleStatement |
|
| DropTableStatement |
|
| DropTableStatement.Raw |
|
| DropTriggerStatement |
|
| DropTriggerStatement.Raw |
|
| DropTypeStatement |
|
| DropTypeStatement.Raw |
|
| DropViewStatement |
|
| DropViewStatement.Raw |
|
| DuplicateRowChecker |
|
| Duration |
Represents a duration.
|
| Duration |
Represents a duration.
|
| DurationSerializer |
|
| DurationSpec |
Represents a positive time duration.
|
| DurationSpec.IntMillisecondsBound |
Represents a duration used for Cassandra configuration.
|
| DurationSpec.IntMinutesBound |
Represents a duration used for Cassandra configuration.
|
| DurationSpec.IntSecondsBound |
Represents a duration used for Cassandra configuration.
|
| DurationSpec.LongMicrosecondsBound |
Represents a duration used for Cassandra configuration.
|
| DurationSpec.LongMillisecondsBound |
Represents a duration used for Cassandra configuration.
|
| DurationSpec.LongNanosecondsBound |
Represents a duration used for Cassandra configuration.
|
| DurationSpec.LongSecondsBound |
Represents a duration used for Cassandra configuration.
|
| DurationType |
Represents a duration.
|
| DynamicCompositeType |
|
| DynamicCompositeType.FixedValueComparator |
|
| DynamicCompositeType.Serializer |
|
| DynamicEndpointSnitch |
A dynamic snitch that sorts endpoints by latency with an adapted phi failure detector
|
| DynamicEndpointSnitchMBean |
|
| DynamicList<E> |
|
| DynamicList.Node<E> |
|
| DynamicTokenTreeBuilder |
|
| Ec2MultiRegionSnitch |
1) Snitch will automatically set the public IP by querying the AWS API
2) Snitch will set the private IP as a Gossip application state.
|
| Ec2Snitch |
A snitch that assumes an EC2 region is a DC and an EC2 availability_zone
is a rack.
|
| EchoVerbHandler |
|
| EmbeddedCassandraService |
An embedded, in-memory cassandra storage service.
|
| EmptyIterators |
|
| EmptyPartitionsDiscarder |
|
| EmptyRebufferer |
|
| EmptySerializer |
|
| EmptySSTableScanner |
|
| EmptyType |
A type that only accept empty data.
|
| EnableAuditLog |
|
| EnableAutoCompaction |
|
| EnableBackup |
|
| EnableBinary |
|
| EnableFlag |
A guardrail that enables the use of a particular feature.
|
| EnableFullQueryLog |
|
| EnableGossip |
|
| EnableHandoff |
|
| EnableHintsForDC |
|
| EnableOldProtocolVersions |
|
| EncodingStats |
Stats used for the encoding of the rows and tombstones of a given source.
|
| EncodingStats.Collector |
|
| EncodingStats.Serializer |
|
| EncryptedChecksummedDataInput |
|
| EncryptedFileSegmentInputStream |
Each segment of an encrypted file may contain many encrypted chunks, and each chunk needs to be individually decrypted
to reconstruct the full segment.
|
| EncryptedFileSegmentInputStream.ChunkProvider |
|
| EncryptedHintsWriter |
|
| EncryptedSegment |
Writes encrypted segments to disk.
|
| EncryptedSegment.EncryptedSegmentBuilder |
|
| EncryptionContext |
A (largely) immutable wrapper for the application-wide file-level encryption settings.
|
| EncryptionOptions |
This holds various options used for enabling SSL/TLS encryption.
|
| EncryptionOptions.ConfigKey |
|
| EncryptionOptions.ServerEncryptionOptions |
|
| EncryptionOptions.ServerEncryptionOptions.InternodeEncryption |
|
| EncryptionOptions.TlsEncryptionPolicy |
|
| EncryptionUtils |
Encryption and decryption functions specific to the commit log.
|
| EncryptionUtils.ChannelProxyReadChannel |
|
| EndpointMessagingVersions |
Map of hosts to their known current messaging versions.
|
| Endpoints<E extends Endpoints<E>> |
A collection of Endpoints for a given ring position.
|
| EndpointsByRange |
|
| EndpointsByRange.Builder |
|
| EndpointsByReplica |
|
| EndpointsByReplica.Builder |
|
| EndpointsForRange |
A ReplicaCollection where all Replica are required to cover a range that fully contains the range() defined in the builder().
|
| EndpointsForRange.Builder |
|
| EndpointsForToken |
A ReplicaCollection where all Replica are required to cover a range that fully contains the token() defined in the builder().
|
| EndpointsForToken.Builder |
|
| EndpointSnitchInfo |
|
| EndpointSnitchInfoMBean |
MBean exposing standard Snitch info
|
| EndpointState |
This abstraction represents both the HeartBeatState and the ApplicationState in an EndpointState
instance.
|
| EnsureOnHeap |
|
| Envelope |
|
| Envelope.Compressor |
|
| Envelope.Decoder |
|
| Envelope.Decoder.HeaderExtractionResult |
|
| Envelope.Decompressor |
|
| Envelope.Encoder |
|
| Envelope.Header |
|
| Envelope.Header.Flag |
|
| ErrorCollector |
ErrorListener that collect and enhance the errors send by the CQL lexer and parser.
|
| ErrorListener |
Listener used to collect the syntax errors emitted by the Lexer and Parser.
|
| ErrorMessage |
Message to indicate an error to the client.
|
| ErrorMessage.WrappedException |
|
| EstimatedHistogram |
|
| EstimatedHistogram.EstimatedHistogramSerializer |
|
| Event |
|
| Event.NodeEvent |
|
| Event.SchemaChange |
|
| Event.SchemaChange.Change |
|
| Event.SchemaChange.Target |
|
| Event.StatusChange |
|
| Event.StatusChange.Status |
|
| Event.TopologyChange |
|
| Event.TopologyChange.Change |
|
| Event.Type |
|
| EventMessage |
|
| ExceptionCode |
Exceptions code, as defined by the binary protocol.
|
| ExceptionHandlers |
|
| ExcludingBounds<T extends RingPosition<T>> |
AbstractBounds containing neither of its endpoints: (left, right).
|
| ExecuteMessage |
|
| ExecutionFailure |
|
| ExecutorBuilder<E extends java.util.concurrent.ExecutorService> |
Configure an executor before creating it.
|
| ExecutorBuilderFactory<E extends ExecutorPlus,S extends SequentialExecutorPlus> |
Entry point for configuring and creating new executors.
|
| ExecutorBuilderFactory.Jmxable<E extends ExecutorPlus,S extends SequentialExecutorPlus> |
Entry point for configuring and creating new executors.
|
| ExecutorFactory |
Entry point for configuring and creating new executors.
|
| ExecutorFactory.Default |
|
| ExecutorFactory.Global |
|
| ExecutorFactory.LocalAwareSubFactory |
|
| ExecutorFactory.LocalAwareSubFactoryWithJMX |
|
| ExecutorFactory.SimulatorSemantics |
|
| ExecutorLocals |
|
| ExecutorLocals.Impl |
|
| ExecutorPlus |
|
| ExecutorPlus.MaximumPoolSizeListener |
|
| ExecutorUtils |
|
| ExpirationDateOverflowHandling |
|
| ExpirationDateOverflowHandling.ExpirationDateOverflowPolicy |
|
| ExpiringMemoizingSupplier<T> |
An implementation similar to Guava's Suppliers.memoizeWithExpiration(Supplier)
but allowing for memoization to be skipped.
|
| ExpiringMemoizingSupplier.Memoized<T> |
|
| ExpiringMemoizingSupplier.NotMemoized<T> |
|
| ExpiringMemoizingSupplier.ReturnValue<T> |
|
| ExpMovingAverage |
Sample-based exponential moving average.
|
| Expression |
An Expression is an internal representation of an index query operation. |
| Expression |
|
| Expression.Bound |
|
| Expression.Bound |
|
| Expression.IndexedExpression |
|
| Expression.IndexOperator |
|
| Expression.Op |
|
| Expression.UnindexedExpression |
|
| Expression.Value |
A representation of a column value in its raw and encoded form.
|
| ExternalArchiver |
Archives binary log files immediately when they are rolled using a configure archive command.
|
| FailingBiConsumer<A,B> |
|
| FailingConsumer<T> |
|
| FailSession |
|
| FailureDetector |
This FailureDetector is an implementation of the paper titled
"The Phi Accrual Failure Detector" by Hayashibara.
|
| FailureDetectorInfo |
|
| FailureDetectorMBean |
|
| FailureRecordingCallback<T> |
|
| FailureRecordingCallback.AsMap |
|
| FailureRecordingCallback.FailureResponses |
|
| FastByteOperations |
Utility code to do optimized byte-array comparison.
|
| FastByteOperations.ByteOperations |
|
| FastByteOperations.PureJavaOperations |
|
| FastByteOperations.UnsafeOperations |
|
| FBUtilities |
|
| FieldIdentifier |
Identifies a field in a UDT.
|
| File |
A thin wrapper around java.nio.file.Path to provide more ergonomic functionality.
|
| File.WriteMode |
|
| FileAuditLogger |
Synchronous, file-based audit logger; just uses the standard logging mechansim.
|
| FileBasedSslContextFactory |
Abstract implementation for ISslContextFactory using file based, standard keystore format with the ability
to hot-reload the files upon file changes (detected by the last modified timestamp). |
| FileBasedSslContextFactory.FileBasedStoreContext |
|
| FileBasedSslContextFactory.HotReloadableFile |
Helper class for hot reloading SSL Contexts
|
| FileDataInput |
|
| FileDirectSegment |
Writes to the backing commit log file only on sync, allowing transformations of the mutations,
such as compression or encryption, before writing out to disk.
|
| FileHandle |
|
| FileHandle.Builder |
Configures how the file will be read (compressed, mmapped, use cache etc.)
|
| FileInputStreamPlus |
|
| FileOutputStreamPlus |
|
| FileReader |
|
| FileSegmentInputStream |
This is the same as DataInputBuffer, i.e.
|
| FileStoreUtils |
|
| FileSystemOwnershipCheck |
Ownership markers on disk are compatible with the java property file format.
|
| FileUtils |
|
| FileWriter |
|
| Filter |
|
| FilterComponent |
|
| FilteredPartition |
|
| FilteredPartitions |
|
| FilteredRows |
|
| FilterFactory |
|
| FilteringInMemoryKeyRangeIterator |
|
| FilteringPostingList |
A wrapper that iterates over a delegate PostingList, filtering out postings at
positions that are not present in a provided filter. |
| FilterPipeline |
|
| FilterPipeline.Task |
|
| FilterPipelineBuilder |
Creates a Pipeline object for applying n pieces of logic
from the provided methods to the builder in a guaranteed order
|
| FilterPipelineExecutor |
|
| FilterPipelineExecutor |
Executes all linked Pipeline Tasks serially and returns
output (if exists) from the executed logic
|
| FilterPipelineTask<F,T> |
A single task or set of work to process an input
and return a single output.
|
| FilterTree |
Tree-like structure to filter base table data using indexed expressions and non-user-defined filters.
|
| FinalizeCommit |
|
| FinalizePromise |
|
| FinalizePropose |
|
| FixedSpeculativeRetryPolicy |
|
| FloatSerializer |
|
| FloatType |
|
| Flush |
|
| Flushing |
|
| Flushing.FlushRunnable |
|
| ForceCompact |
|
| ForwardingInfo |
A container used to store a node -> message_id map for inter-DC write forwarding.
|
| ForwardingProperty |
This class delegates all calls of Property to a ForwardingProperty.delegate(), used for cases where a small number of
methods want to be overriden from the delegate. |
| FrameDecoder |
A Netty inbound handler that decodes incoming frames and passes them forward to
InboundMessageHandler for processing. |
| FrameDecoder.CorruptFrame |
A corrupted frame was encountered; this represents the knowledge we have about this frame,
and whether or not the stream is recoverable.
|
| FrameDecoder.Frame |
|
| FrameDecoder.FrameProcessor |
|
| FrameDecoder.IntactFrame |
The payload bytes of a complete frame, i.e.
|
| FrameDecoderCrc |
Framing format that protects integrity of data in movement with CRCs (of both header and payload).
|
| FrameDecoderLZ4 |
Framing format that compresses payloads with LZ4, and protects integrity of data in movement with CRCs
(of both header and payload).
|
| FrameEncoder |
|
| FrameEncoder.Payload |
An abstraction useful for transparently allocating buffers that can be written to upstream
of the FrameEncoder without knowledge of the encoder's frame layout, while ensuring
enough space to write the remainder of the frame's contents is reserved.
|
| FrameEncoder.PayloadAllocator |
|
| FrameEncoderCrc |
Please see FrameDecoderCrc for description of the framing produced by this encoder. |
| FrameEncoderLZ4 |
Please see FrameDecoderLZ4 for description of the framing produced by this encoder. |
| FrequencySampler<T> |
Find the most frequent sample.
|
| FromJsonFct |
|
| FrozenType |
A fake type that is only used for parsing type strings that include frozen types.
|
| FSDiskFullWriteError |
|
| FSError |
|
| FSErrorHandler |
Interface for handling file system errors.
|
| FSNoDiskAvailableForWriteError |
Thrown when all the disks used by a given keyspace have been marked as unwriteable.
|
| FSReadError |
|
| FSWriteError |
|
| FullBTreeSearchIterator<K,V> |
|
| FullQueryLogger |
A logger that logs entire query contents after the query finishes (or times out).
|
| FullQueryLogger.Batch |
|
| FullQueryLogger.Query |
|
| FullQueryLoggerOptions |
|
| FullQueryLoggerOptionsCompositeData |
|
| Function |
|
| FunctionArguments |
|
| FunctionCall |
|
| FunctionCall.Raw |
|
| FunctionExecutionException |
|
| FunctionFactory |
Class for dynamically building different overloads of a CQL Function according to specific function calls. |
| FunctionName |
|
| FunctionParameter |
Generic, loose definition of a function parameter, able to infer the specific data type of the parameter in the
function specifically built by a FunctionFactory for a particular function call. |
| FunctionResolver |
|
| FunctionResource |
IResource implementation representing functions.
|
| Future<V> |
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| FutureCombiner<T> |
Netty's PromiseCombiner is not threadsafe, and we combine futures from multiple event executors.
|
| FutureDelegate<V> |
A delegating future, that we can extend to provide subtly modified behaviour.
|
| FutureResult<V> |
An abstraction for yielding a result performed by an asynchronous task,
for whom we may wish to offer cancellation, but no other access to the underlying task
|
| FutureTask<V> |
|
| FutureTaskWithResources<V> |
|
| GarbageCollect |
|
| GaugeProvider<T extends java.lang.Number> |
|
| GCInspector |
|
| GCInspectorMXBean |
|
| GcStats |
|
| GenerateTokens |
|
| GetAuditLog |
|
| GetAuthCacheConfig |
|
| GetBatchlogReplayTrottle |
|
| GetCIDRGroupsOfIP |
Nodetool command to get CIDR groups(s) of given IP
|
| GetColumnIndexSize |
|
| GetCompactionThreshold |
|
| GetCompactionThroughput |
|
| GetConcurrency |
|
| GetConcurrentCompactors |
|
| GetConcurrentViewBuilders |
|
| GetDefaultKeyspaceRF |
|
| GetEndpoints |
|
| GetFullQueryLog |
|
| GetInterDCStreamThroughput |
|
| GetLoggingLevels |
|
| GetMaxHintWindow |
|
| GetSeeds |
|
| GetSnapshotThrottle |
|
| GetSSTables |
|
| GetStreamThroughput |
|
| GettableByIndexData |
Collection of (typed) CQL values that can be retrieved by index (starting at zero).
|
| GettableByNameData |
Collection of (typed) CQL values that can be retrieved by name.
|
| GettableData |
Collection of (typed) CQL values that can be retrieved either by index (starting at zero) or by
name.
|
| GetTimeout |
|
| GetTraceProbability |
|
| GetVersion |
|
| GlobalBufferPoolAllocator |
Primary ByteBuf / ByteBuffer allocator - using the global BufferPool. |
| GoogleCloudSnitch |
A snitch that assumes an GCE region is a DC and an GCE availability_zone
is a rack.
|
| GossipDigest |
Contains information about a specified list of Endpoints and the largest version
of the state they have generated as known by the local endpoint.
|
| GossipDigestAck |
This ack gets sent out as a result of the receipt of a GossipDigestSynMessage by an
endpoint.
|
| GossipDigestAck2 |
This ack gets sent out as a result of the receipt of a GossipDigestAckMessage.
|
| GossipDigestAck2VerbHandler |
|
| GossipDigestAckVerbHandler |
|
| GossipDigestSyn |
This is the first message that gets sent out as a start of the Gossip protocol in a
round.
|
| GossipDigestSynVerbHandler |
|
| Gossiper |
This module is responsible for Gossiping information for the local endpoint.
|
| GossiperEvent |
DiagnosticEvent implementation for Gossiper activities. |
| GossiperEvent.GossiperEventType |
|
| GossiperMBean |
|
| GossipInfo |
|
| GossipingPropertyFileSnitch |
|
| GossipShutdown |
|
| GossipShutdown.Serializer |
|
| GossipShutdownVerbHandler |
|
| GossipVerbHandler<T> |
|
| GrantPermissionsStatement |
|
| GrantRoleStatement |
|
| GroupCommitLogService |
A commitlog service that will block returning an ACK back to the a coordinator/client
for a minimum amount of time as we wait until the the commit log segment is flushed.
|
| GroupingState |
GroupMaker state.
|
| GroupingState.Serializer |
|
| GroupMaker |
A GroupMaker can be used to determine if some sorted rows belongs to the same group or not.
|
| Guardrail |
General class defining a given guardrail that guards against some particular usage/condition.
|
| Guardrails |
Entry point for Guardrails, storing the defined guardrails and providing a few global methods over them.
|
| GuardrailsConfig |
Configuration settings for guardrails.
|
| GuardrailsConfigProvider |
|
| GuardrailsConfigProvider.Default |
|
| GuardrailsMBean |
JMX entrypoint for updating the default guardrails configuration parsed from cassandra.yaml.
|
| GuardrailsOptions |
Configuration settings for guardrails populated from the Yaml file.
|
| GuardrailViolatedException |
|
| GuidGenerator |
|
| HashMaskingFunction |
A MaskingFunction that replaces the specified column value by its hash according to the specified
algorithm. |
| HashPassword |
|
| HeapCloner |
Cloner class that can be use to clone partition elements on heap.
|
| HeapPool |
|
| HeapPool.Allocator |
|
| HeapPool.Logged |
|
| HeapPool.Logged.Listener |
|
| HeapUtils |
Utility to log heap histogram.
|
| HeartBeatState |
HeartBeat State associated with any given endpoint.
|
| Hex |
|
| Hint |
Encapsulates the hinted mutation, its creation time, and the gc grace seconds param for each table involved.
|
| HintedHandoffMetrics |
|
| HintedHandoffMetrics.DifferencingCounter |
|
| HintMessage |
The message we use to dispatch and forward hints.
|
| HintMessage.Serializer |
|
| HintsService |
A singleton-ish wrapper over various hints components:
- a catalog of all hints stores
- a single-threaded write executor
- a multi-threaded dispatch executor
- the buffer pool for writing hints into
- an optional scheduled task to clean up the applicable hints files
The front-end for everything hints related.
|
| HintsServiceMBean |
|
| HintsServiceMetrics |
|
| HintVerbHandler |
Verb handler used both for hint dispatch and streaming.
|
| HistogramBuilder |
Simple class for constructing an EsimtatedHistogram from a set of predetermined values
|
| HistogramDataConsumer<T extends java.lang.Exception> |
This interface exists to avoid boxing primitive ints to Integers (otherwise BiConsumer<Integer, Integer> would have been sufficient).
|
| HostDifferences |
Tracks the differences for a single host
|
| HostStat |
|
| HostStatWithPort |
|
| HybridSpeculativeRetryPolicy |
|
| HybridSpeculativeRetryPolicy.Function |
|
| IAuditLogger |
|
| IAuthenticator |
|
| IAuthenticator.SaslNegotiator |
Performs the actual SASL negotiation for a single authentication attempt.
|
| IAuthorizer |
Primary Cassandra authorization interface.
|
| IBitSet |
|
| ICache<K,V> |
This is similar to the Map interface, but requires maintaining a given capacity
and does not require put or remove to return values, which lets SerializingCache
be more efficient by avoiding deserialize except on get.
|
| ICIDRAuthorizer |
Backend for CIDR authorization feature
|
| ICIDRAuthorizer.CIDRAuthorizerMode |
Supported modes by CIDR authorizer
|
| ICompactionManager |
|
| ICompressor |
|
| ICompressor.Uses |
Ways that a particular instance of ICompressor should be used internally in Cassandra.
|
| IEndpointLifecycleSubscriber |
Interface on which interested parties can be notified of high level endpoint
state changes.
|
| IEndpointSnitch |
This interface helps determine location of node in the datacenter relative to another node.
|
| IEndpointStateChangeSubscriber |
This is called by an instance of the IEndpointStateChangePublisher to notify
interested parties about changes in the the state associated with any endpoint.
|
| IFailureDetectionEventListener |
Implemented by the Gossiper to convict an endpoint
based on the PHI calculated by the Failure Detector on the inter-arrival
times of the heart beats.
|
| IFailureDetector |
An interface that provides an application with the ability
to query liveness information of a node in the cluster.
|
| IFilter |
|
| IFilter.FilterKey |
|
| IGenericSerializer<T,I extends java.io.DataInput,O extends java.io.DataOutput> |
|
| IGossiper |
|
| IInternodeAuthenticator |
|
| IInternodeAuthenticator.InternodeConnectionDirection |
Enum that represents connection type of internode connection.
|
| ILifecycleTransaction |
|
| IMeasurableMemory |
|
| IMergeIterator<In,Out> |
|
| IMetadataComponentSerializer<T extends MetadataComponent> |
Metadata component serializer
|
| IMetadataSerializer |
Interface for SSTable metadata serializer
|
| ImmediateExecutor |
|
| ImmediateFuture<V> |
|
| ImmutableBTreePartition |
|
| Import |
|
| IMutation |
|
| InboundConnectionInitiator |
|
| InboundConnectionSettings |
|
| InboundMessageHandler |
|
| InboundMessageHandlers |
|
| InboundMessageHandlers.GlobalMetricCallbacks |
|
| InboundMessageHandlers.MessageConsumer |
|
| InboundSink |
A message sink that all inbound messages go through.
|
| IncludingExcludingBounds<T extends RingPosition<T>> |
AbstractBounds containing only its left endpoint: [left, right).
|
| IncomingRepairStreamTracker |
Tracks incoming streams for a single host
|
| IncomingStream |
|
| IncomingStreamMessage |
|
| IncompatibleSchemaException |
|
| IncrementalDeepTrieWriterPageAware<VALUE> |
|
| IncrementalRepairTask |
|
| IncrementalTrieWriter<VALUE> |
Common interface for incremental trie writers.
|
| IncrementalTrieWriter.PartialTail |
|
| IncrementalTrieWriterBase<VALUE,DEST,NODE extends org.apache.cassandra.io.tries.IncrementalTrieWriterBase.BaseNode<VALUE,NODE>> |
Helper base class for incremental trie builders.
|
| IncrementalTrieWriterPageAware<VALUE> |
Incremental builders of on-disk tries which packs trie stages into disk cache pages.
|
| IncrementalTrieWriterSimple<VALUE> |
Incremental builder of on-disk tries.
|
| Index |
Consisting of a top level Index interface and two sub-interfaces which handle read and write operations,
Searcher and Indexer respectively, this defines a secondary index implementation.
|
| Index.CollatedViewIndexBuildingSupport |
Default implementation of IndexBuildingSupport which uses a ReducingKeyIterator to obtain a
collated view of the data in the SSTables.
|
| Index.Group |
Class providing grouped operations for indexes that communicate with each other.
|
| Index.Group.Key |
Group key is used to uniquely identify a Index.Group within a table |
| Index.IndexBuildingSupport |
Provider of SecondaryIndexBuilder instances.
|
| Index.Indexer |
Listener for processing events emitted during a single partition update.
|
| Index.LoadType |
Supported loads.
|
| Index.QueryPlan |
Specifies a set of compatible indexes to be used with a query according to its RowFilter, ignoring data
ranges, limits, etc. |
| Index.Searcher |
Performs the actual index lookup during execution of a ReadCommand.
|
| Index.Status |
|
| IndexAttributes |
|
| IndexComponent |
This is a definitive list of all the on-disk components for all versions
|
| IndexComponent |
|
| IndexDescriptor |
|
| IndexedSearchIterator<K,V> |
|
| IndexedTerm |
|
| IndexEntry |
Entries in indexes on non-compact tables (tables with composite comparators)
can be encapsulated as IndexedEntry instances.
|
| IndexEntry |
|
| Indexes |
For backwards compatibility, in the first instance an IndexMetadata must have
TargetType.COLUMN and its Set of target columns must contain only a single
ColumnIdentifier.
|
| Indexes.Builder |
|
| IndexFileUtils |
|
| IndexGroupMetrics |
|
| IndexIdentifier |
This is a simple wrapper around the index identity.
|
| IndexInfo |
|
| IndexInfo.Serializer |
|
| IndexInputReader |
This is a wrapper over a Cassandra RandomAccessReader that provides an IndexInput
interface for Lucene classes that need IndexInput. |
| IndexMemtable |
|
| IndexMetadata |
An immutable representation of secondary index metadata.
|
| IndexMetadata.Kind |
|
| IndexMetadata.Serializer |
|
| IndexMetrics |
|
| IndexMode |
|
| IndexNotAvailableException |
Thrown if a secondary index is not currently available.
|
| IndexOutputWriter |
This is a wrapper over a Cassandra SequentialWriter that provides a Lucene IndexOutput
interface for the Lucene index writers. |
| IndexRegistry |
The collection of all Index instances for a base table.
|
| IndexRestrictions |
|
| IndexSearchResultIterator |
|
| IndexSegmentSearcher |
Abstract reader for individual segments of an on-disk index.
|
| IndexSegmentSearcherContext |
|
| IndexState |
|
| IndexStatusManager |
Handles the status of an index across the ring, updating the status per index and endpoint
in a per-endpoint map.
|
| IndexSummary |
|
| IndexSummary.IndexSummarySerializer |
|
| IndexSummaryBuilder |
|
| IndexSummaryBuilder.ReadableBoundary |
Represents a boundary that is guaranteed fully readable in the summary, index file and data file.
|
| IndexSummaryComponent |
|
| IndexSummaryManager<T extends SSTableReader & IndexSummarySupport<T>> |
Manages the fixed-size memory pool for index summaries, periodically resizing them
in order to give more memory to hot sstables and less memory to cold sstables.
|
| IndexSummaryManagerMBean |
|
| IndexSummaryMetrics<R extends SSTableReader & IndexSummarySupport<R>> |
|
| IndexSummaryRedistribution |
|
| IndexSummarySupport<T extends SSTableReader & IndexSummarySupport<T>> |
|
| IndexTarget |
|
| IndexTarget.Raw |
|
| IndexTarget.Type |
|
| IndexTermType |
This class is a representation of an AbstractType as an indexable type. |
| IndexTransaction |
Base interface for the handling of index updates.
|
| IndexTransaction.Type |
Used to differentiate between type of index transaction when obtaining
a handler from Index implementations.
|
| IndexValidation |
|
| IndexViewManager |
Maintain an atomic view for read requests, so that requests can read all data during concurrent compactions.
|
| IndexWriterConfig |
Per-index config for storage-attached index writers.
|
| InetAddressAndPort |
A class to replace the usage of InetAddress to identify hosts in the cluster.
|
| InetAddressAndPort.FwdFrmSerializer |
Serializer for handling FWD_FRM message parameters.
|
| InetAddressAndPort.Serializer |
As of version 4.0 the endpoint description includes a port number as an unsigned short
|
| InetAddressSerializer |
|
| InetAddressType |
|
| INetworkAuthorizer |
|
| InfiniteLoopExecutor |
|
| InfiniteLoopExecutor.Daemon |
|
| InfiniteLoopExecutor.InternalState |
|
| InfiniteLoopExecutor.Interrupts |
|
| InfiniteLoopExecutor.SimulatorSafe |
|
| Info |
|
| InheritingClass |
|
| InitialConnectionHandler |
Added to the Netty pipeline whenever a new Channel is initialized.
|
| InitialSSTableAddedNotification |
Fired when we load SSTables during the Cassandra initialization phase.
|
| InMemoryKeyRangeIterator |
|
| InMemoryPartitionIterator |
|
| InMemoryReadTrie<T> |
In-memory trie built for fast modification and reads executing concurrently with writes from a single mutator thread.
|
| InMemoryTrie<T> |
In-memory trie built for fast modification and reads executing concurrently with writes from a single mutator thread.
|
| InMemoryTrie.SpaceExhaustedException |
Because we use buffers and 32-bit pointers, the trie cannot grow over 2GB of size.
|
| InMemoryTrie.UpsertTransformer<T,U> |
|
| InMemoryUnfilteredPartitionIterator |
|
| INodeProbeFactory |
|
| INotification |
Created by IntelliJ IDEA.
|
| INotificationConsumer |
|
| InOurDc |
|
| InputPosition |
Marker interface for file positions as provided by the various ChecksummedDataReader implementations.
|
| InstrumentingCache<K,V> |
Wraps an ICache in requests + hits tracking.
|
| Int32Serializer |
|
| Int32Serializer |
|
| Int32Type |
|
| Int64Serializer |
|
| IntArrayPostingList |
|
| IntegerInterval |
Mutable integer interval class, thread-safe.
|
| IntegerInterval.Set |
A mutable set of closed integer intervals, stored in normalized form (i.e.
|
| IntegerSerializer |
|
| IntegerType |
|
| IntegralSA |
|
| Intercept |
|
| InternodeConnectionUtils |
Class that contains certificate utility methods.
|
| InternodeConnectionUtils.ByteBufDiscardHandler |
Discard handler releases the received data silently.
|
| InternodeInboundMetrics |
Metrics for internode connections.
|
| InternodeInboundTable |
|
| InternodeOutboundMetrics |
Metrics for internode connections.
|
| InternodeOutboundTable |
|
| Interruptible |
|
| Interruptible.SimpleTask |
A Task that only runs on NORMAL states
|
| Interruptible.State |
|
| Interruptible.Task |
|
| Interruptible.TerminateException |
|
| Interval<C,D> |
|
| IntervalSet<T extends java.lang.Comparable<T>> |
An immutable set of closed intervals, stored in normalized form (i.e.
|
| IntervalSet.Builder<T extends java.lang.Comparable<T>> |
Builder of interval sets, applying the necessary normalization while adding ranges.
|
| IntervalTree<C extends java.lang.Comparable<? super C>,D,I extends Interval<C,D>> |
|
| IntervalTree.Serializer<C extends java.lang.Comparable<? super C>,D,I extends Interval<C,D>> |
|
| IntrusiveStack<T extends IntrusiveStack<T>> |
An efficient stack/list that is expected to be ordinarily either empty or close to, and for which
we need concurrent insertions and do not need to support removal - i.e.
|
| IntrusiveStack.Setter<O,T> |
|
| InvalidateCIDRPermissionsCache |
Nodetool command to invalidate CIDR permissions cache, for a give role or for all roles in the cache.
|
| InvalidateCounterCache |
|
| InvalidateCredentialsCache |
|
| InvalidateJmxPermissionsCache |
|
| InvalidateKeyCache |
|
| InvalidateNetworkPermissionsCache |
|
| InvalidatePermissionsCache |
|
| InvalidateRolesCache |
|
| InvalidateRowCache |
|
| InvalidRequestException |
|
| InvalidTypeException |
Thrown when a TypeCodec is unable to perform the requested
operation (serialization, deserialization, parsing or formatting) because the object or the byte
buffer content being processed does not comply with the expected Java and/or CQL type. |
| IOOptions |
|
| IPartitioner |
|
| IPartitionerDependentSerializer<T> |
Versioned serializer where the serialization depends on partitioner.
|
| IResource |
The interface at the core of Cassandra authorization.
|
| IRoleManager |
Responsible for managing roles (which also includes what
used to be known as users), including creation, deletion,
alteration and the granting and revoking of roles to other
roles.
|
| IRoleManager.Option |
Supported options for CREATE ROLE/ALTER ROLE (and
CREATE USER/ALTER USER, which are aliases provided
for backwards compatibility).
|
| IRowCacheEntry |
|
| IsBootstrappingException |
|
| IScrubber |
|
| IScrubber.Options |
|
| IScrubber.Options.Builder |
|
| IScrubber.ScrubResult |
|
| ISerializer<T> |
|
| Isolated |
Tells jvm-dtest that a class should be isolated and loaded into the instance class loader.
|
| ISslContextFactory |
The purpose of this interface is to provide pluggable mechanism for creating custom JSSE and Netty SSLContext
objects.
|
| ISslContextFactory.SocketType |
Indicates if the process holds the inbound/listening (Server) end of the socket or the outbound side (Client).
|
| ISSTableScanner |
An ISSTableScanner is an abstraction allowing multiple SSTableScanners to be
chained together under the hood.
|
| IStreamReader |
This is the interface is used by the streaming code read a SSTable stream off a channel.
|
| IteratorWithLowerBound<In> |
|
| ITrigger |
|
| IValidationManager |
|
| IVerbHandler<T> |
IVerbHandler provides the method that all verb handlers need to implement.
|
| IVerifier |
|
| IVerifier.Options |
|
| IVerifier.Options.Builder |
|
| IVersionedAsymmetricSerializer<In,Out> |
|
| IVersionedSerializer<T> |
|
| JavaBasedUDFunction |
|
| JavaDriverUtils |
|
| JavaUDF |
Base class for all Java UDFs.
|
| JavaUtils |
Utility method to retrieve information about the JRE.
|
| JKSKeyProvider |
A KeyProvider that retrieves keys from a java keystore.
|
| JMXBroadcastExecutor |
Holds dedicated executor for JMX event handling.
|
| JMXNotificationProgressListener |
JMXNotificationProgressListener uses JMX Notification API to convert JMX Notification message to progress event
and notifies its ProgressListeners. |
| JMXProgressSupport |
ProgressListener that translates ProgressEvent to JMX Notification message.
|
| JMXResource |
|
| JMXServerUtils |
|
| JMXServerUtils.JmxRegistry |
|
| JMXTool |
|
| JMXTool.Attribute |
|
| JMXTool.CliPattern |
|
| JMXTool.Diff |
|
| JMXTool.Diff.Format |
|
| JMXTool.Dump |
|
| JMXTool.Dump.Format |
|
| JMXTool.Info |
|
| JMXTool.Operation |
|
| JMXTool.Parameter |
|
| JobState |
|
| JobState.State |
|
| Join |
|
| JREProvider |
Crypto provider which does nothing.
|
| Json |
Term-related classes for INSERT JSON support.
|
| Json.Literal |
Represents a literal JSON string in an INSERT JSON statement.
|
| Json.Marker |
Represents a marker for a JSON string in an INSERT JSON statement.
|
| Json.Prepared |
A prepared, full set of JSON values.
|
| Json.Raw |
|
| JsonTransformer |
|
| JsonUtils |
|
| JVMStabilityInspector |
Responsible for deciding whether to kill the JVM if it gets in an "unstable" state (think OOM).
|
| JVMStabilityInspector.Killer |
|
| JVMStabilityInspector.OnKillHook |
This class is usually used to avoid JVM exit when running junit tests.
|
| KeepAliveMessage |
|
| KeyAnalyzer<K> |
|
| KeyCache |
A simple wrapper of possibly global cache with local metrics.
|
| KeyCacheKey |
|
| KeyCacheMetrics<R extends SSTableReader & KeyCacheSupport<R>> |
|
| KeyCacheSupport<T extends SSTableReader & KeyCacheSupport<T>> |
|
| KeyIterator |
|
| KeyLookup |
Provides read access to an on-disk sequence of partition or clustering keys written by KeyStoreWriter. |
| KeyLookupMeta |
|
| KeyProvider |
Customizable key retrieval mechanism.
|
| KeyRangeConcatIterator |
KeyRangeConcatIterator takes a list of sorted range iterators and concatenates them, leaving duplicates in
place, to produce a new stably sorted iterator. |
| KeyRangeConcatIterator.Builder |
|
| KeyRangeIntersectionIterator |
A simple intersection iterator that makes no real attempts at optimising the iteration apart from
initially sorting the ranges.
|
| KeyRangeIntersectionIterator.Builder |
|
| KeyRangeIterator |
An abstract implementation of AbstractGuavaIterator that supports the building and management of
concatanation, union and intersection iterators. |
| KeyRangeIterator |
|
| KeyRangeIterator.Builder |
|
| KeyRangeIterator.Builder.Statistics |
|
| KeyRangeListIterator |
|
| KeyRangeOrderingIterator |
An iterator that consumes a chunk of PrimaryKeys from the KeyRangeIterator, passes them to the
Function to filter the chunk of PrimaryKeys and then pass the results to next consumer. |
| KeyRangeUnionIterator |
Range Union Iterator is used to return sorted stream of elements from multiple RangeIterator instances.
|
| KeyRangeUnionIterator.Builder |
|
| KeyReader |
Reads keys from an SSTable.
|
| KeysIndex |
|
| Keyspace |
It represents a Keyspace.
|
| KeyspaceAttributes |
|
| KeyspaceMetadata |
An immutable representation of keyspace metadata (name, params, tables, types, and functions).
|
| KeyspaceMetadata.KeyspaceDiff |
|
| KeyspaceMetadata.Kind |
|
| KeyspaceMetrics |
|
| KeyspaceNotDefinedException |
|
| KeyspaceParams |
An immutable class representing keyspace parameters (durability and replication).
|
| KeyspaceParams.Option |
|
| KeyspaceRepairManager |
Keyspace level hook for repair.
|
| Keyspaces |
|
| Keyspaces.Builder |
|
| Keyspaces.KeyspacesDiff |
|
| KeyspaceWriteHandler |
|
| KeysSearcher |
|
| KeyStoreWriter |
Writes a sequence of partition keys or clustering keys for use with KeyLookup. |
| LastEventIdBroadcasterMBean |
Provides a list of event types and the corresponding highest event IDs.
|
| LatencyConsumer |
|
| LatencyMetrics |
Metrics about latencies
|
| LatencySubscribers |
|
| LatencySubscribers.Subscriber |
|
| LazilyInitializedUnfilteredRowIterator |
Abstract class to create UnfilteredRowIterator that lazily initializes itself.
|
| LazyToString |
|
| LeafBTreeSearchIterator<K,V> |
|
| LegacyTimeUUIDType |
|
| LengthAvailableInputStream |
a FilterInputStream that returns the remaining bytes to read from available()
regardless of whether the device is ready to provide them.
|
| LeveledCompactionStrategy |
|
| LeveledCompactionTask |
|
| LeveledManifest |
|
| LeveledManifest.CompactionCandidate |
|
| LexicalUUIDType |
|
| LexicalUUIDType.Serializer |
|
| LifecycleNewTracker |
An interface for tracking new sstables added to a LifecycleTransaction, possibly through some proxy.
|
| LifecycleTransaction |
IMPORTANT: When this object is involved in a transactional graph, for correct behaviour its commit MUST occur before
any others, since it may legitimately fail.
|
| LifecycleTransaction.ReaderState |
|
| LifecycleTransaction.ReaderState.Action |
|
| LightweightRecycler<T> |
A simple thread local object reuse facility with limited capacity and no attempt at rebalancing pooling between
threads.
|
| LimitingRebufferer |
Rebufferer wrapper that applies rate limiting.
|
| ListCIDRGroups |
|
| ListPendingHints |
|
| ListPermissionsStatement |
|
| ListRolesStatement |
|
| Lists |
Static helper methods and classes for lists.
|
| Lists.Appender |
|
| Lists.DelayedValue |
Basically similar to a Value, but with some non-pure function (that need
to be evaluated at execution time) in it.
|
| Lists.Discarder |
|
| Lists.DiscarderByIndex |
|
| Lists.Literal |
|
| Lists.Marker |
A marker for List values and IN relations
|
| Lists.Prepender |
|
| Lists.Setter |
|
| Lists.SetterByIndex |
|
| Lists.Value |
|
| ListSerializer<T> |
|
| ListSnapshots |
|
| ListType<T> |
|
| ListUsersStatement |
|
| LiteralIndexSegmentSearcher |
Executes Expressions against the trie-based terms dictionary for an individual index segment. |
| LiteralIndexSegmentTermsReader |
Synchronous reader of terms dictionary and postings lists to produce a PostingList with matching row ids. |
| LiteralIndexWriter |
Builds an on-disk inverted index structure: terms dictionary and postings lists.
|
| LivenessInfo |
Stores the information relating to the liveness of the primary key columns of a row.
|
| LoadBroadcaster |
|
| Loader |
|
| LoaderOptions |
|
| LoadingMap<K,V> |
An extension of NonBlockingHashMap where all values are wrapped by Future. |
| LoadingMap.UnloadExecutionException |
Thrown when unloading a value failed.
|
| LocalAwareExecutorPlus |
An ExecutorPlus that is aware of, and propagates to execution, any ExecutorLocals |
| LocalAwareSequentialExecutorPlus |
|
| LocalAwareSingleThreadExecutorPlus |
|
| LocalAwareThreadPoolExecutorPlus |
|
| LocalDate |
A date with no time components, no time zone, in the ISO 8601 calendar.
|
| LocalPartitioner |
|
| LocalReadSizeTooLargeException |
|
| LocalRepairTables |
|
| LocalSession |
Basically just a record of a local session.
|
| LocalSession.Builder |
|
| LocalSessionInfo |
helper for JMX management functions
|
| LocalSessions |
Manages all consistent repair sessions a node is participating in.
|
| LocalSessions.Listener |
|
| LocalStrategy |
|
| LocalSyncTask |
LocalSyncTask performs streaming between local(coordinator) node and remote replica.
|
| LockedDynamicList<E> |
|
| LogbackLoggingSupport |
Encapsulates all logback-specific implementations in a central place.
|
| LoggingSupport |
Common abstraction of functionality which can be implemented for different logging backend implementations (slf4j bindings).
|
| LoggingSupportFactory |
Dynamically loads and instantiates an appropriate LoggingSupport implementation according to the used slf4j binding. |
| LogMessagesTable |
Virtual table for holding Cassandra logs.
|
| LogMessagesTable.LogMessage |
|
| LogReplicaSet |
A set of log replicas.
|
| LongAccumulator<T> |
|
| LongArray |
Abstraction over a long-indexed array of longs.
|
| LongArray.DeferredLongArray |
|
| LongArray.Factory |
|
| LongSerializer |
|
| LongTimSort |
A stable, adaptive, iterative mergesort that requires far fewer than
n lg(n) comparisons when running on partially sorted arrays, while
offering performance comparable to a traditional mergesort when run
on random arrays.
|
| LongTimSort.LongComparator |
|
| LongType |
|
| LZ4Compressor |
|
| MajorLeveledCompactionWriter |
|
| MappedBuffer |
|
| Maps |
Static helper methods and classes for maps.
|
| Maps.DelayedValue |
|
| Maps.DiscarderByKey |
|
| Maps.Literal |
|
| Maps.Marker |
|
| Maps.Putter |
|
| Maps.Setter |
|
| Maps.SetterByKey |
|
| Maps.Value |
|
| MapSerializer<K,V> |
|
| MapType<K,V> |
|
| MarshalException |
|
| MaskingFcts |
A collection of MaskingFunctions for dynamic data masking, meant to obscure the real value of a column. |
| MaskingFunction |
A NativeScalarFunction that totally or partially replaces the original value of a column value,
meant to obscure the real value of the column. |
| MaskingFunction.Factory |
|
| MathFcts |
|
| MaxSampler<T> |
Note: Sampler.samplerExecutor is single threaded but we still need to synchronize as we have access
from both internal and the external JMX context that can cause races. |
| MaxSSTableSizeWriter |
|
| MaxThreshold |
MaxThreshold for maximum guardrails, the value is checked to see if it is greater than the warn and fail thresholds. |
| MBeanWrapper |
Helper class to avoid catching and rethrowing checked exceptions on MBean and
allow turning of MBean registration for test purposes.
|
| MBeanWrapper.DelegatingMbeanWrapper |
|
| MBeanWrapper.InstanceMBeanWrapper |
|
| MBeanWrapper.NoOpMBeanWrapper |
|
| MBeanWrapper.OnException |
|
| MBeanWrapper.PlatformMBeanWrapper |
|
| MD5Digest |
The result of the computation of an MD5 digest.
|
| MemIndex |
|
| Memory |
An off-heap region of memory that must be manually free'd when no longer needed.
|
| MemoryIndex |
|
| MemoryInputStream |
|
| MemoryMappedSegment |
|
| MemoryMappedSegment.MemoryMappedSegmentBuilder |
|
| MemoryOutputStream |
This class provides a way to stream the writes into the Memory |
| MemoryUtil |
|
| Memtable |
Memtable interface.
|
| Memtable.Factory |
Factory interface for constructing memtables, and querying write durability features.
|
| Memtable.FlushablePartitionSet<P extends Partition> |
A collection of partitions for flushing plus some information required for writing an sstable.
|
| Memtable.LastCommitLogPosition |
|
| Memtable.MemoryUsage |
|
| Memtable.Owner |
Interface for providing signals back and requesting information from the owner, i.e.
|
| MemtableAllocator |
|
| MemtableAllocator.SubAllocator |
Mark the BB as unused, permitting it to be reclaimed
|
| MemtableBufferAllocator |
|
| MemtableCleaner |
The cleaner is used by MemtableCleanerThread in order to reclaim space from memtables, normally
by flushing the largest memtable. |
| MemtableCleanerThread<P extends MemtablePool> |
A thread that reclaims memory from a MemtablePool on demand.
|
| MemtableDiscardedNotification |
|
| MemtableIndex |
|
| MemtableIndexManager |
|
| MemtableIndexWriter |
Column index writer that flushes indexed data directly from the corresponding Memtable index, without buffering index
data in memory.
|
| MemtableOrdering |
|
| MemtableParams |
Memtable types and options are specified with these parameters.
|
| MemtablePool |
Represents an amount of memory used for a given purpose, that can be allocated to specific tasks through
child MemtableAllocator objects.
|
| MemtableRenewedNotification |
|
| MemtableSwitchedNotification |
|
| MemtableTermsIterator |
Iterator over a token range bounded segment of a Memtable index.
|
| MergeIterator<In,Out> |
Merges sorted input iterators which individually contain unique items.
|
| MergeIterator.Candidate<In> |
|
| MergeIterator.Reducer<In,Out> |
Accumulator that collects values of type A, and outputs a value of type B.
|
| MergePostingList |
Merges multiple PostingList which individually contain unique items into a single list. |
| MerkleTree |
A MerkleTree implemented as a binary tree.
|
| MerkleTree.RowHash |
Hash value representing a row, to be used to pass hashes to the MerkleTree.
|
| MerkleTree.TreeRange |
The public interface to a range in the tree.
|
| MerkleTree.TreeRangeIterator |
Returns the leaf (range) of a given tree in increasing order.
|
| MerkleTrees |
Wrapper class for handling of multiple MerkleTrees at once.
|
| MerkleTrees.MerkleTreesSerializer |
|
| Message<T> |
Immutable main unit of internode communication - what used to be MessageIn and MessageOut fused
in one class.
|
| Message |
A message from the CQL binary protocol.
|
| Message.Builder<T> |
|
| Message.Codec<M extends Message> |
|
| Message.Direction |
|
| Message.Header |
Split into a separate object to allow partial message deserialization without wasting work and allocation
afterwards, if the entire message is necessary and available.
|
| Message.InvalidLegacyProtocolMagic |
|
| Message.Request |
|
| Message.Response |
|
| Message.Serializer |
Each message contains a header with several fixed fields, an optional key-value params section, and then
the message payload itself.
|
| Message.Type |
|
| MessageDelivery |
|
| MessageFlag |
Binary message flags to be passed as flags field of Message. |
| MessageParams |
|
| MessagingMetrics |
Metrics for messages
|
| MessagingMetrics.DCLatencyRecorder |
|
| MessagingService |
MessagingService implements all internode communication - with the exception of SSTable streaming (for now).
|
| MessagingService.FailureResponseException |
|
| MessagingService.Version |
|
| MessagingServiceMBean |
MBean exposing MessagingService metrics plus allowing to enable/disable back-pressure.
|
| MessagingServiceMBeanImpl |
|
| Metadata |
Keeps metadata on the connected cluster, including known nodes and schema definitions.
|
| MetadataCollector |
|
| MetadataCollector.MinMaxIntTracker |
|
| MetadataCollector.MinMaxLongTracker |
|
| MetadataComponent |
MetadataComponent is a component for SSTable metadata and serialized to Stats.db.
|
| MetadataSerializer |
Metadata serializer for SSTables version >= 'na'.
|
| MetadataSource |
|
| MetadataType |
Defines Metadata component type.
|
| MetadataWriter |
|
| MetricNameFactory |
|
| MetricsProviders |
|
| MigrationCoordinator |
Migration coordinator is responsible for tracking schema versions on various nodes and, if needed, synchronize the
schema.
|
| MinMaxAvgMetric |
|
| MinThreshold |
MinThreshold for minimum guardrails, the value is checked to see if it is lesser than the warn and fail thresholds. |
| MmappedRegions |
|
| MmappedRegions.Region |
|
| MmappedRegions.Tidier |
|
| MmappedRegionsCache |
It is a utility class for caching MmappedRegions primarily used by a FileHandle.Builder when a handle
to the same file is created multiple times (as when an sstable is opened early). |
| ModificationStatement |
|
| ModificationStatement.Parsed |
|
| Monitorable |
|
| MonitorableImpl |
|
| MonitoringState |
|
| MonotonicBlockPackedReader |
|
| MonotonicBlockPackedWriter |
A writer for large monotonically increasing sequences of positive longs.
|
| MonotonicClock |
Wrapper around time related functions that are either implemented by using the default JVM calls
or by using a custom implementation for testing purposes.
|
| MonotonicClock.AbstractEpochSamplingClock |
|
| MonotonicClock.AbstractEpochSamplingClock.AlmostSameTime |
|
| MonotonicClock.Global |
|
| MonotonicClock.SampledClock |
|
| MonotonicClock.SystemClock |
|
| MonotonicClockTranslation |
|
| MorePartitions<I extends BasePartitionIterator<?>> |
An interface for providing new partitions for a partitions iterator.
|
| MoreRows<I extends BaseRowIterator<?>> |
An interface for providing new row contents for a partition.
|
| Move |
|
| MovingAverage |
|
| MulticastQueryEventListeners |
|
| MulticastQueryEventListeners.Multicast2BalancedTreeEventListener |
|
| MulticastQueryEventListeners.Multicast2BalancedTreePostingListEventListener |
|
| MulticastQueryEventListeners.Multicast2TrieIndexEventListener |
|
| MulticastQueryEventListeners.Multicast2TriePostingListEventListener |
|
| MultiCBuilder |
Builder that allow to build multiple Clustering/ClusteringBound at the same time.
|
| MultiColumnRelation |
A relation using the tuple notation, which typically affects multiple columns.
|
| MultiColumnRestriction |
|
| MultiColumnRestriction.EQRestriction |
|
| MultiColumnRestriction.INRestriction |
|
| MultiColumnRestriction.InRestrictionWithMarker |
An IN restriction that uses a single marker for a set of IN values that are tuples.
|
| MultiColumnRestriction.InRestrictionWithValues |
An IN restriction that has a set of terms for in values.
|
| MultiColumnRestriction.NotNullRestriction |
|
| MultiColumnRestriction.SliceRestriction |
|
| MultiPartitionPager<T extends SinglePartitionReadQuery> |
Pager over a list of SinglePartitionReadQuery.
|
| Murmur3Partitioner |
This class generates a BigIntegerToken using a Murmur3 hash.
|
| Murmur3Partitioner.LongToken |
|
| MurmurHash |
This is a very fast, non-cryptographic hash suitable for general hash-based
lookup.
|
| MutableDeletionInfo |
A mutable implementation of DeletionInfo.
|
| MutableDeletionInfo.Builder |
Builds DeletionInfo object from (in order) range tombstone markers.
|
| Mutation |
|
| Mutation.MutationSerializer |
|
| Mutation.PartitionUpdateCollector |
Collects finalized partition updates
|
| Mutation.SimpleBuilder |
Interface for building mutations geared towards human.
|
| MutationExceededMaxSizeException |
|
| MutationVerbHandler |
|
| MutualTlsAuthenticator |
|
| MutualTlsCertificateValidator |
Interface for certificate validation and authorization for mTLS authenticators.
|
| MutualTlsInternodeAuthenticator |
|
| MutualTlsWithPasswordFallbackAuthenticator |
This authenticator can be used in optional mTLS mode, If the client doesn't make an mTLS connection
this fallbacks to password authentication.
|
| Mx4jTool |
If mx4j-tools is in the classpath call maybeLoad to load the HTTP interface of mx4j.
|
| NamedMemoryLimiter |
A simple, thread-safe memory usage tracker, named to reflect a particular scope.
|
| NamedThreadFactory |
This class is an implementation of the ThreadFactory interface.
|
| NamedThreadFactory.MetaFactory |
|
| NativeAccessMBean |
|
| NativeAggregateFunction |
Base class for the AggregateFunction native classes.
|
| NativeAllocator |
This NativeAllocator uses global slab allocation strategy
with slab size that scales exponentially from 8KiB to 1MiB to
serve allocation of up to 128KiB.
|
| NativeCell |
|
| NativeClustering |
|
| NativeDecoratedKey |
|
| NativeFunction |
Base class for our native/hardcoded functions.
|
| NativeFunctions |
A container of native functions.
|
| NativeLibrary |
|
| NativeLibrary.OSType |
|
| NativeLibraryDarwin |
A NativeLibraryWrapper implementation for Darwin/Mac.
|
| NativeLibraryLinux |
A NativeLibraryWrapper implementation for Linux.
|
| NativeLibraryWrapper |
An interface to implement for using OS specific native methods.
|
| NativePool |
|
| NativeScalarFunction |
Base class for the ScalarFunction native classes.
|
| NativeSSTableLoaderClient |
|
| NativeTransportService |
Handles native transport server lifecycle and associated resources.
|
| Nemesis |
Annotate fields, particularly important volatile fields, where the system should adversarially schedule
thread events around memory accesses (read or write).
|
| Nemesis.Traffic |
|
| NetStats |
|
| NettyStreamingChannel |
|
| NettyStreamingConnectionFactory |
|
| NetworkPermissionsCache |
|
| NetworkPermissionsCacheMBean |
|
| NetworkTopologyStrategy |
This Replication Strategy takes a property file that gives the intended
replication factor in each datacenter.
|
| NeverSpeculativeRetryPolicy |
|
| NIODataInputStream |
Rough equivalent of BufferedInputStream and DataInputStream wrapping the input stream of a File or Socket
Created to work around the fact that when BIS + DIS delegate to NIO for socket IO they will allocate large
thread local direct byte buffers when a large array is used to read.
|
| NodeProbe |
JMX client operations for Cassandra.
|
| NodeTool |
|
| NodeTool.CassHelp |
|
| NodeTool.NodeToolCmd |
|
| NodeTool.NodeToolCmd.KeyspaceSet |
|
| NonBlockingRateLimiter |
A rate limiter implementation that allows callers to reserve permits that may only be available
in the future, delegating to them decisions about how to schedule/delay work and whether or not
to block execution to do so.
|
| NonTokenizingAnalyzer |
Analyzer that does *not* tokenize the input.
|
| NonTokenizingAnalyzer |
Analyzer that does *not* tokenize the input.
|
| NonTokenizingOptions |
|
| NonTokenizingOptions |
|
| NonTokenizingOptions.OptionsBuilder |
|
| NonTokenizingOptions.OptionsBuilder |
|
| NoOpAnalyzer |
Default noOp tokenizer.
|
| NoOpAuditLogger |
No-Op implementation of IAuditLogger to be used as a default audit logger when audit logging is disabled. |
| NoopCompressor |
A Compressor which doesn't actually compress any data.
|
| NoOpFallbackLoggingSupport |
A fallback implementation with empty implementations which ensures other slf4j bindings (logging implementations)
than the default supported framework can be used.
|
| NoopReadRepair<E extends Endpoints<E>,P extends ReplicaPlan.ForRead<E,P>> |
Bypasses the read repair path for short read protection and testing
|
| NoPayload |
Empty message payload - primarily used for responses.
|
| NopCacheProvider |
|
| NoReplicationTokenAllocator<Unit> |
|
| NormalRepairTask |
|
| NoSpamLogger |
Logging that limits each log statement to firing based on time since the statement last fired.
|
| NoSpamLogger.Clock |
|
| NoSpamLogger.Level |
Levels for programmatically specifying the severity of a log statement
|
| NoSuchRepairSessionException |
|
| NotScheduledFuture<T> |
|
| NullableSerializer |
|
| NullMaskingFunction |
|
| NumberType<T extends java.lang.Number> |
Base type for the numeric types.
|
| NumberType.NumberArgumentDeserializer<M extends org.apache.commons.lang3.mutable.Mutable<java.lang.Number>> |
|
| NumericIndexSegmentSearcher |
Executes Expressions against the balanced tree for an individual index segment. |
| NumericIndexWriter |
Specialized writer for values, that builds them into a BlockBalancedTreeWriter with auxiliary
posting lists on eligible tree levels. |
| NumericValuesMeta |
|
| NumericValuesWriter |
|
| ObjectSizes |
A convenience class for wrapping access to MemoryMeter.
|
| OffHeapBitSet |
Off-heap bitset,
file compatible with OpeBitSet
|
| OfflineSchemaUpdateHandler |
Update handler which works only in memory.
|
| OfflineTokenAllocator |
|
| OfflineTokenAllocator.FakeNode |
|
| OHCProvider |
|
| OnDiskBlock<T extends Term> |
|
| OnDiskBlock.BlockType |
|
| OnDiskBlock.SearchResult<T> |
|
| OnDiskFormat |
An interface to the on-disk format of an index.
|
| OnDiskIndex |
|
| OnDiskIndex.IteratorOrder |
|
| OnDiskIndex.PointerTerm |
|
| OnDiskIndexBuilder |
|
| OnDiskIndexBuilder.Mode |
|
| OnDiskIndexBuilder.TermSize |
|
| OnDiskIndexIterator |
|
| OnDiskOrdinalsMap |
|
| OnHeapGraph<T> |
|
| OnHeapGraph.InvalidVectorBehavior |
|
| Operation |
An UPDATE or DELETE operation.
|
| Operation |
|
| Operation |
|
| Operation.Addition |
|
| Operation.BooleanOperator |
|
| Operation.Builder |
|
| Operation.ColumnDeletion |
|
| Operation.ElementDeletion |
|
| Operation.FieldDeletion |
|
| Operation.OperationType |
|
| Operation.Prepend |
|
| Operation.RawDeletion |
A parsed raw DELETE operation.
|
| Operation.RawUpdate |
A parsed raw UPDATE operation.
|
| Operation.SetElement |
|
| Operation.SetField |
|
| Operation.SetValue |
|
| Operation.Substraction |
|
| OperationExecutionException |
Thrown when an operation problem has occured (e.g.
|
| OperationFcts |
Operation functions (Mathematics).
|
| Operations |
A set of Operations.
|
| OperationType |
|
| Operator |
|
| OpOrder |
A class for providing synchronization between producers and consumers that do not
communicate directly with each other, but where the consumers need to process their
work in contiguous batches.
|
| OpOrder.Group |
Represents a group of identically ordered operations, i.e.
|
| OptimizeFor |
Allows the vector index searches to be optimised for latency or recall.
|
| OptionsMessage |
Message to indicate that the server is ready to receive requests.
|
| Ordering |
A single element of an ORDER BY clause.
|
| Ordering.Ann |
An expression used in Approximate Nearest Neighbor ordering.
|
| Ordering.Direction |
|
| Ordering.Expression |
|
| Ordering.Raw |
Represents ANTLR's abstract syntax tree of a single element in the ORDER BY clause.
|
| Ordering.Raw.Ann |
|
| Ordering.Raw.Expression |
|
| Ordering.Raw.SingleColumn |
|
| Ordering.SingleColumn |
Represents a single column in ORDER BY column
|
| OrderPreservingPartitioner |
|
| OrderPreservingPartitioner.StringToken |
|
| OrdinalPostingList |
|
| OutboundConnection |
Represents a connection type to a peer, and handles the state transistions on the connection and the netty Channel.
|
| OutboundConnectionInitiator<SuccessType extends OutboundConnectionInitiator.Result.Success> |
A ChannelHandler to execute the send-side of the internode handshake protocol.
|
| OutboundConnectionInitiator.Result<SuccessType extends OutboundConnectionInitiator.Result.Success> |
The result of the handshake.
|
| OutboundConnectionInitiator.Result.MessagingSuccess |
|
| OutboundConnectionInitiator.Result.StreamingSuccess |
|
| OutboundConnectionInitiator.Result.Success<SuccessType extends OutboundConnectionInitiator.Result.Success> |
|
| OutboundConnectionInitiator.SslFallbackConnectionType |
|
| OutboundConnections |
Groups a set of outbound connections to a given peer, and routes outgoing messages to the appropriate connection
(based upon message's type or size).
|
| OutboundConnectionSettings |
A collection of settings to be passed around for outbound connections.
|
| OutboundConnectionSettings.Framing |
|
| OutboundSink |
A message sink that all outbound messages go through.
|
| OutboundSink.Sink |
|
| OutgoingStream |
Some subset of data to be streamed.
|
| OutgoingStreamMessage |
|
| Output |
|
| OutputHandler |
|
| OutputHandler.LogOutput |
|
| OutputHandler.SystemOutput |
|
| OverlapIterator<I extends java.lang.Comparable<? super I>,V> |
A class for iterating sequentially through an ordered collection and efficiently
finding the overlapping set of matching intervals.
|
| Overlaps |
|
| Overlaps.BucketMaker<E,B> |
|
| Overlaps.InclusionMethod |
|
| OverloadedException |
|
| PackedLongsPostingList |
Adapter class for PackedLongValues to expose it as PostingList. |
| PageAware |
|
| PagingState |
|
| PagingState.RowMark |
Marks the last row returned by paging, the one from which paging should continue.
|
| Pair<T1,T2> |
|
| ParameterizedClass |
|
| ParamType |
Type names and serializers for various parameters that can be put in Message params map. |
| ParseUtils |
Simple utility class used to help parsing CQL values (mainly UDT and collection ones).
|
| PartialMaskingFunction |
|
| PartialMaskingFunction.Kind |
|
| PartialScalarFunction |
A partial application of a function.
|
| ParticipateState |
|
| ParticipateState.Job |
|
| ParticipateState.Job.State |
|
| ParticipateState.RegisterStatus |
|
| Partition |
In-memory representation of a Partition.
|
| PartitionDenylist |
PartitionDenylist uses the system_distributed.partition_denylist table to maintain a list of denylisted partition keys
for each keyspace/table.
|
| PartitionerDefinedOrder |
for sorting columns representing row keys in the row ordering as determined by a partitioner.
|
| PartitionIndex |
This class holds the partition index as an on-disk trie mapping unique prefixes of decorated keys to:
data file position if the partition is small enough to not need an index
row index file position if the partition has a row index
plus
the last 8 bits of the key's filter hash which is used to filter out mismatched keys without reading the key
To avoid having to create an object to carry the result, the two are distinguished by sign.
|
| PartitionIndex.Acceptor<ArgType,ResultType> |
|
| PartitionIndex.IndexPosIterator |
Iterator of index positions covered between two keys.
|
| PartitionIndex.Reader |
Provides methods to read the partition index trie.
|
| PartitionInfo |
|
| PartitionIterator |
An iterator over a number of (filtered) partition.
|
| PartitionIteratorMergeListener<E extends Endpoints<E>> |
|
| PartitionIterators |
|
| PartitionKeyIndex |
Index on a PARTITION_KEY column definition.
|
| PartitionPosition |
|
| PartitionPosition.ForKey |
|
| PartitionPosition.Kind |
|
| PartitionPosition.RowPositionSerializer |
|
| PartitionRangeQueryPager |
Pages a PartitionRangeReadQuery.
|
| PartitionRangeReadCommand |
A read command that selects a (part of a) range of partitions.
|
| PartitionRangeReadCommand.VirtualTablePartitionRangeReadCommand |
|
| PartitionRangeReadQuery |
A ReadQuery for a range of partitions.
|
| PartitionSerializationException |
|
| PartitionStatisticsCollector |
|
| PartitionUpdate |
Stores updates made on a partition.
|
| PartitionUpdate.Builder |
Builder for PartitionUpdates
This class is not thread safe, but the PartitionUpdate it produces is (since it is immutable).
|
| PartitionUpdate.CounterMark |
A counter mark is basically a pointer to a counter update inside this partition update.
|
| PartitionUpdate.PartitionUpdateSerializer |
|
| PartitionUpdate.SimpleBuilder |
Interface for building partition updates geared towards human.
|
| PartitionUpdate.SimpleBuilder.RangeTombstoneBuilder |
Interface to build range tombstone.
|
| PasswordAuthenticator |
PasswordAuthenticator is an IAuthenticator implementation
that keeps credentials (rolenames and bcrypt-hashed passwords)
internally in C* - in system_auth.roles CQL3 table.
|
| PasswordAuthenticator.CredentialsCache |
|
| PasswordAuthenticator.CredentialsCacheMBean |
|
| PasswordObfuscator |
Obfuscates passwords in a given string
|
| PathUtils |
Vernacular: tryX means return false or 0L on any failure; XIfNotY means propagate any exceptions besides those caused by Y
This class tries to apply uniform IOException handling, and does not propagate IOException except for NoSuchFileException.
|
| PathUtils.IOConsumer |
|
| PathUtils.IOToLongFunction<V> |
|
| PatriciaTrie<K,V> |
|
| PauseHandoff |
|
| Paxos |
This class serves as an entry-point to Cassandra's implementation of Paxos Consensus.
|
| Paxos.Async<Result> |
|
| PaxosBallotTracker |
Tracks the highest paxos ballot we've seen, and the lowest ballot we can accept.
|
| PaxosCleanup |
|
| PaxosCleanupComplete |
|
| PaxosCleanupComplete.Request |
|
| PaxosCleanupHistory |
|
| PaxosCleanupLocalCoordinator |
|
| PaxosCleanupRequest |
|
| PaxosCleanupResponse |
|
| PaxosCleanupSession |
|
| PaxosCommit<OnDone extends java.util.function.Consumer<? super org.apache.cassandra.service.paxos.PaxosCommit.Status>> |
|
| PaxosCommit.RequestHandler |
|
| PaxosCommitAndPrepare |
|
| PaxosCommitAndPrepare.RequestHandler |
|
| PaxosCommitAndPrepare.RequestSerializer |
|
| PaxosFinishPrepareCleanup |
|
| PaxosKeyState |
|
| PaxosMetrics |
|
| PaxosOperationLock |
|
| PaxosPrepare |
Perform one paxos "prepare" attempt, with various optimisations.
|
| PaxosPrepare.RequestHandler |
|
| PaxosPrepare.RequestSerializer |
|
| PaxosPrepare.ResponseSerializer |
|
| PaxosPrepareRefresh |
Nodes that have promised in response to our prepare, may be missing the latestCommit, meaning we cannot be sure the
prior round has been committed to the necessary quorum of participants, so that it will be visible to future quorums.
|
| PaxosPrepareRefresh.RequestHandler |
|
| PaxosPrepareRefresh.RequestSerializer |
|
| PaxosPrepareRefresh.ResponseSerializer |
|
| PaxosPropose<OnDone extends java.util.function.Consumer<? super org.apache.cassandra.service.paxos.PaxosPropose.Status>> |
In waitForNoSideEffect mode, we will not return failure to the caller until
we have received a complete set of refusal responses, or at least one accept,
indicating (respectively) that we have had no side effect, or that we cannot
know if we our proposal produced a side effect.
|
| PaxosPropose.RequestHandler |
The proposal request handler, i.e.
|
| PaxosPropose.RequestSerializer |
|
| PaxosPropose.ResponseSerializer |
|
| PaxosRepair |
Facility to finish any in-progress paxos transaction, and ensure that a quorum of nodes agree on the most recent operation.
|
| PaxosRepair.RequestHandler |
The proposal request handler, i.e.
|
| PaxosRepair.RequestSerializer |
|
| PaxosRepair.ResponseSerializer |
|
| PaxosRepairHistory |
|
| PaxosRepairState |
Tracks the state of paxos repair cleanup work
|
| PaxosRequestCallback<T> |
|
| PaxosRows |
|
| PaxosStartPrepareCleanup |
Determines the highest ballot we should attempt to repair
|
| PaxosStartPrepareCleanup.Request |
|
| PaxosStartPrepareCleanup.RequestSerializer |
|
| PaxosState |
We save to memory the result of each operation before persisting to disk, however each operation that performs
the update does not return a result to the coordinator until the result is fully persisted.
|
| PaxosState.Key |
|
| PaxosState.MaybePromise |
|
| PaxosState.MaybePromise.Outcome |
|
| PaxosState.Snapshot |
|
| PaxosState.UnsafeSnapshot |
|
| PaxosStateTracker |
Tracks uncommitted and ballot high/low bounds
|
| PaxosTableRepairs |
Coordinates repairs on a given key to prevent multiple repairs being scheduled for a single key
|
| PaxosUncommittedIndex |
A 2i implementation made specifically for system.paxos that listens for changes to paxos state by interpreting
mutations against system.paxos and updates the uncommitted tracker accordingly.
|
| PaxosUncommittedTracker |
Tracks uncommitted paxos operations to enable operation completion as part of repair by returning an iterator of
partition keys with uncommitted paxos operations (and their consistency levels) for a given table and token range(s)
There are 2 parts to the uncommitted states it tracks: operations flushed to disk, and updates still in memory.
|
| PaxosUncommittedTracker.UpdateSupplier |
|
| PeekablePostingList |
A peekable wrapper around a PostingList that allows the next value to be
looked at without advancing the state of the PostingList |
| PEMBasedSslContextFactory |
SslContextFactory for the PEM standard encoded PKCS#8 private keys and X509 certificates/public-keys. |
| PEMBasedSslContextFactory.ConfigKey |
|
| PEMBasedSslContextFactory.PEMBasedKeyStoreContext |
|
| PEMReader |
This is a helper class to read private keys and X509 certifificates encoded based on PEM (RFC 1421)
format. |
| PendingAntiCompaction |
Performs an anti compaction on a set of tables and token ranges, isolating the unrepaired sstables
for a give token range into a pending repair group so they can't be compacted with other sstables
while they are being repaired.
|
| PendingAntiCompaction.AcquireResult |
|
| PendingAntiCompaction.AcquisitionCallable |
|
| PendingHintsInfo |
|
| PendingRangeCalculatorService |
|
| PendingRangeMaps |
|
| PendingRepairHolder |
|
| PendingStat |
|
| PendingStat.Builder |
|
| PendingStats |
|
| PercentageThreshold |
A Threshold guardrail whose values represent a percentage |
| PercentileSpeculativeRetryPolicy |
|
| PerColumnIndexFiles |
|
| PerColumnIndexWriter |
Creates the on-disk components for a given column index.
|
| Permission |
An enum encapsulating the set of possible permissions that an authenticated user can have on a resource.
|
| PermissionDetails |
Sets of instances of this class are returned by IAuthorizer.listPermissions() method for LIST PERMISSIONS query.
|
| PermissionsCache |
|
| PermissionsCacheMBean |
|
| PermissionsManagementStatement |
|
| PerSSTableIndexWriter |
Writes all SSTable-attached index files.
|
| PerSSTableIndexWriter |
|
| PingRequest |
Indicates to the recipient which ConnectionType should be used for the response. |
| PipelineConfigurator |
Takes care of intializing a Netty Channel and Pipeline for client protocol connections.
|
| PostingList |
Interface for advancing on and consuming a posting list.
|
| PostingList.EmptyPostingList |
|
| PostingListRangeIterator |
A key iterator based on a PostingList derived from a single index segment. |
| PostingsReader |
Reads, decompresses and decodes postings lists written by PostingsWriter. |
| PostingsReader.BlocksSummary |
|
| PostingsWriter |
Encodes, compresses and writes postings lists to disk.
|
| Predicates<T> |
A guardrail based on two predicates.
|
| Predicates.MessageProvider<T> |
A function used to build the warning or error message of a triggered Predicates guardrail. |
| PreferedNodeFilter |
|
| PrefixTermTree |
This class is an extension over RangeTermTree for string terms,
it is required because interval tree can't handle matching if search is on the
prefix of min/max of the range, so for ascii/utf8 fields we build an additional
prefix trie (including both min/max terms of the index) and do union of the results
of the prefix tree search and results from the interval tree lookup.
|
| PrefixTermTree.Builder |
|
| PreHashedDecoratedKey |
|
| PrepareAckMessage |
|
| PrepareCallback |
|
| PrepareConsistentRequest |
|
| PrepareConsistentResponse |
|
| PreparedQueryNotFoundException |
|
| PrepareMessage |
|
| PrepareMessage |
|
| PrepareResponse |
|
| PrepareResponse.PrepareResponseSerializer |
|
| PrepareSynAckMessage |
|
| PrepareSynMessage |
|
| PrepareVerbHandler |
|
| PreV5Handlers |
|
| PreV5Handlers.ExceptionHandler |
Pre-V5 exception handler which closes the connection if an ProtocolException
is thrown |
| PreV5Handlers.LegacyDispatchHandler |
Wraps an Dispatcher so that it can be used as an
channel inbound handler in pre-V5 pipelines. |
| PreV5Handlers.ProtocolDecoder |
Simple adaptor to allow Message.Decoder.decodeMessage(Channel, Envelope)
to be used as a handler in pre-V5 pipelines
|
| PreV5Handlers.ProtocolEncoder |
Simple adaptor to plug CQL message encoding into pre-V5 pipelines
|
| PreviewKind |
|
| PreviewRepairConflictWithIncrementalRepairException |
|
| PreviewRepairTask |
|
| PrimaryKey |
|
| PrimaryKey.Factory |
|
| PrimaryKey.Kind |
|
| PrimaryKeyMap |
|
| PrimaryKeyMap.Factory |
|
| PrimaryKeys |
|
| ProfileLoad |
|
| ProgressEvent |
Progress event
|
| ProgressEventNotifier |
|
| ProgressEventNotifierSupport |
Provides basic, thread safe ProgressEvent notification support
|
| ProgressEventType |
Progress event type.
|
| ProgressInfo |
ProgressInfo contains stream transfer progress.
|
| ProgressInfo.Direction |
Direction of the stream.
|
| ProgressInfoCompositeData |
|
| ProgressListener |
|
| Promise<V> |
A Promise that integrates Promise with our Future API
to improve clarity and coherence in the codebase. |
| Properties |
Utility class for working with Property types.
|
| PropertyDefinitions |
|
| PropertyFileSnitch |
Used to determine if two IP's are in the same datacenter or on the same rack.
|
| ProposeCallback |
ProposeCallback has two modes of operation, controlled by the failFast parameter.
|
| ProposeVerbHandler |
|
| ProtocolException |
Exceptions thrown when a client didn't respect the protocol.
|
| ProtocolVersion |
The native (CQL binary) protocol version.
|
| ProtocolVersionTracker |
This class tracks the last 100 connections per protocol version
|
| ProxyHistograms |
|
| PurgeFunction |
|
| QualifiedName |
Class for the names of the keyspace-prefixed elements (e.g.
|
| QualifiedStatement |
Abstract class for statements that work on sub-keyspace level (tables, views, indexes, functions, etc.)
|
| QueryCancelledException |
|
| QueryContext |
Tracks state relevant to the execution of a single query, including metrics and timeout monitoring.
|
| QueryController |
|
| QueryController |
|
| QueryEventListener |
Listener that gets notified during storage-attached index query execution.
|
| QueryEventListener.BalancedTreeEventListener |
Collector for balanced tree file related metrics.
|
| QueryEventListener.PostingListEventListener |
Collector for posting file related metrics.
|
| QueryEventListener.TrieIndexEventListener |
|
| QueryEvents |
|
| QueryEvents.Listener |
|
| QueryHandler |
|
| QueryHandler.Prepared |
|
| QueryMessage |
A CQL query
|
| QueryOptions |
Options for a query.
|
| QueryPager |
Perform a query, paging it by page of a given size.
|
| QueryProcessor |
|
| QueryReferencesTooManyIndexesAbortException |
|
| QueryReferencingTooManyIndexesException |
|
| QueryState |
Primarily used as a recorder for server-generated timestamps (timestamp, in microseconds, and nowInSeconds - in, well, seconds).
|
| QueryViewBuilder |
Build a query specific view of the on-disk indexes for a query.
|
| QueryViewBuilder.QueryView |
|
| QueueBackpressure |
Native Queue Backpressure mechanism.
|
| QueueBackpressure.Incident |
|
| RackInferringSnitch |
A simple endpoint snitch implementation that assumes datacenter and rack information is encoded
in the 2nd and 3rd octets of the ip address, respectively.
|
| RamAwareVectorValues |
|
| RamEstimation |
|
| RandomAccessReader |
|
| RandomAccessReaderAdapter |
|
| RandomPartitioner |
This class generates a BigIntegerToken using MD5 hash.
|
| RandomPartitioner.BigIntegerToken |
|
| Range<T extends RingPosition<T>> |
A representation of the range that a node is responsible for on the DHT ring.
|
| Range.OrderedRangeContainmentChecker |
Helper class to check if a token is contained within a given collection of ranges
|
| RangeAwareSSTableWriter |
|
| RangeCommandIterator |
|
| RangeCommands |
|
| RangeDenormalizer |
|
| RangeFetchMapCalculator |
We model the graph like this:
* Each range we are about to stream is a vertex in the graph
* Each node that can provide a range is a vertex in the graph
* We add an edge from each range to the node that can provide the range
* Then, to be able to solve the maximum flow problem using Ford-Fulkerson we add a super source with edges to all range vertices
and a super sink with incoming edges from all the node vertices.
|
| RangeIntersectionIterator |
|
| RangeIntersectionIterator.BounceIntersectionIterator<K extends java.lang.Comparable<K>,D extends CombinedValue<K>> |
Iterator which performs intersection of multiple ranges by using bouncing (merge-join) technique to identify
common elements in the given ranges.
|
| RangeIntersectionIterator.Builder<K extends java.lang.Comparable<K>,D extends CombinedValue<K>> |
|
| RangeIntersectionIterator.LookupIntersectionIterator<K extends java.lang.Comparable<K>,D extends CombinedValue<K>> |
Iterator which performs a linear scan over a primary range (the smallest of the ranges)
and O(log(n)) lookup into secondary ranges using values from the primary iterator.
|
| RangeIntersectionIterator.Strategy |
|
| RangeIterator<K extends java.lang.Comparable<K>,T extends CombinedValue<K>> |
|
| RangeIterator.Builder<K extends java.lang.Comparable<K>,D extends CombinedValue<K>> |
|
| RangeIterator.Builder.EmptyRangeIterator<K extends java.lang.Comparable<K>,D extends CombinedValue<K>> |
|
| RangeIterator.Builder.IteratorType |
|
| RangeIterator.Builder.Statistics<K extends java.lang.Comparable<K>,D extends CombinedValue<K>> |
|
| RangeKeySample |
|
| RangeMap<T> |
|
| RangeRelocator |
|
| RangesAtEndpoint |
A ReplicaCollection for Ranges occurring at an endpoint.
|
| RangesAtEndpoint.Builder |
|
| RangesByEndpoint |
|
| RangesByEndpoint.Builder |
|
| RangesSerializer |
|
| RangeStreamer |
Assists in streaming ranges to this node.
|
| RangeStreamer.AllowedSourcesFilter |
Source filter which only includes endpoints contained within a provided set.
|
| RangeStreamer.ExcludeLocalDatacenterFilter |
Source filter which excludes nodes from local DC.
|
| RangeStreamer.ExcludeLocalNodeFilter |
Source filter which excludes the current node from source calculations
|
| RangeStreamer.FailureDetectorSourceFilter |
Source filter which excludes any endpoints that are not alive according to a
failure detector.
|
| RangeStreamer.FetchReplica |
|
| RangeStreamer.SingleDatacenterFilter |
Source filter which excludes any endpoints that are not in a specific data center.
|
| RangeStreamer.SourceFilter |
|
| RangeTermTree |
|
| RangeTermTree |
|
| RangeTermTree.Term |
This is required since IntervalTree doesn't support custom Comparator
implementations and relied on items to be comparable which "raw" terms are not.
|
| RangeTermTree.Term |
This is required since IntervalTree doesn't support custom Comparator
implementations and relied on items to be comparable which "raw" terms are not.
|
| RangeTombstone |
A range tombstone is a tombstone that covers a slice/range of rows.
|
| RangeTombstoneBoundaryMarker |
A range tombstone marker that represents a boundary between 2 range tombstones (i.e.
|
| RangeTombstoneBoundMarker |
A range tombstone marker that indicates the bound of a range tombstone (start or end).
|
| RangeTombstoneList |
Data structure holding the range tombstones of a ColumnFamily.
|
| RangeTombstoneMarker |
A marker for a range tombstone bound.
|
| RangeTombstoneMarker.Merger |
Utility class to help merging range tombstone markers coming from multiple inputs (UnfilteredRowIterators).
|
| RangeUnionIterator<K extends java.lang.Comparable<K>,D extends CombinedValue<K>> |
Range Union Iterator is used to return sorted stream of elements from multiple RangeIterator instances.
|
| RangeUnionIterator.Builder<K extends java.lang.Comparable<K>,D extends CombinedValue<K>> |
|
| RangeUtil |
|
| RawSelector |
|
| ReadableMemory |
|
| ReadAbortException |
Special Read Failure which is caused by user query; implies a user request is not allowed and not that Cassandra had an issue.
|
| ReadCallback<E extends Endpoints<E>,P extends ReplicaPlan.ForRead<E,P>> |
|
| ReadCommand |
General interface for storage-engine read commands (common to both range and
single partition commands).
|
| ReadCommand.Kind |
|
| ReadCommand.SelectionDeserializer |
|
| ReadCommand.Serializer |
|
| ReadCommandVerbHandler |
|
| ReaderFileProxy |
Base class for the RandomAccessReader components that implement reading.
|
| ReadExecutionController |
|
| ReadFailureException |
|
| ReadOnlyReadRepair<E extends Endpoints<E>,P extends ReplicaPlan.ForRead<E,P>> |
Only performs the collection of data responses and reconciliation of them, doesn't send repair mutations
to replicas.
|
| ReadQuery |
Generic abstraction for read queries.
|
| ReadRepair<E extends Endpoints<E>,P extends ReplicaPlan.ForRead<E,P>> |
|
| ReadRepair.Factory |
|
| ReadRepairMetrics |
Metrics related to Read Repair.
|
| ReadRepairStrategy |
|
| ReadRepairVerbHandler |
|
| ReadResponse |
|
| ReadSizeAbortException |
|
| ReadTimeoutException |
|
| ReadyMessage |
Message to indicate that the server is ready to receive requests.
|
| Rebufferer |
Rebufferer for reading data by a RandomAccessReader.
|
| Rebufferer.BufferHolder |
|
| RebuffererFactory |
Interface for the classes that can be used to instantiate rebufferers over a given file.
|
| RebufferingInputStream |
Rough equivalent of BufferedInputStream and DataInputStream wrapping a ByteBuffer that can be refilled
via rebuffer.
|
| Rebuild |
|
| RebuildIndex |
|
| ReceivedMessage |
|
| RecompressSSTables |
|
| RecomputingSupplier<T> |
|
| ReconnectableSnitchHelper |
Sidekick helper for snitches that want to reconnect from one IP addr for a node to another.
|
| ReduceHelper |
Basic idea is that we track incoming ranges instead of blindly just exchanging the ranges that mismatch between two nodes
Say node X has tracked that it will stream range r1 from node Y.
|
| ReducingKeyIterator |
Caller must acquire and release references to the sstables used here.
|
| Ref<T> |
An object that needs ref counting does the two following:
- defines a Tidy object that will cleanup once it's gone,
(this must retain no references to the object we're tracking (only its resources and how to clean up))
Then, one of two options:
1) Construct a Ref directly pointing to it, and always use this Ref; or
2)
- implements RefCounted
- encapsulates a Ref, we'll call selfRef, to which it proxies all calls to RefCounted behaviours
- users must ensure no references to the selfRef leak, or are retained outside of a method scope.
|
| Ref.DirectBufferRef<T extends sun.nio.ch.DirectBuffer> |
A version of Ref for objects that implement DirectBuffer. |
| Ref.IdentityCollection |
|
| Ref.OnLeak |
|
| RefCounted<T> |
An object that needs ref counting does the two following:
- defines a Tidy object that will cleanup once it's gone,
(this must retain no references to the object we're tracking (only its resources and how to clean up))
Then, one of two options:
1) Construct a Ref directly pointing to it, and always use this Ref; or
2)
- implements RefCounted
- encapsulates a Ref, we'll call selfRef, to which it proxies all calls to RefCounted behaviours
- users must ensure no references to the selfRef leak, or are retained outside of a method scope.
|
| RefCounted.Tidy |
|
| RefCountedMemory |
|
| ReflectionUtils |
|
| Refresh |
|
| RefreshSizeEstimates |
|
| Refs<T extends RefCounted<T>> |
A collection of managed Ref references to RefCounted objects, and the objects they are referencing.
|
| RegisterMessage |
|
| RegularAndStaticColumns |
Columns (or a subset of the columns) that a partition contains.
|
| RegularAndStaticColumns.Builder |
|
| RegularColumnIndex |
Index on a REGULAR column definition on a composite type.
|
| RejectException |
Represents a request to reject the current operation
|
| Relation |
|
| ReloadCIDRGroupsCache |
Nodetool command to reload CIDR groups cache
|
| ReloadLocalSchema |
|
| ReloadSeeds |
|
| ReloadSslCertificates |
|
| ReloadTriggers |
|
| RelocateSSTables |
|
| RemoveNode |
|
| Repair |
|
| RepairAdmin |
Supports listing and failing incremental repair sessions
|
| RepairAdmin.CancelCmd |
|
| RepairAdmin.CleanupDataCmd |
|
| RepairAdmin.ListCmd |
|
| RepairAdmin.SummarizePendingCmd |
|
| RepairAdmin.SummarizeRepairedCmd |
|
| RepairConfig |
|
| RepairCoordinator |
|
| RepairCoordinator.NeighborsAndRanges |
|
| RepairedDataTracker |
|
| RepairedDataVerifier |
|
| RepairedDataVerifier.SimpleVerifier |
|
| RepairedDataVerifier.SnapshottingVerifier |
|
| RepairedState |
Tracks the repaired state of token ranges per table, and is effectively an
in memory representation of the on-disk local incremental repair state.
|
| RepairedState.Section |
|
| RepairedState.Stats |
|
| RepairException |
Exception thrown during repair
|
| RepairJob |
RepairJob runs repair on given ColumnFamily.
|
| RepairJobDesc |
RepairJobDesc is used from various repair processes to distinguish one RepairJob to another.
|
| RepairMessage |
Base class of all repair related request/response messages.
|
| RepairMessage.RepairFailureCallback |
|
| RepairMessageVerbHandler |
Handles all repair related message.
|
| RepairMetrics |
|
| RepairNotifier |
|
| RepairOption |
Repair options.
|
| RepairParallelism |
Specify the degree of parallelism when calculating the merkle trees in a repair job.
|
| RepairResult |
RepairJob's result
|
| RepairRetrySpec |
|
| RepairRunner |
|
| RepairSession |
Coordinates the (active) repair of a list of non overlapping token ranges.
|
| RepairSessionResult |
Repair session result
|
| RepairStats |
|
| RepairStats.Section |
|
| RepairTask |
|
| ReplaceMaskingFunction |
A MaskingFunction that replaces the specified column value by a certain replacement value. |
| Replacement |
Holder for replacements to support backward compatibility between old and new names and types
of configuration parameters (CASSANDRA-15234)
|
| Replacements |
|
| Replaces |
Repeatable annotation for providing old name, converter from old to new type and whether the
config parameters we annotate are deprecated and we need to warn the users.
|
| ReplacesList |
Concatenating annotation type for the repeatable annotation Replaces |
| ReplayBatchlog |
|
| Replica |
A Replica represents an owning node for a copy of a portion of the token ring.
|
| ReplicaCollection<C extends ReplicaCollection<C>> |
A collection like class for Replica objects.
|
| ReplicaCollection.Builder<C extends ReplicaCollection<C>> |
A mutable (append-only) extension of a ReplicaCollection.
|
| ReplicaCollection.Builder.Conflict |
Passed to add() and addAll() as ignoreConflicts parameter.
|
| ReplicaFilteringProtection<E extends Endpoints<E>> |
Helper in charge of collecting additional queries to be done on the coordinator to protect against invalid results
being included due to replica-side filtering (secondary indexes or ALLOW * FILTERING).
|
| ReplicaFilteringProtectionOptions |
|
| ReplicaLayout<E extends Endpoints<E>> |
The relevant replicas for an operation over a given range or token.
|
| ReplicaLayout.ForRange |
|
| ReplicaLayout.ForRangeRead |
|
| ReplicaLayout.ForToken |
|
| ReplicaLayout.ForTokenRead |
|
| ReplicaLayout.ForTokenWrite |
|
| ReplicaLayout.ForWrite<E extends Endpoints<E>> |
|
| ReplicaMultimap<K,C extends ReplicaCollection<?>> |
|
| ReplicaMultimap.Builder<K,B extends ReplicaCollection.Builder<?>> |
|
| ReplicaPlan<E extends Endpoints<E>,P extends ReplicaPlan<E,P>> |
|
| ReplicaPlan.AbstractForRead<E extends Endpoints<E>,P extends ReplicaPlan.ForRead<E,P>> |
|
| ReplicaPlan.AbstractReplicaPlan<E extends Endpoints<E>,P extends ReplicaPlan<E,P>> |
|
| ReplicaPlan.ForFullRangeRead |
|
| ReplicaPlan.ForPaxosWrite |
|
| ReplicaPlan.ForRangeRead |
|
| ReplicaPlan.ForRead<E extends Endpoints<E>,P extends ReplicaPlan.ForRead<E,P>> |
|
| ReplicaPlan.ForTokenRead |
|
| ReplicaPlan.ForWrite |
|
| ReplicaPlan.Shared<E extends Endpoints<E>,P extends ReplicaPlan<E,P>> |
Used by AbstractReadExecutor, {Data,Digest}Resolver and ReadRepair to share a ReplicaPlan whose 'contacts' replicas
we progressively modify via various forms of speculation (initial speculation, rr-read and rr-write)
The internal reference is not volatile, despite being shared between threads.
|
| ReplicaPlan.SharedForRangeRead |
|
| ReplicaPlan.SharedForTokenRead |
|
| ReplicaPlans |
|
| ReplicaPlans.Selector |
|
| Replicas |
|
| Replicas.ReplicaCount |
|
| ReplicationDoneVerbHandler |
|
| ReplicationFactor |
|
| ReplicationParams |
|
| RequestCallback<T> |
|
| RequestCallbacks |
An expiring map of request callbacks.
|
| RequestCallbacks.CallbackInfo |
|
| RequestCallbackWithFailure<T> |
|
| RequestExecutionException |
|
| RequestFailureException |
|
| RequestFailureReason |
|
| RequestFailureReason.Serializer |
|
| RequestTimeoutException |
|
| RequestValidationException |
|
| RequestValidations |
Utility methods use to perform request validation.
|
| ReservedKeywords |
|
| ResetFullQueryLog |
|
| ResetLocalSchema |
|
| ResettableByteBuffersIndexOutput |
A wrapper around ByteBuffersIndexOutput that adds several methods that interact
with the underlying delegate.
|
| ResizableThreadPool |
|
| ResizableThreadPoolMXBean |
|
| ResourceLimits |
|
| ResourceLimits.Basic |
A cheaper, thread-unsafe permit container to be used for unshared limits.
|
| ResourceLimits.Concurrent |
A thread-safe permit container.
|
| ResourceLimits.EndpointAndGlobal |
A convenience class that groups a per-endpoint limit with the global one
to allow allocating/releasing permits from/to both limits as one logical operation.
|
| ResourceLimits.Limit |
Represents permits to utilise a resource and ways to allocate and release them.
|
| ResourceLimits.Outcome |
|
| Resources |
|
| ResourceWatcher |
|
| ResourceWatcher.WatchedResource |
|
| ResponseResolver<E extends Endpoints<E>,P extends ReplicaPlan.ForRead<E,P>> |
|
| RestorableMeter |
A meter metric which measures mean throughput as well as fifteen-minute and two-hour
exponentially-weighted moving average throughputs.
|
| Restriction |
Implementation of this class must be immutable.
|
| Restrictions |
Sets of restrictions
|
| ResultMessage |
|
| ResultMessage.Kind |
|
| ResultMessage.Prepared |
|
| ResultMessage.Rows |
|
| ResultMessage.SchemaChange |
|
| ResultMessage.SetKeyspace |
|
| ResultMessage.Void |
|
| ResultSet |
|
| ResultSet.Codec |
|
| ResultSet.Flag |
|
| ResultSet.PreparedMetadata |
The metadata for the query parameters in a prepared statement.
|
| ResultSet.ResultMetadata |
The metadata for the results of executing a query or prepared statement.
|
| ResultSetBuilder |
|
| ResumeHandoff |
|
| RetrySpec |
|
| RetrySpec.MaxAttempt |
|
| RetrySpec.Partial |
|
| ReversedType<T> |
|
| ReverseValueIterator<Concrete extends ReverseValueIterator<Concrete>> |
Thread-unsafe reverse value iterator for on-disk tries.
|
| RevokePermissionsStatement |
|
| RevokeRoleStatement |
|
| RewindableDataInput |
|
| Ring |
|
| RingPosition<C extends RingPosition<C>> |
Interface representing a position on the ring.
|
| RMIClientSocketFactoryImpl |
This class is used to override the local address the JMX client calculates when trying to connect,
which can otherwise be influenced by the system property "java.rmi.server.hostname" in strange and
unpredictable ways.
|
| RMIServerSocketFactoryImpl |
|
| Role |
|
| RoleManagementStatement |
|
| RoleName |
|
| RoleOptions |
|
| RoleResource |
IResource implementation representing database roles.
|
| Roles |
|
| RolesCache |
|
| RolesCacheMBean |
|
| Row |
Storage engine representation of a row.
|
| Row.Builder |
Interface for building rows.
|
| Row.Deletion |
A row deletion/tombstone.
|
| Row.Merger |
Utility class to help merging rows from multiple inputs (UnfilteredRowIterators).
|
| Row.SimpleBuilder |
Row builder interface geared towards human.
|
| RowAndDeletionMergeIterator |
An iterator that merges a source of rows with the range tombstone and partition level deletion of a give partition.
|
| RowCacheKey |
|
| RowCacheSentinel |
A sentinel object for row caches.
|
| RowDiffListener |
Interface that allows to act on the result of merging multiple rows.
|
| RowFilter |
A filter on which rows a given query should include or exclude.
|
| RowFilter.CustomExpression |
A custom index expression for use with 2i implementations which support custom syntax and which are not
necessarily linked to a single column in the base table.
|
| RowFilter.Expression |
|
| RowFilter.Expression.Kind |
|
| RowFilter.Serializer |
|
| RowFilter.SimpleExpression |
An expression of the form 'column' 'op' 'value'.
|
| RowFilter.UserExpression |
A user defined filtering expression.
|
| RowFilter.UserExpression.Deserializer |
|
| RowIndexEntry |
Binary format of RowIndexEntry is defined as follows:
(long) position (64 bit long, vint encoded)
(int) serialized size of data that follows (32 bit int, vint encoded)
-- following for indexed entries only (so serialized size > 0)
(int) int/Uint DeletionTime.localDeletionTime (uint if version >= "oa" (5.0))
(long) DeletionTime.markedForDeletionAt
(int) number of IndexInfo objects (32 bit int, vint encoded)
(*) serialized IndexInfo objects, see below
(*) offsets of serialized IndexInfo objects, since version "ma" (3.0)
Each IndexInfo object's offset is relative to the first IndexInfo object.
|
| RowIndexEntry.IndexInfoRetriever |
|
| RowIndexEntry.IndexSerializer |
|
| RowIndexEntry.RowIndexEntryReadSizeTooLargeException |
|
| RowIndexEntry.Serializer |
|
| RowIndexReader |
Reader class for row index files created by RowIndexWriter.
|
| RowIndexReader.IndexInfo |
|
| RowIterator |
An iterator over rows belonging to a partition.
|
| RowIteratorMergeListener<E extends Endpoints<E>> |
|
| RowIterators |
Static methods to work with row iterators.
|
| RowMapping |
In memory representation of PrimaryKey to row ID mappings which only contains
Row regardless of whether it's live or deleted. |
| Rows |
Static utilities to work on Row objects.
|
| RTBoundCloser |
A transformation that appends an RT bound marker to row iterators in case they don't have one.
|
| RTBoundValidator |
A validating transformation that sanity-checks the sequence of RT bounds and boundaries in every partition.
|
| RTBoundValidator.Stage |
|
| RunnableFuture<V> |
|
| SA<T extends java.nio.Buffer> |
|
| SafeMemory |
|
| SafeMemoryWriter |
|
| SAICodecUtils |
|
| Sampler<T> |
|
| Sampler.Sample<S> |
Represents the ranked items collected during a sample period
|
| Sampler.SamplerType |
|
| SamplingManager |
|
| SamplingManager.ResultBuilder |
|
| SASIIndex |
|
| SASIIndexGroup |
|
| SASIIndexQueryPlan |
|
| SASIIndexSearcher |
|
| ScalarFunction |
Determines a single output value based on any number of input values.
|
| ScalingReservoir |
A reservoir that scales the values before updating.
|
| ScalingReservoir.ScaleFunction |
Scale the input value.
|
| ScanAllRangesCommandIterator |
|
| ScheduledExecutorPlus |
|
| ScheduledExecutors |
Centralized location for shared executors
|
| ScheduledThreadPoolExecutorPlus |
Like ExecutorPlus, ScheduledThreadPoolExecutorPlus always
logs exceptions from the tasks it is given, even if Future.get is never called elsewhere.
|
| Scheduler |
Task scheduler that limits the number of concurrent tasks across multiple executors.
|
| Scheduler.LimitedConcurrentScheduler |
|
| Scheduler.NoopScheduler |
|
| Scheduler.Task<T> |
|
| Schema |
Manages shared schema, keyspace instances and table metadata refs.
|
| SchemaArgsParser |
|
| SchemaChangeListener |
|
| SchemaChangeNotifier |
Registers schema change listeners and sends the notifications.
|
| SchemaConstants |
When adding new String keyspace names here, double check if it needs to be added to PartitionDenylist.canDenylistKeyspace
|
| SchemaCQLHelper |
Helper methods to represent TableMetadata and related objects in CQL format
|
| SchemaElement |
A schema element (keyspace, udt, udf, uda, table, index, view).
|
| SchemaElement.SchemaElementType |
|
| SchemaEvent |
|
| SchemaEvent.SchemaEventType |
|
| SchemaKeyspace |
system_schema.* tables and methods for manipulating them.
|
| SchemaKeyspaceTables |
|
| SchemaMutationsSerializer |
|
| SchemaProvider |
|
| SchemaPullVerbHandler |
Sends it's current schema state in form of mutations in response to the remote node's request.
|
| SchemaPushVerbHandler |
Called when node receives updated schema state from the schema migration coordinator node.
|
| SchemaTransformation |
|
| SchemaTransformation.SchemaTransformationResult |
The result of applying (on this node) a given schema transformation.
|
| SchemaTransformations |
Factory and utility methods to create simple schema transformation.
|
| SchemaUpdateHandler |
Schema update handler is responsible for maintaining the shared schema and synchronizing it with other nodes in
the cluster, which means pushing and pulling changes, as well as tracking the current version in the cluster.
|
| SchemaUpdateHandlerFactory |
|
| SchemaUpdateHandlerFactoryProvider |
|
| SchemaVersionVerbHandler |
|
| Scrub |
|
| ScrubIterator |
|
| ScrubPartitionIterator |
Iterator over the partitions of an sstable used for scrubbing.
|
| SearchIterator<K,V> |
|
| SecondaryIndexBuilder |
Manages building an entire index from column family data.
|
| SecondaryIndexManager |
Handles the core maintenance functionality associated with indexes: adding/removing them to or from
a table, (re)building during bootstrap or other streaming operations, flushing, reloading metadata
and so on.
|
| SecurityThreadGroup |
|
| SecurityThreadGroup.ThreadInitializer |
|
| SeedProvider |
|
| SeekingRandomAccessInput |
IndexInput adapter that exposes it as a RandomAccessInput.
|
| Segment |
Each segment represents an on-disk index structure (balanced tree/terms/postings) flushed by memory limit or token boundaries.
|
| SegmentBuilder |
Creates an on-heap index data structure to be flushed to an SSTable index.
|
| SegmentBuilder.TrieSegmentBuilder |
|
| SegmentBuilder.VectorSegmentBuilder |
|
| SegmentMetadata |
|
| SegmentMetadata.ComponentMetadata |
|
| SegmentMetadata.ComponentMetadataMap |
|
| SegmentOrdering |
|
| SegmentsSystemView |
A VirtualTable providing a system view of SSTable index segment metadata. |
| SegmentTrieBuffer |
On-heap buffer for values that provides a sorted view of itself as an Iterator.
|
| SegmentWriter |
|
| Selectable |
|
| Selectable.BetweenParenthesesOrWithTuple |
Selectable for Selectable between parentheses or tuples.
|
| Selectable.BetweenParenthesesOrWithTuple.Raw |
|
| Selectable.Raw |
|
| Selectable.RawIdentifier |
In the selection clause, the parser cannot differentiate between Maps and UDTs as a column identifier and field
identifier have the same syntax.
|
| Selectable.WithArrayLiteral |
Selectable for literal Lists.
|
| Selectable.WithArrayLiteral.Raw |
|
| Selectable.WithCast |
|
| Selectable.WithCast.Raw |
|
| Selectable.WithElementSelection |
Represents the selection of an element of a collection (eg.
|
| Selectable.WithElementSelection.Raw |
|
| Selectable.WithFieldSelection |
Represents the selection of the field of a UDT (eg.
|
| Selectable.WithFieldSelection.Raw |
|
| Selectable.WithFunction |
|
| Selectable.WithFunction.Raw |
|
| Selectable.WithList |
|
| Selectable.WithMapOrUdt |
Selectable for literal Maps or UDTs.
|
| Selectable.WithMapOrUdt.Raw |
|
| Selectable.WithSet |
Selectable for literal Sets.
|
| Selectable.WithSet.Raw |
|
| Selectable.WithSliceSelection |
Represents the selection of a slice of a collection (eg.
|
| Selectable.WithSliceSelection.Raw |
|
| Selectable.WithTerm |
|
| Selectable.WithTerm.Raw |
|
| Selectable.WithTypeHint |
Selectable for type hints (e.g.
|
| Selectable.WithTypeHint.Raw |
|
| Selectable.WithVector |
|
| Selectable.WritetimeOrTTL |
|
| Selectable.WritetimeOrTTL.Kind |
|
| Selectable.WritetimeOrTTL.Raw |
|
| Selection |
|
| Selection.Selectors |
|
| SelectionColumnMapping |
Separately maintains the ColumnSpecifications and their mappings to underlying
columns as we may receive null mappings.
|
| SelectionColumns |
Represents a mapping between the actual columns used to satisfy a Selection
and the column definitions included in the resultset metadata for the query.
|
| Selector |
A Selector is used to convert the data returned by the storage engine into the data requested by the
user.
|
| Selector.Factory |
A factory for Selector instances.
|
| Selector.InputRow |
A row of data that need to be processed by a Selector
|
| Selector.Kind |
The Selector kinds.
|
| Selector.SelectorDeserializer |
|
| Selector.Serializer |
|
| SelectStatement |
Encapsulates a completely parsed SELECT query, including the target
column family, expression, result count, and ordering clause.
|
| SelectStatement.Parameters |
|
| SelectStatement.RawStatement |
|
| SelfRefCounted<T extends SelfRefCounted<T>> |
|
| Semaphore |
|
| Semaphore.Standard |
|
| SEPExecutor |
|
| SEPExecutor.TakeTaskPermitResult |
|
| SEPExecutorMBean |
|
| SequenceBasedSSTableId |
Generation identifier based on sequence of integers.
|
| SequenceBasedSSTableId.Builder |
|
| SequentialExecutorPlus |
An ExecutorPlus that guarantees the order of execution matches the order of task submission,
and provides a simple mechanism for the recurring pattern of ensuring a job is executed at least once
after some point in time (i.e. |
| SequentialExecutorPlus.AtLeastOnceTrigger |
|
| SequentialWriter |
Adds buffering, mark, and fsyncing to OutputStream.
|
| SequentialWriter.BufferedFileWriterMark |
Class to hold a mark to the position of the file
|
| SequentialWriterOption |
SequentialWriter option
|
| SequentialWriterOption.Builder |
|
| SerializableHintMessage |
|
| SerializationHeader |
|
| SerializationHeader.Component |
We need the TableMetadata to properly deserialize a SerializationHeader but it's clunky to pass that to
a SSTable component, so we use this temporary object to delay the actual need for the metadata.
|
| SerializationHeader.Serializer |
|
| SerializationHelper |
|
| SerializationNode<VALUE> |
An abstraction of a node given to the trie serializer to write.
|
| SerializingCache<K,V> |
Serializes cache values off-heap.
|
| SerializingCacheProvider |
|
| SerializingCacheProvider.RowCacheSerializer |
|
| Server |
|
| Server.Builder |
|
| Server.ConnectionTracker |
|
| Server.EventNotifier |
|
| ServerConnection |
|
| ServerError |
Exceptions thrown when a client didn't respect the protocol.
|
| SessionCompleteEventCompositeData |
|
| SessionFailedMessage |
|
| SessionInfo |
Stream session info.
|
| SessionInfoCompositeData |
|
| SessionState |
|
| SessionState.State |
|
| SessionSummary |
|
| SetAuthCacheConfig |
|
| SetBatchlogReplayThrottle |
|
| SetCacheCapacity |
|
| SetCacheKeysToSave |
|
| SetColumnIndexSize |
|
| SetCompactionThreshold |
|
| SetCompactionThroughput |
|
| SetConcurrency |
|
| SetConcurrentCompactors |
|
| SetConcurrentViewBuilders |
|
| SetDefaultKeyspaceRF |
|
| SetHintedHandoffThrottleInKB |
|
| SetHostStat |
|
| SetHostStatWithPort |
|
| SetInterDCStreamThroughput |
|
| SetLoggingLevel |
|
| SetMaxHintWindow |
|
| Sets |
Static helper methods and classes for sets.
|
| Sets.Adder |
|
| Sets.DelayedValue |
|
| Sets.Discarder |
|
| Sets.ElementDiscarder |
|
| Sets.Literal |
|
| Sets.Marker |
|
| Sets.Setter |
|
| Sets.Value |
|
| SetSerializer<T> |
|
| SetSnapshotThrottle |
|
| SetStreamThroughput |
|
| SettableByIndexData<T extends SettableByIndexData<T>> |
Collection of (typed) CQL values that can be set by index (starting at zero).
|
| SettableByNameData<T extends SettableData<T>> |
Collection of (typed) CQL values that can set by name.
|
| SettableData<T extends SettableData<T>> |
Collection of (typed) CQL values that can be set either by index (starting at zero) or by name.
|
| SetTimeout |
|
| SetTraceProbability |
|
| SetType<T> |
|
| ShardBoundaries |
Holds boundaries (tokens) used to map a particular token (so partition key) to a shard id.
|
| ShardedCompactionWriter |
|
| ShardedMemtableConfigMXBean |
|
| ShardedMultiWriter |
|
| ShardedSkipListMemtable |
A proof-of-concept sharded memtable implementation.
|
| ShardedSkipListMemtable.MemtableUnfilteredPartitionIterator |
|
| ShardManager |
|
| ShardManagerDiskAware |
|
| ShardManagerNoDisks |
|
| ShardManagerTrivial |
|
| ShardTracker |
|
| ShareableBytes |
A wrapper for possibly sharing portions of a single, BufferPools.forNetworking() managed, ByteBuffer;
optimised for the case where no sharing is necessary. |
| Shared |
Tells jvm-dtest that a class should be shared across all ClassLoaders.
|
| Shared.Recursive |
|
| Shared.Scope |
|
| SharedCloseable |
A simple extension of AutoCloseable, that represents a resource that can be utilised in multiple locations,
each managing their own closure of the resource, so that when the last such instance is closed all are.
|
| SharedCloseableImpl |
A simple abstract implementation of SharedCloseable
|
| SharedContext |
Access methods to shared resources and services.
|
| SharedContext.ForwardingSharedContext |
|
| SharedContext.Global |
|
| SharedDefaultFileRegion |
Netty's DefaultFileRegion closes the underlying FileChannel as soon as
the refCnt() for the region drops to zero, this is an implementation of
the DefaultFileRegion that doesn't close the FileChannel.
|
| SharedDefaultFileRegion.SharedFileChannel |
|
| SharedExecutorPool |
A pool of worker threads that are shared between all Executors created with it.
|
| ShortReadPartitionsProtection |
|
| ShortReadProtection |
We have a potential short read if the result from a given node contains the requested number of rows
(i.e.
|
| ShortSerializer |
|
| ShortType |
|
| Shutdownable |
|
| SigarLibrary |
|
| SimpleBuilders |
|
| SimpleBuilders.MutationBuilder |
|
| SimpleBuilders.PartitionUpdateBuilder |
|
| SimpleBuilders.RowBuilder |
|
| SimpleCachedBufferPool |
A very simple Bytebuffer pool with a fixed allocation size and a cached max allocation count.
|
| SimpleClient |
|
| SimpleClient.Builder |
|
| SimpleClient.EventHandler |
|
| SimpleClient.SimpleEventHandler |
|
| SimpleClient.SimpleFlusher |
|
| SimpleDataSet |
A DataSet implementation that is filled on demand and has an easy to use API for adding rows.
|
| SimpleDataSet.SerializationException |
|
| SimpleDateSerializer |
|
| SimpleDateType |
|
| SimpleGaugeProvider<T extends java.lang.Number,R extends SSTableReader> |
|
| SimpleSeedProvider |
|
| SimpleSelector |
|
| SimpleSelector.SimpleSelectorFactory |
The Factory for SimpleSelector.
|
| SimpleSnitch |
A simple endpoint snitch implementation that treats Strategy order as proximity,
allowing non-read-repaired reads to prefer a single endpoint, which improves
cache locality.
|
| SimpleSSTableMultiWriter |
|
| SimpleStrategy |
This class returns the nodes responsible for a given
key but does not respect rack awareness.
|
| Simulate |
Enable certain features for a specific method or class.
|
| Simulate.With |
|
| SingleColumnRelation |
Relations encapsulate the relationship between an entity of some kind, and
a value (term).
|
| SingleColumnRestriction |
|
| SingleColumnRestriction.AnnRestriction |
|
| SingleColumnRestriction.ContainsRestriction |
|
| SingleColumnRestriction.EQRestriction |
|
| SingleColumnRestriction.INRestriction |
|
| SingleColumnRestriction.InRestrictionWithMarker |
|
| SingleColumnRestriction.InRestrictionWithValues |
|
| SingleColumnRestriction.IsNotNullRestriction |
|
| SingleColumnRestriction.LikeRestriction |
|
| SingleColumnRestriction.SliceRestriction |
|
| SinglePartitionPager |
Common interface to single partition queries (by slice and by name).
|
| SinglePartitionReadCommand |
A read command that selects a (part of a) single partition.
|
| SinglePartitionReadCommand.Group |
Groups multiple single partition read commands.
|
| SinglePartitionReadCommand.VirtualTableGroup |
|
| SinglePartitionReadCommand.VirtualTableSinglePartitionReadCommand |
|
| SinglePartitionReadQuery |
A ReadQuery for a single partition.
|
| SinglePartitionReadQuery.Group<T extends SinglePartitionReadQuery> |
Groups multiple single partition read queries.
|
| SingleRestriction |
A single restriction/clause on one or multiple column.
|
| SingleSSTableLCSTask |
Special compaction task that does not do any compaction, instead it
just mutates the level metadata on the sstable and notifies the compaction
strategy.
|
| SingleThreadExecutorPlus |
|
| SingleThreadExecutorPlus.AtLeastOnce |
|
| SingletonIndexGroup |
|
| SingletonIndexQueryPlan |
|
| SingletonUnfilteredPartitionIterator |
|
| SizedInts |
Utility class for sizing, writing and reading ints with length stored separately.
|
| SizeEstimatesRecorder |
A very simplistic/crude partition count/size estimator.
|
| SizeTieredCompactionStrategy |
|
| SizeTieredCompactionStrategyOptions |
|
| Sjk |
|
| Sjk.Wrapper |
|
| SkinnyPrimaryKeyMap |
A PrimaryKeyMap for skinny tables (those with no clustering columns). |
| SkinnyPrimaryKeyMap.Factory |
|
| SkipListMemIndex |
|
| SkipListMemtable |
|
| SkipListMemtableFactory |
This class makes better sense as an inner class to SkipListMemtable (which could be as simple as
FACTORY = SkipListMemtable::new), but having it there causes the SkipListMemtable class to be initialized the first
time it is referenced (e.g.
|
| SlabAllocator |
+ * The SlabAllocator is a bump-the-pointer allocator that allocates
+ * large (1MiB) global regions and then doles them out to threads that
+ * request smaller sized (up to 128KiB) slices into the array.
|
| SlabPool |
|
| Slice |
A slice represents the selection of a range of rows.
|
| Slice.Serializer |
|
| SlicedTrie<T> |
Represents a sliced view of a trie, i.e.
|
| Slices |
Represents the selection of multiple range of rows within a partition.
|
| Slices.Builder |
Builder to create Slices objects.
|
| Slices.InOrderTester |
|
| Slices.Serializer |
|
| SnappyCompressor |
|
| Snapshot |
|
| SnapshotCommand |
|
| SnapshotDetailsTabularData |
|
| SnapshotLoader |
Loads snapshot metadata from data directories
|
| SnapshotManager |
|
| SnapshotManifest |
|
| SnapshotMessage |
|
| SnapshotsTable |
|
| SnapshotTask |
SnapshotTask is a task that sends snapshot request.
|
| SnapshottingReservoir |
|
| SnapshottingTimer |
|
| SnapshotVerbHandler |
|
| SnitchProperties |
|
| SnitchUtils |
|
| SocketFactory |
A factory for building Netty Channels.
|
| SomeRepairFailedException |
This is a special exception which states "I know something failed but I don't have access to the failure".
|
| SortedBiMultiValMap<K,V> |
|
| SortedTablePartitionWriter |
|
| SortedTableReaderLoadingBuilder<R extends SSTableReader,B extends SSTableReader.Builder<R,B>> |
|
| SortedTableScrubber<R extends SSTableReaderWithFilter> |
|
| SortedTableScrubber.ScrubInfo |
|
| SortedTableVerifier<R extends SSTableReaderWithFilter> |
|
| SortedTableVerifier.RangeOwnHelper |
Use the fact that check(...) is called with sorted tokens - we keep a pointer in to the normalized ranges
and only bump the pointer if the key given is out of range.
|
| SortedTableVerifier.VerifyController |
|
| SortedTableVerifier.VerifyInfo |
|
| SortedTableWriter<P extends SortedTablePartitionWriter,I extends SortedTableWriter.AbstractIndexWriter> |
A generic implementation of a writer which assumes the existence of some partition index and bloom filter.
|
| SortedTableWriter.AbstractIndexWriter |
|
| SortedTableWriter.Builder<P extends SortedTablePartitionWriter,I extends SortedTableWriter.AbstractIndexWriter,W extends SortedTableWriter<P,I>,B extends SortedTableWriter.Builder<P,I,W,B>> |
|
| SpeculativeRetryPolicy |
|
| SpeculativeRetryPolicy.Kind |
|
| SpiffeCertificateValidator |
This class assumes that the identity of a certificate is SPIFFE which is a URI that is present as part of the SAN
of the client certificate.
|
| SpinningDiskOptimizationStrategy |
|
| Splitter |
Partition splitter.
|
| Splitter.WeightedRange |
|
| SplittingSizeTieredCompactionWriter |
CompactionAwareWriter that splits input in differently sized sstables
Biggest sstable will be total_compaction_size / 2, second biggest total_compaction_size / 4 etc until
the result would be sub 50MiB, all those are put in the same
|
| SsdDiskOptimizationStrategy |
|
| SSLFactory |
A Factory for providing and setting up client SSLSockets.
|
| SSLFactory.LoggingCipherSuiteFilter |
|
| SSTable |
|
| SSTable.Builder<S extends SSTable,B extends SSTable.Builder<S,B>> |
A builder of this sstable representation.
|
| SSTable.Owner |
|
| SSTableAddedNotification |
|
| SSTableComponentsWriter |
|
| SSTableContext |
An SSTableContext is created for an individual sstable and is shared across column indexes to track per-sstable
index files. |
| SSTableContextManager |
|
| SSTableDeletingNotification |
Fired right before removing an SSTable.
|
| SSTableExpiredBlockers |
During compaction we can drop entire sstables if they only contain expired tombstones and if it is guaranteed
to not cover anything in other sstables.
|
| SSTableExport |
Export SSTables to JSON format.
|
| SSTableFlushObserver |
Observer for events in the lifecycle of writing out an sstable.
|
| SSTableFormat<R extends SSTableReader,W extends SSTableWriter> |
Provides the accessors to data on disk.
|
| SSTableFormat.Components |
|
| SSTableFormat.Components.Types |
|
| SSTableFormat.Factory |
|
| SSTableFormat.KeyCacheValueSerializer<R extends SSTableReader,T extends AbstractRowIndexEntry> |
|
| SSTableFormat.SSTableReaderFactory<R extends SSTableReader,B extends SSTableReader.Builder<R,B>> |
|
| SSTableFormat.SSTableWriterFactory<W extends SSTableWriter,B extends SSTableWriter.Builder<W,B>> |
|
| SSTableId |
Represents a unique identifier in the sstable descriptor filename.
|
| SSTableId.Builder<T extends SSTableId> |
Builder that can create instances of certain implementation of SSTableId. |
| SSTableIdentityIterator |
|
| SSTableIdFactory |
|
| SSTableImporter |
|
| SSTableImporter.Options |
|
| SSTableIndex |
A reference-counted container of a SSTableReader for each column index that:
Manages references to the SSTable for each query
Exposes a version agnostic searcher onto the column index
Exposes the index metadata for the column index
|
| SSTableIndex |
|
| SSTableIndexesSystemView |
A VirtualTable providing a system view of SSTable index metadata. |
| SSTableIndexWriter |
Column index writer that accumulates (on-heap) indexed data from a compacted SSTable as it's being flushed to disk.
|
| SSTableIntervalTree |
|
| SSTableIterator |
A Cell Iterator over SSTable
|
| SSTableLevelResetter |
Reset level to 0 on a given set of sstables
|
| SSTableListChangedNotification |
|
| SSTableLoader |
Cassandra SSTable bulk loader.
|
| SSTableLoader.Client |
|
| SSTableMetadataChanged |
|
| SSTableMetadataViewer |
Shows the contents of sstable metadata
|
| SSTableMultiWriter |
|
| SSTableOfflineRelevel |
Create a decent leveling for the given keyspace/column family
Approach is to sort the sstables by their last token
given an original leveling like this (note that [ ] indicates token boundaries, not sstable size on disk, all sstables are the same size)
L3 [][][][][][][][][][][]
L2 [ ][ ][ ][ ]
L1 [ ][ ]
L0 [ ]
Will look like this after being dropped to L0 and sorted by last token (and, to illustrate overlap, the overlapping ones are put on a new line):
[][][]
[ ][][][]
[ ]
[ ]
...
|
| SSTablePartitions |
|
| SSTableReader |
An SSTableReader can be constructed in a number of places, but typically is either read from disk at startup, or
constructed from a flushed memtable, or after compaction to replace some existing sstables.
|
| SSTableReader.Builder<R extends SSTableReader,B extends SSTableReader.Builder<R,B>> |
A builder of this sstable reader.
|
| SSTableReader.IndexesBounds |
|
| SSTableReader.InstanceTidier |
One instance per SSTableReader we create.
|
| SSTableReader.OpenReason |
|
| SSTableReader.Operator |
TODO: Move someplace reusable
|
| SSTableReader.PartitionPositionBounds |
|
| SSTableReader.UniqueIdentifier |
|
| SSTableReaderLoadingBuilder<R extends SSTableReader,B extends SSTableReader.Builder<R,B>> |
|
| SSTableReaderWithFilter |
|
| SSTableReaderWithFilter.Builder<R extends SSTableReaderWithFilter,B extends SSTableReaderWithFilter.Builder<R,B>> |
|
| SSTableReadsListener |
Listener for receiving notifications associated with reading SSTables.
|
| SSTableReadsListener.SelectionReason |
The reasons for selecting an SSTable
|
| SSTableReadsListener.SkippingReason |
The reasons for skipping an SSTable
|
| SSTableRepairedAtSetter |
|
| SSTableRepairStatusChanged |
|
| SSTableReversedIterator |
A Cell Iterator in reversed clustering order over SSTable
|
| SSTableRewriter |
Wraps one or more writers as output for rewriting one or more readers: every sstable_preemptive_open_interval
we look in the summary we're collecting for the latest writer for the penultimate key that we know to have been fully
flushed to the index file, and then double check that the key is fully present in the flushed data file.
|
| SSTableScanner<S extends SSTableReader,E extends AbstractRowIndexEntry,I extends SSTableScanner.BaseKeyScanningIterator> |
|
| SSTableSet |
|
| SSTablesGlobalTracker |
Tracks all sstables in use on the local node.
|
| SSTableSimpleIterator |
Utility class to handle deserializing atom from sstables.
|
| SSTableSplitter |
|
| SSTableSplitter.SplitController |
|
| SSTableSplitter.SplittingCompactionTask |
|
| SSTablesVersionsInUseChangeNotification |
Notification triggered by a SSTablesGlobalTracker when the set of sstables versions in use on this node
changes. |
| SSTableTxnWriter |
A wrapper for SSTableWriter and LifecycleTransaction to be used when
the writer is the only participant in the transaction and therefore
it can safely own the transaction.
|
| SSTableWriter |
A root class for a writer implementation.
|
| SSTableWriter.Builder<W extends SSTableWriter,B extends SSTableWriter.Builder<W,B>> |
A builder of this sstable writer.
|
| SSTableWriter.SSTableSizeParameters |
Parameters for calculating the expected size of an SSTable.
|
| SSTableZeroCopyWriter |
|
| Stage |
|
| Stage.ExecutorServiceInitialiser |
|
| StandaloneScrubber |
|
| StandaloneSplitter |
|
| StandaloneSSTableUtil |
|
| StandaloneUpgrader |
|
| StandaloneVerifier |
|
| StandardAnalyzer |
|
| StandardAnalyzer.TokenType |
|
| StandardTokenizerInterface |
Internal interface for supporting versioned grammars.
|
| StandardTokenizerOptions |
Various options for controlling tokenization and enabling
or disabling features
|
| StandardTokenizerOptions.OptionsBuilder |
|
| StartupCheck |
A test to determine if the system is in a valid state to start up.
|
| StartupChecks |
Verifies that the system and environment is in a fit state to be started.
|
| StartupChecks.StartupCheckType |
|
| StartupChecksOptions |
|
| StartupClusterConnectivityChecker |
|
| StartupException |
An exception thrown during system startup, indicating the environment or system
is not in a valid state to startup.
|
| StartupMessage |
The initial message of the protocol.
|
| State<T extends java.lang.Enum<T>,I> |
|
| StatementRestrictions |
The restrictions corresponding to the relations specified on the where-clause of CQL query.
|
| StatementType |
|
| StaticTokenTreeBuilder |
|
| StatsComponent |
|
| StatsHolder |
Interface for the Stats property bag
|
| StatsKeyspace |
|
| StatsMetadata |
SSTable metadata that always stay on heap.
|
| StatsMetadata.StatsMetadataSerializer |
|
| StatsPrinter<T extends StatsHolder> |
Interface for the Stats printer, that'd output statistics
given the StatsHolder
|
| StatsPrinter.JsonPrinter<T extends StatsHolder> |
|
| StatsPrinter.YamlPrinter<T extends StatsHolder> |
|
| StatsTable |
|
| StatsTableComparator |
Comparator to sort StatsTables by a named statistic.
|
| Status |
|
| StatusAutoCompaction |
|
| StatusBackup |
|
| StatusBinary |
|
| StatusGossip |
|
| StatusHandoff |
|
| StatusLogger |
|
| StatusRequest |
|
| StatusResponse |
|
| StemmerFactory |
Returns a SnowballStemmer instance appropriate for
a given language
|
| StemmingFilters |
Filters for performing Stemming on tokens
|
| StemmingFilters.DefaultStemmingFilter |
|
| Stop |
|
| StopDaemon |
|
| StoppingTransformation<I extends BaseRowIterator<?>> |
|
| StopWordFactory |
Provides a list of Stop Words for a given language
|
| StopWordFilters |
Filter implementations for input matching Stop Words
|
| StopWordFilters.DefaultStopWordFilter |
|
| StorageAttachedIndex |
|
| StorageAttachedIndexBuilder |
Multiple storage-attached indexes can start building concurrently.
|
| StorageAttachedIndexGroup |
Orchestrates building of storage-attached indices, and manages lifecycle of resources shared between them.
|
| StorageAttachedIndexOptions |
|
| StorageAttachedIndexQueryPlan |
|
| StorageAttachedIndexSearcher |
|
| StorageAttachedIndexTables |
|
| StorageAttachedIndexWriter |
Writes all on-disk index structures attached to a given SSTable.
|
| StorageCompatibilityMode |
The mode of compatibility with older Cassandra versions.
|
| StorageHook |
|
| StorageMetrics |
Metrics related to Storage.
|
| StorageProxy |
|
| StorageProxy.LocalReadRunnable |
|
| StorageProxy.WritePerformer |
|
| StorageProxyMBean |
|
| StorageService |
This abstraction contains the token/identifier of this node
on the identifier space.
|
| StorageService.Mode |
|
| StorageServiceMBean |
|
| StorageServiceMBean.StageConcurrency |
Gets the concurrency settings for processing stages
|
| StreamCompressionInputStream |
|
| StreamCompressionSerializer |
A serialiazer for stream compressed files (see package-level documentation).
|
| StreamConnectionFactory |
|
| StreamCoordinator |
StreamCoordinator is a helper class that abstracts away maintaining multiple
StreamSession and ProgressInfo instances per peer. |
| StreamDeserializingTask |
The task that performs the actual deserialization.
|
| StreamEvent |
|
| StreamEvent.ProgressEvent |
|
| StreamEvent.SessionCompleteEvent |
|
| StreamEvent.SessionPreparedEvent |
|
| StreamEvent.Type |
|
| StreamEventHandler |
|
| StreamEventJMXNotifier |
|
| StreamException |
|
| StreamExecutor |
|
| StreamFromOptions |
Keeps track of where a node needs to stream a given range from.
|
| StreamHook |
|
| StreamingChannel |
|
| StreamingChannel.Factory |
|
| StreamingChannel.Factory.Global |
|
| StreamingChannel.Kind |
|
| StreamingChannel.Send |
|
| StreamingDataInputPlus |
|
| StreamingDataOutputPlus |
|
| StreamingDataOutputPlus.BufferSupplier |
|
| StreamingDataOutputPlus.RateLimiter |
|
| StreamingDataOutputPlus.Write |
|
| StreamingDataOutputPlusFixed |
|
| StreamingMetrics |
Metrics for streaming.
|
| StreamingMultiplexedChannel |
|
| StreamingRepairTask |
StreamingRepairTask performs data streaming between two remote replicas, neither of which is repair coordinator.
|
| StreamingState |
|
| StreamingState.Sessions |
|
| StreamingState.Status |
|
| StreamingTombstoneHistogramBuilder |
Histogram that can be constructed from streaming of data.
|
| StreamingVirtualTable |
|
| StreamInitMessage |
StreamInitMessage is first sent from the node where StreamSession is started,
to initiate corresponding StreamSession on the other side. |
| StreamManager |
StreamManager manages currently running StreamResultFutures and provides status of all operation invoked. |
| StreamManager.StreamListener |
|
| StreamManager.StreamRateLimiter |
|
| StreamManagerMBean |
|
| StreamMessage |
StreamMessage is an abstract base class that every messages in streaming protocol inherit.
|
| StreamMessage.Serializer<V extends StreamMessage> |
StreamMessage serializer
|
| StreamMessage.Type |
StreamMessage types
|
| StreamMessageHeader |
StreamMessageHeader is appended before sending actual data to describe what it's sending.
|
| StreamMessageHeader.FileMessageHeaderSerializer |
|
| StreamOperation |
|
| StreamPlan |
StreamPlan is a helper class that builds StreamOperation of given configuration. |
| StreamReceiveException |
|
| StreamReceiver |
StreamReceiver acts as a staging area for incoming data.
|
| StreamReceiveTask |
Task that manages receiving files for the session for certain ColumnFamily.
|
| StreamRequest |
|
| StreamRequest.StreamRequestSerializer |
|
| StreamResultFuture |
A future on the result ( StreamState) of a streaming plan. |
| StreamSession |
Handles the streaming a one or more streams to and from a specific remote node.
|
| StreamSession.MessageStateSink |
|
| StreamSession.PrepareDirection |
|
| StreamSession.State |
State Transition:
|
| StreamState |
Current snapshot of streaming progress.
|
| StreamStateCompositeData |
|
| StreamStateStore |
Store and update available ranges (data already received) to system keyspace.
|
| StreamSummary |
Summary of streaming.
|
| StreamSummary.StreamSummarySerializer |
|
| StreamSummaryCompositeData |
|
| StreamTask |
StreamTask is an abstraction of the streaming task performed over specific ColumnFamily.
|
| StreamTransferTask |
StreamTransferTask sends streams for a given table
|
| StringType |
|
| SubnetGroups |
When a group of subnets are needed, this class can be used to represent the group as if it was a single subnet.
|
| SuffixSA |
|
| SupportedMessage |
Message to indicate that the server is ready to receive requests.
|
| SymmetricRemoteSyncTask |
SymmetricRemoteSyncTask sends SyncRequest to remote(non-coordinator) node
to repair(stream) data with other replica. |
| SyncFuture<V> |
Netty's DefaultPromise uses a mutex to coordinate notifiers AND waiters between the eventLoop and the other threads.
|
| SyncFutureTask<T> |
|
| SyncNodePair |
SyncNodePair is used for repair message body to indicate the pair of nodes.
|
| SyncNodePair.NodePairSerializer |
|
| SyncPromise<V> |
|
| SyncPromise.WithExecutor<V> |
|
| SyncRequest |
Body part of SYNC_REQUEST repair message.
|
| SyncResponse |
|
| SyncStat |
Statistics about synchronizing two replica
|
| SyncState |
|
| SyncState.Id |
|
| SyncState.State |
|
| SyncStatSummary |
|
| SyncTask |
|
| SyncUtil |
|
| SyntaxException |
|
| SystemDistributedKeyspace |
|
| SystemKeyspace |
|
| SystemKeyspace.AvailableRanges |
|
| SystemKeyspace.BootstrapState |
|
| SystemKeyspace.TriFunction<A,B,C,D> |
|
| SystemKeyspaceMigrator41 |
Migrate 3.0 versions of some tables to 4.1.
|
| SystemReplicas |
|
| SystemViewsKeyspace |
|
| TableAttributes |
|
| TableBuilder |
Build and print table.
|
| TableBuilder.SharedTable |
Share max offsets across multiple TableBuilders
|
| TableHistograms |
|
| TableId |
The unique identifier of a table.
|
| TableMetadata |
|
| TableMetadata.Builder |
|
| TableMetadata.CompactTableMetadata |
|
| TableMetadata.Flag |
|
| TableMetadata.Kind |
|
| TableMetadataRef |
Encapsulates a volatile reference to an immutable TableMetadata instance. |
| TableMetrics |
|
| TableMetrics.ReleasableMetric |
|
| TableMetrics.TableHistogram |
|
| TableMetrics.TableMeter |
|
| TableMetrics.TableTimer |
|
| TableMetrics.TableTimer.Context |
|
| TableMetricTables |
Contains multiple the Table Metric virtual tables.
|
| TableParams |
|
| TableParams.Builder |
|
| TableParams.Option |
|
| TablePaxosRepairHistory |
|
| TableQueryMetrics |
|
| TableRepairManager |
Table level hook for repair
|
| Tables |
An immutable container for a keyspace's Tables.
|
| Tables.Builder |
|
| Tables.TablesDiff |
|
| TableSnapshot |
|
| TableSnapshot.SnapshotTrueSizeCalculator |
|
| TableStateMetrics |
|
| TableStats |
|
| TableStatsHolder |
|
| TableStatsPrinter<T extends StatsHolder> |
|
| TableStreamManager |
The main streaming hook for a storage implementation.
|
| TableViews |
Groups all the views for a given table.
|
| TableWriteHandler |
|
| TailOverridingRebufferer |
Special rebufferer that replaces the tail of the file (from the specified cutoff point) with the given buffer.
|
| TargetParser |
|
| TaskFactory |
A simple mechanism to impose our desired semantics on the execution of a task without requiring a specialised
executor service.
|
| TaskFactory.LocalAware |
|
| TaskFactory.Standard |
|
| TeeDataInputPlus |
DataInput that also stores the raw inputs into an output buffer
This is useful for storing serialized buffers as they are deserialized.
|
| TemporalType<T> |
Base type for temporal types (timestamp, date ...).
|
| Term |
A CQL3 term, i.e.
|
| Term<T extends java.nio.Buffer> |
|
| Term |
|
| Term.MultiColumnRaw |
|
| Term.MultiItemTerminal |
|
| Term.NonTerminal |
A non terminal term, i.e.
|
| Term.Raw |
A parsed, non prepared (thus untyped) term.
|
| Term.Terminal |
A terminal term, one that can be reduced to a byte buffer directly.
|
| TermIterator |
|
| TermIterator |
|
| Terms |
A set of Terms
|
| TermSelector |
Selector representing a simple term (literals or bound variables).
|
| TermsIterator |
An iterator over the contents of an index that extends Iterator< IndexEntry> that provides the min and max
terms in the index. |
| TermTree |
|
| TermTree.Builder |
|
| ThreadAwareSecurityManager |
Custom SecurityManager and Policy implementation that only performs access checks
if explicitly enabled.
|
| ThreadLocalByteBufferHolder |
Utility class that allow buffers to be reused by storing them in a thread local instance.
|
| ThreadLocals |
|
| ThreadPoolExecutorBase |
This class incorporates some Executor best practices for Cassandra.
|
| ThreadPoolExecutorBuilder<E extends ExecutorPlus> |
|
| ThreadPoolExecutorJMXAdapter |
|
| ThreadPoolExecutorPlus |
|
| ThreadPoolMetrics |
Metrics for ThreadPoolExecutor.
|
| Threads |
|
| Threads.StackTraceCombiner |
|
| Threshold |
A guardrail based on numeric threshold(s).
|
| ThrottledUnfilteredIterator |
|
| Throwables |
|
| Throwables.DiscreteAction<E extends java.lang.Exception> |
|
| Throwables.FileOpType |
|
| TimeFcts |
|
| TimeFcts.FloorDateFunction |
Function that rounds a date down to the closest multiple of a duration.
|
| TimeFcts.FloorTimestampFunction |
Function that rounds a timestamp down to the closest multiple of a duration.
|
| TimeFcts.FloorTimeUuidFunction |
Function that rounds a timeUUID down to the closest multiple of a duration.
|
| TimeFcts.TemporalConversionFunction |
|
| TimeQuotaExceededException |
|
| TimeSerializer |
|
| TimestampSerializer |
|
| TimestampType |
Type for date-time values.
|
| TimeType |
Nanosecond resolution time values
|
| TimeUUID |
|
| TimeUUID.AbstractSerializer<T extends TimeUUID> |
|
| TimeUUID.Generator |
|
| TimeUUID.Serializer |
|
| TimeUUIDType |
|
| TimeWindowCompactionController |
|
| TimeWindowCompactionStrategy |
|
| TimeWindowCompactionStrategyOptions |
|
| TimeWindowCompactionTask |
|
| TinyThreadLocalPool<V> |
|
| TinyThreadLocalPool.TinyPool<V> |
|
| TOCComponent |
|
| ToJsonFct |
|
| Token |
|
| Token |
|
| Token.KeyBound |
|
| Token.TokenFactory |
|
| Token.TokenSerializer |
|
| TokenAllocation |
|
| TokenAllocator<Unit> |
|
| TokenAllocatorBase<Unit> |
|
| TokenAllocatorFactory |
|
| TokenFct |
|
| TokenMetadata |
|
| TokenMetadata.Topology |
Tracks the assignment of racks and endpoints in each datacenter for all the "normal" endpoints
in this TokenMetadata.
|
| TokenMetadataEvent |
|
| TokenMetadataEvent.TokenMetadataEventType |
|
| TokenRange |
|
| TokenRange.EndpointDetails |
|
| TokenRelation |
A relation using the token function.
|
| TokenRestriction |
Restriction using the token function.
|
| TokenRestriction.EQRestriction |
|
| TokenRestriction.SliceRestriction |
|
| TokenSerializer |
|
| TokenTree |
|
| TokenTree.OnDiskToken |
|
| TokenTreeBuilder |
|
| TokenTreeBuilder.EntryType |
|
| TombstoneAbortException |
|
| TombstoneHistogram |
|
| TombstoneHistogram.HistogramSerializer |
|
| TombstoneHistogram.LegacyHistogramSerializer |
|
| TombstoneOverwhelmingException |
|
| TopPartitions |
Deprecated. |
| TopPartitionTracker |
Tracks top partitions, currently by size and by tombstone count
Collects during full and preview (-vd) repair since then we read the full partition
Note that since we can run sub range repair there might be windows where the top partitions are not correct -
for example, assume we track the top 2 partitions for this node:
tokens with size:
(a, 100); (b, 40); (c, 10); (d, 100); (e, 50); (f, 10)
- top2: a, d
now a is deleted and we run a repair for keys [a, c]
- top2: b, d
and when we repair [d, f]
- top2: d, e
|
| TopPartitionTracker.Collector |
|
| TopPartitionTracker.StoredTopPartitions |
|
| TopPartitionTracker.TombstoneCounter |
|
| TopPartitionTracker.TopHolder |
|
| TopPartitionTracker.TopPartition |
|
| TpStats |
|
| TpStatsHolder |
|
| TpStatsPrinter |
|
| TpStatsPrinter.DefaultPrinter |
|
| TraceKeyspace |
|
| TraceState |
ThreadLocal state for a tracing session.
|
| TraceState.Status |
|
| TraceStateImpl |
ThreadLocal state for a tracing session.
|
| Tracing |
A trace session context.
|
| Tracing.TraceType |
|
| TrackedDataInputPlus |
This class is to track bytes read from given DataInput
|
| TrackedInputStream |
This class is to track bytes read from given DataInputStream
|
| Tracker |
Tracker tracks live View of data store for a table. |
| Transactional |
An abstraction for Transactional behaviour.
|
| Transactional.AbstractTransactional |
A simple abstract implementation of Transactional behaviour.
|
| Transactional.AbstractTransactional.State |
|
| TransactionAlreadyCompletedException |
|
| Transformation<I extends BaseRowIterator<?>> |
We have a single common superclass for all Transformations to make implementation efficient.
|
| TransparentDataEncryptionOptions |
|
| TransportException |
|
| TreeResponse |
Merkle tree response sent from given endpoint.
|
| Trie<T> |
Base class for tries.
|
| Trie<K,V> |
Defines the interface for a prefix tree, an ordered tree data structure.
|
| Trie.CollectionMergeResolver<T> |
Resolver of content of merged nodes.
|
| Trie.Cursor<T> |
A trie cursor.
|
| Trie.MergeResolver<T> |
Resolver of content of merged nodes, used for two-source merges (i.e.
|
| Trie.ResettingTransitionsReceiver |
|
| Trie.TransitionsReceiver |
|
| Trie.ValueConsumer<T> |
|
| Trie.Walker<T,R> |
A push interface for walking over the trie.
|
| TrieEntriesIterator<T,V> |
|
| TrieEntriesWalker<T,V> |
Walker of trie entries, used with Trie.process to walk all content in order and provide the path through which values
are reached.
|
| TrieMemIndex |
|
| TrieMemIndex.ConcurrentPrefixTrie |
|
| TrieMemIndex.ConcurrentSuffixTrie |
|
| TrieMemoryIndex |
|
| TrieMemtable |
Trie memtable implementation.
|
| TrieMemtableMetricsView |
|
| TrieNode |
Trie node types and manipulation mechanisms.
|
| TriePathReconstructor |
|
| Tries |
A collection of Trie utilities |
| TrieSerializer<VALUE,DEST> |
|
| TrieTermsDictionaryReader |
|
| TrieTermsDictionaryWriter |
|
| TriggerExecutor |
|
| TriggerMetadata |
|
| Triggers |
|
| Triggers.Builder |
|
| TruncateException |
|
| TruncateHints |
|
| TruncateRequest |
A truncate operation descriptor
|
| TruncateResponse |
This message is sent back the truncate operation and basically specifies if
the truncate succeeded.
|
| TruncateResponse.TruncateResponseSerializer |
|
| TruncateResponseHandler |
|
| TruncateStatement |
|
| TruncateVerbHandler |
|
| TruncationNotification |
Fired during truncate, after the memtable has been flushed but before any
snapshot is taken and SSTables are discarded
|
| Tuples |
Static helper methods and classes for tuples.
|
| Tuples.DelayedValue |
Similar to Value, but contains at least one NonTerminal, such as a non-pure functions or bind marker.
|
| Tuples.InMarker |
Represents a marker for a set of IN values that are tuples, like "SELECT ...
|
| Tuples.INRaw |
A raw marker for an IN list of tuples, like "SELECT ...
|
| Tuples.InValue |
A terminal value for a list of IN values that are tuples.
|
| Tuples.Literal |
A raw, literal tuple.
|
| Tuples.Marker |
Represents a marker for a single tuple, like "SELECT ... WHERE (a, b, c) > ?"
|
| Tuples.Raw |
A raw placeholder for a tuple of values for different multiple columns, each of which may have a different type.
|
| Tuples.Value |
A tuple of terminal values (e.g (123, 'abc')).
|
| TupleSerializer |
|
| TupleType |
A tuple type.
|
| TupleType |
This is essentially like a CompositeType, but it's not primarily meant for comparison, just
to pack multiple values together so has a more friendly encoding.
|
| TupleValue |
A value for a Tuple.
|
| TypeCast |
|
| TypeCodec<T> |
A Codec that can serialize and deserialize to and from a given CQL type and
a given Java Type. |
| TypeCodec.AbstractCollectionCodec<E,C extends java.util.Collection<E>> |
Base class for codecs mapping CQL lists and sets to Java collections. |
| TypeCodec.AbstractMapCodec<K,V> |
Base class for codecs mapping CQL maps to a Java
Map. |
| TypeCodec.AbstractTupleCodec<T> |
Base class for codecs mapping CQL tuples to Java objects. |
| TypeCodec.AbstractUDTCodec<T> |
|
| TypeCodec.PrimitiveBooleanCodec |
A codec that is capable of handling primitive booleans, thus avoiding the overhead of boxing
and unboxing such primitives.
|
| TypeCodec.PrimitiveByteCodec |
A codec that is capable of handling primitive bytes, thus avoiding the overhead of boxing and
unboxing such primitives.
|
| TypeCodec.PrimitiveDoubleCodec |
A codec that is capable of handling primitive doubles, thus avoiding the overhead of boxing and
unboxing such primitives.
|
| TypeCodec.PrimitiveFloatCodec |
A codec that is capable of handling primitive floats, thus avoiding the overhead of boxing and
unboxing such primitives.
|
| TypeCodec.PrimitiveIntCodec |
A codec that is capable of handling primitive ints, thus avoiding the overhead of boxing and
unboxing such primitives.
|
| TypeCodec.PrimitiveLongCodec |
A codec that is capable of handling primitive longs, thus avoiding the overhead of boxing and
unboxing such primitives.
|
| TypeCodec.PrimitiveShortCodec |
A codec that is capable of handling primitive shorts, thus avoiding the overhead of boxing and
unboxing such primitives.
|
| TypeParser |
Parse a string containing an Type definition.
|
| TypeParser.Vector |
|
| Types |
An immutable container for a keyspace's UDTs.
|
| Types.Builder |
|
| Types.RawBuilder |
|
| TypeSerializer<T> |
|
| TypeSizes |
|
| TypeTokens |
Utility methods to create TypeToken instances.
|
| TypeUtil |
|
| UDAggregate |
Base class for user-defined-aggregates.
|
| UDFByteCodeVerifier |
Verifies Java UDF byte code.
|
| UDFContext |
Provides context information for a particular user defined function.
|
| UDFContextImpl |
|
| UDFDataType |
Represents a data type used within the UDF/UDA.
|
| UDFunction |
Base class for User Defined Functions.
|
| UDTValue |
A value for a User Defined Type.
|
| UnaccessibleFieldException |
|
| UnauthorizedException |
|
| UnavailableException |
|
| UnbufferedDataOutputStreamPlus |
Base class for DataOutput implementations that does not have an optimized implementations of Plus methods
and does no buffering.
|
| UncheckedInterruptedException |
Unchecked InterruptedException, to be thrown in places where an interrupt is unexpected
|
| UncommittedDataFile |
|
| UncommittedPaxosKey |
|
| UncommittedTableData |
On memtable flush
|
| UncommittedTableData.FlushWriter |
|
| Unfiltered |
Unfiltered is the common class for the main constituent of an unfiltered partition.
|
| Unfiltered.Kind |
|
| UnfilteredDeserializer |
Helper class to deserialize Unfiltered object from disk efficiently.
|
| UnfilteredPartitionIterator |
An iterator over a number of unfiltered partitions (i.e.
|
| UnfilteredPartitionIterators |
Static methods to work with partition iterators.
|
| UnfilteredPartitionIterators.MergeListener |
|
| UnfilteredPartitionIterators.Serializer |
Serialize each UnfilteredSerializer one after the other, with an initial byte that indicates whether
we're done or not.
|
| UnfilteredRowIterator |
An iterator over the rows of a given partition that also includes deletion informations.
|
| UnfilteredRowIterators |
Static methods to work with atom iterators.
|
| UnfilteredRowIterators.MergeListener |
Interface for a listener interested in the result of merging multiple versions of a given row.
|
| UnfilteredRowIteratorSerializer |
Serialize/Deserialize an unfiltered row iterator.
|
| UnfilteredRowIteratorSerializer.Header |
|
| UnfilteredRowIteratorWithLowerBound |
An unfiltered row iterator with a lower bound retrieved from either the global
sstable statistics or the row index lower bounds (if available in the cache).
|
| UnfilteredSerializer |
Serialize/deserialize a single Unfiltered (both on-wire and on-disk).
|
| UnfilteredSource |
Common data access interface for sstables and memtables.
|
| UnfilteredValidation |
Handles unfiltered validation - if configured, it checks if the provided unfiltered has
invalid deletions (if the local deletion time is negative or if the ttl is negative) and
then either logs or throws an exception if so.
|
| UnifiedCompactionStrategy |
The design of the unified compaction strategy is described in the accompanying UnifiedCompactionStrategy.md.
|
| UnifiedCompactionStrategy.Level |
A level: index, sstables and some properties.
|
| UnifiedCompactionStrategy.MultiSetBucket |
|
| UnifiedCompactionStrategy.SimpleBucket |
|
| UnifiedCompactionTask |
|
| UnknownColumnException |
|
| UnknownIndexException |
Exception thrown when we read an index id from a serialized ReadCommand and no corresponding IndexMetadata
can be found in the TableMetadata#indexes collection.
|
| UnknownTableException |
|
| UnrecoverableIllegalStateException |
|
| UnsupportedMessageCodec<T extends Message> |
Catch-all codec for any unsupported legacy messages.
|
| UntypedResultSet |
a utility for doing internal cql-based queries
|
| UntypedResultSet.Row |
|
| UpdateCIDRGroup |
|
| UpdateFunction<K,V> |
An interface defining the method to be applied to the existing and replacing object in a BTree.
|
| UpdateFunction.Simple<V> |
|
| UpdateParameters |
Groups the parameters of an update query, and make building updates easier.
|
| UpdatesCollector |
|
| UpdateStatement |
An UPDATE statement parsed from a CQL query statement.
|
| UpdateStatement.ParsedInsert |
|
| UpdateStatement.ParsedInsertJson |
A parsed INSERT JSON statement.
|
| UpdateStatement.ParsedUpdate |
|
| UpdateTransaction |
Handling of index updates on the write path.
|
| Upgrader |
|
| UpgradeSSTable |
|
| UserFunction |
A non-native, user-defined function, like UDFs and UDAs.
|
| UserFunctions |
An immutable container for a keyspace's UDAs and UDFs.
|
| UserFunctions.Builder |
|
| UserFunctions.Filter |
|
| UserFunctions.FunctionsDiff<T extends Function> |
|
| UserType |
A User Defined Type (UDT).
|
| UserType |
A user defined type.
|
| UserType.Field |
A UDT field.
|
| UserTypes |
Static helper methods and classes for user types.
|
| UserTypes.DelayedValue |
|
| UserTypes.DeleterByField |
|
| UserTypes.Literal |
|
| UserTypes.Marker |
|
| UserTypes.Setter |
|
| UserTypes.SetterByField |
|
| UserTypes.Value |
|
| UserTypeSerializer |
|
| UseStatement |
|
| UTF8Serializer |
|
| UTF8Type |
|
| Util |
|
| Util.TermHistogram |
|
| UTName |
|
| UUIDBasedSSTableId |
SSTable generation identifiers that can be stored across nodes in one directory/bucket
|
| UUIDBasedSSTableId.Builder |
|
| UuidFcts |
|
| UUIDGen |
The goods are here: www.ietf.org/rfc/rfc4122.txt.
|
| UUIDSerializer |
|
| UUIDSerializer |
|
| UUIDType |
Compares UUIDs using the following criteria:
- if count of supplied bytes is less than 16, compare counts
- compare UUID version fields
- nil UUID is always lesser
- compare timestamps if both are time-based
- compare lexically, unsigned msb-to-lsb comparison
|
| V1OnDiskFormat |
|
| V1SSTableIndex |
A version specific implementation of the SSTableIndex where the
index is segmented |
| Validation |
A collection of static validation functions reused across statements.
|
| ValidationManager |
|
| ValidationMetadata |
SSTable metadata component used only for validating SSTable.
|
| ValidationMetadata.ValidationMetadataSerializer |
|
| ValidationPartitionIterator |
|
| ValidationRequest |
ValidationRequest
|
| ValidationResponse |
ValidationComplete message is sent when validation compaction completed successfully.
|
| ValidationState |
|
| ValidationState.State |
|
| ValidationTask |
|
| Validator |
Handles the building of a merkle tree for a column family.
|
| ValueAccessor<V> |
ValueAccessor allows serializers and other code dealing with raw bytes to operate on different backing types
(ie: byte arrays, byte buffers, etc) without requiring that the supported backing types share a common type
ancestor and without incuring the allocation cost of a wrapper object.
|
| ValueAccessor.ObjectFactory<V> |
Creates db objects using the given accessors value type.
|
| ValueComparators |
|
| ValueIterator<CONCRETE extends ValueIterator<CONCRETE>> |
Thread-unsafe value iterator for on-disk tries.
|
| ValueIterator.IterationPosition |
|
| Values<T> |
A guardrail that warns about some specific values, warns about but ignores some other values, and/or rejects the use
of some other values.
|
| VariableSpecifications |
|
| VectorCodec<E> |
|
| VectorFcts |
|
| VectorIndexSegmentSearcher |
Executes ANN search against a vector graph for an individual index segment.
|
| VectorMemoryIndex |
|
| VectorPostingList |
|
| VectorPostings<T> |
|
| VectorPostingsWriter<T> |
|
| VectorQueryContext |
This represents the state of a vector query.
|
| Vectors |
|
| Vectors.DelayedValue<T> |
Basically similar to a Value, but with some non-pure function (that need
to be evaluated at execution time) in it.
|
| Vectors.Literal |
|
| Vectors.Value<T> |
|
| VectorSelector |
|
| VectorTopKProcessor |
Processor that scans all rows from given partitions and selects rows with top-k scores based on vector indexes.
|
| VectorType |
A vector type.
|
| VectorType<T> |
|
| Verb |
Note that priorities except P0 are presently unused.
|
| Verb.Kind |
|
| Verb.Priority |
|
| Verify |
|
| Version |
Format version of indexing component, denoted as [major][minor].
|
| Version |
A set of feature flags associated with a SSTable format
|
| Version |
|
| Version.FileNameFormatter |
|
| VersionedValue |
This abstraction represents the state associated with a particular node which an
application wants to make available to the rest of the nodes in the cluster.
|
| VersionedValue.VersionedValueFactory |
|
| VersionGenerator |
A unique version number generator for any state that is generated by the
local node.
|
| View |
An immutable structure holding the current memtable, the memtables pending
flush, the sstables for a column family, and the sstables that are active
in compaction (a subset of the sstables).
|
| View |
A View copies data from a base table into a view table which can be queried independently from the
base.
|
| View |
The View is an immutable, point in time, view of the avalailable SSTableIndexes for an index. |
| View |
|
| ViewBuilderTask |
|
| ViewBuildStatus |
|
| ViewManager |
|
| ViewMetadata |
|
| Views |
|
| Views.Builder |
|
| ViewUpdateGenerator |
Creates the updates to apply to a view given the existing rows in the base
table and the updates that we're applying to them (this handles updates
on a single partition only).
|
| ViewUtils |
|
| ViewWriteMetrics |
|
| VIntCoding |
Borrows idea from
https://developers.google.com/protocol-buffers/docs/encoding#varints
|
| VIntCoding.VIntOutOfRangeException |
Throw when attempting to decode a vint and the output type
doesn't have enough space to fit the value that was decoded
|
| VirtualKeyspace |
|
| VirtualKeyspaceRegistry |
|
| VirtualMutation |
A specialised IMutation implementation for virtual keyspaces.
|
| VirtualSchemaKeyspace |
|
| VirtualTable |
A system view used to expose system information.
|
| VirtualTableAppender |
Appends Cassandra logs to virtual table system_views.system_logs
|
| VoidSerializer |
|
| WaitQueue |
A relatively easy to use utility for general purpose thread signalling.
|
| WaitQueue.Signal |
A Signal is a one-time-use mechanism for a thread to wait for notification that some condition
state has transitioned that it may be interested in (and hence should check if it is).
|
| WaitQueue.Standard |
|
| WaitQueue.Standard.AbstractSignal |
An abstract signal implementation
TODO: use intrusive linked list
|
| Walker<CONCRETE extends Walker<CONCRETE>> |
Thread-unsafe trie walking helper.
|
| Walker.Extractor<RESULT,VALUE> |
|
| Walker.PayloadToString |
|
| Walker.TransitionBytesCollector |
|
| WarnAbortCounter |
|
| WarningContext |
|
| WarningsSnapshot |
|
| WarningsSnapshot.Builder |
|
| WarningsSnapshot.Counter |
|
| WarningsSnapshot.Warnings |
|
| WeightedQueue<T> |
Weighted queue is a wrapper around any blocking queue that turns it into a blocking weighted queue.
|
| WeightedQueue.Weighable |
|
| WeightedQueue.Weigher<T> |
|
| WhereClause |
|
| WhereClause.Builder |
|
| WidePrimaryKeyMap |
|
| WidePrimaryKeyMap.Factory |
|
| WithOnlyQueriedData<I extends BaseRowIterator<?>> |
Function to skip cells (from an iterator) that are not part of those queried by the user
according to the provided ColumnFilter.
|
| WithResources |
A generic interface for encapsulating a Runnable task with related work before and after execution,
using the built-in try-with-resources functionality offered by Closeable. |
| WithResources.None |
|
| Wrapped<T> |
Simple wrapper class to be used when a lambda function
needs to modify a variable outside it's scope.
|
| WrappedBoolean |
Simple wrapper for native boolean type
|
| WrappedDataOutputStreamPlus |
|
| WrappedException |
Wrapped runtime exception for lambda functions
|
| WrappedExecutorPlus |
|
| WrappedLifecycleTransaction |
|
| WrappedRunnable |
|
| WrappedSharedCloseable |
An implementation of SharedCloseable that wraps a normal AutoCloseable,
ensuring its close method is only called when all instances of SharedCloseable have been
|
| WrappingRebufferer |
Instantiated once per RandomAccessReader, thread-unsafe.
|
| WrappingUnfilteredRowIterator |
Abstract class to make writing unfiltered iterators that wrap another iterator
easier.
|
| WriteContext |
Issued by the keyspace write handler and used in the write path (as expected), as well as the read path
and some async index building code.
|
| WriteFailureException |
|
| WriteResponseHandler<T> |
Handles blocking writes for ONE, ANY, TWO, THREE, QUORUM, and ALL consistency levels.
|
| WriteTimeoutException |
|
| WriteType |
|
| YamlConfigurationLoader |
|
| ZstdCompressor |
ZSTD Compressor
|