All Classes and Interfaces
Class
Description
A memtable that uses memory tracked and maybe allocated via a MemtableAllocator from a MemtablePool.
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.Base abstract class for
Cell implementations.Abstract CIDR authorizer, contains code common to all implementations of ICIDRAuthorizer
Performs eager-creation of commit log segments in a background thread.
AbstractCompactionController allows custom implementations of the CompactionController for use in tooling, without being tied to the SSTableReader and local filesystem
Pluggable compaction strategy determines how SSTables get merged.
A class avoiding class duplication between CompositeType and
DynamicCompositeType.
Base class for our native/hardcoded functions.
Our default
Future implementation, with all state being managed without locks (except those used by the JVM).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.
A single bind marker.
A raw placeholder for multiple values of the same type for a single column.
A MultiColumnRaw version of AbstractMarker.Raw
A parsed, but non prepared, bind marker.
Memtable that uses a commit log for persistence.
Core logic for handling inbound message deserialization and execution (in tandem with
FrameDecoder).A special-purpose wait queue to park inbound message handlers that failed to allocate
reserve capacity for a message in.
An abstract virtual table implementation that builds the resultset on demand and allows fine-grained source
modification via INSERT/UPDATE, DELETE and TRUNCATE operations.
A regular column value.
A set of partition key or clustering column values.
An endpoint snitch tells Cassandra information about network topology that it can use to route
requests more efficiently.
Sends a read request to the replicas needed to satisfy a given ConsistencyLevel.
A collection like class for Replica objects.
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?
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).
A abstract parent for all replication strategies.
Base abstract class for
Row implementations.The base RowIndexEntry is not stored on disk, only specifies a position in the data file
Abstract class implementing
ISslContextFacotry to provide most of the functionality that any
implementation might need.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
Maps sstables to their token partition bucket
Specifies a Comparator for a specific type of ByteBuffer.
ArgumentDeserializer that uses the type deserialization.An abstract virtual table implementation that builds the resultset on demand.
An abstract, map-backed DataSet implementation.
A simple append-only collection supporting an unbounded number of concurrent readers/writers,
but a bounded number of items.
ActiveRepairService is the starting point for manual "active" repairs.
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.
Cqlsh statement to add identity into roles_to_identity table for storing authorized identities for mTLS connections.
Factory methods for aggregate functions.
Performs a calculation on a set of values and return a single value.
An aggregation operation.
QueryPager that takes care of fetching the pages for aggregation queries.Defines how rows should be grouped for creating aggregates.
Factory for
AggregationSpecification.The
AggregationSpecification kinds.A snitch that assumes an ECS region is a DC and an ECS availability_zone
is a rack.
AllowAllCIDRAuthorizer allows any user to access from any CIDR
i.e, disables CIDR authorization
ALTER TABLE [IF EXISTS] <table> ALTER <column> TYPE <newtype>;
No longer supported.ALTER TABLE [IF EXISTS] <table> ALTER [IF EXISTS] <column> ( MASKED WITH <newMask> | DROP MASKED )The various "states" exchanged through Gossip.
Utility used to deserialize function arguments.
The input arguments to a function.
Represents
[a, b, c, d] in CQL.AsymmetricRemoteSyncTask sends
SyncRequest to target node to repair(stream)
data with other target replica.A
DataOutputStreamPlus that writes ASYNCHRONOUSLY to a Netty Channel.See
AsyncPromise and ChannelPromise
This class is all boiler plate, just ensuring we return ourselves and invoke the correct Promise method.Our default
Future implementation, with all state being managed without locks (except those used by the JVM).A
DataOutputStreamPlus that writes ASYNCHRONOUSLY to a Netty Channel.A callback specialized for returning a value from a single target; that is, this is for messages
that we only send to one recipient.
Extends
AsyncFuture to implement the Promise interface.A
DataOutputStreamPlus that writes ASYNCHRONOUSLY to a Netty Channel.A thread-safe and atomic Partition implementation.
AtomicRatio provides thread safe operations to maintain a
AtomicRatio.Ratio of a numerator and denominator.Utility class for the Parser to gather attributes for modification
statements.
wrapper to expose audit events as
DiagnosticEvents.Enum to categorize AuditLogEntries
Central location for managing the logging of client/user-initated actions (like queries, log in commands, and so on).
Tool to view the contenst of AuditLog files in human readable format.
SASL challenge sent from client to server
Only purpose is to Initialize authentication/authorization via
AuthConfig.applyAuth().Returned from IAuthenticator#authenticate(), represents an authenticated user everywhere internally.
Message to indicate that the server is ready to receive requests.
An alternative to the JAAS based implementation of JMXAuthenticator provided
by the JDK (JMXPluggableAuthenticator).
Provides a proxy interface to the platform's MBeanServer instance to perform
role-based authorization on method invocation.
A SASL token message sent from client to server.
SchemaChangeListener implementation that cleans up permissions on dropped resources.
Indicates to the client that authentication has succeeded.
AutoRepair scheduler responsible for running different types of repairs.
Defines configurations for AutoRepair.
Metrics related to AutoRepair.
AutoRepair metrics manager holding all the auto-repair related metrics.
AutoRepair table parameters - used to define the auto-repair configuration for a table.
Implement all the MBeans for AutoRepair.
Defines all the MBeans exposed for AutoRepair.
AutoRepairState represents the state of automated repair for a given repair type.
Provides currently running auto-repair tasks.
This class serves as a utility class for AutoRepair.
Represents a size estimate by both bytes and partition count for a given keyspace and table for a token range.
An iterator over
SearchResult.NodeScore backed by a SearchResult that resumes search
when the backing SearchResult is exhausted.A base cache serializer that is used to serialize/deserialize a cache to/from disk.
A generic signal consumer, supporting all of the typical patterns used in Cassandra.
A barebones asynchronous
Awaitable.A barebones
Awaitable that uses mutual exclusion.AzureSnitch will resolve datacenter and rack by calling
/metadata/instance/compute endpoint returning
the response in JSON format for API version 2021-12-13.BasePartitions<R extends BaseRowIterator<?>,I extends BasePartitionIterator<? extends BaseRowIterator<?>>>
A common interface for Row and Unfiltered, that permits sharing of the (majority) common
methods and functionality
Basic/General Token Filters
A
BATCH statement parsed from a CQL query.Legacy bigtable format
Column index builder used by
BigTableWriter.SSTableReaders are open()ed by Keyspace.onStart; after that they are created by SSTableWriter.renameAndOpen.
Encapsulates writing the index and filter for an SSTable.
A variant of BiMap which does not enforce uniqueness of values.
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.
Writes leaf postings and auxiliary posting lists for bbtree nodes.
Handles intersection of a point or point range with a block balanced tree previously written with
BlockBalancedTreeWriter.We recurse the balanced tree, using a provided instance of this to guide the recursion.
Base reader for a block balanced tree previously written with
BlockBalancedTreeWriter.This is a specialisation of the Lucene
BKDWriter that only writes a single dimension
balanced tree.'Classic' read repair.
Provides non-blocking, random access to a stream written with
BlockPackedWriter.A writer for large sequences of longs.
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'.
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.
AbstractBounds containing both its endpoints: [left, right].
Annotation to have JMX breaking APIs not trigger test failures, each example must explain why it is ok to expose a
JMX breaking API
An iterator over
RowIdWithScore that lazily consumes from a NeighborQueue of approximate scores.Bigtable format with trie indices.
Reader of SSTable files in BTI format (see
BtiFormat), written by BtiTableWriter.Writes SSTables in BTI format (see
BtiFormat), which can be read by BtiTableReader.Encapsulates writing the index and filter for an SSTable.
Represents the direction of iteration.
A pooled builder for constructing a tree in-order, and without needing any reconciliation.
Holder of the content of a partition, see
AbstractBTreePartition.the function we provide to the trie and btree utilities to perform any row and column replacements
Immutable implementation of a Row object.
The clustering column values for a row.
An implementation of the DataOutputStreamPlus interface using a ByteBuffer to stage writes
before flushing them to an underlying channel.
Buffer manager used for reading from a ChunkReader when cache is not in use.
A pool of ByteBuffers that can be recycled to reduce system direct memory fragmentation and improve buffer allocation
performance.
A trivial wrapper around BufferPool for integrating with Netty, but retaining ownership of pooling behaviour
that is integrated into Cassandra's other pooling.
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.
Accessor for ByteBuffer values.
Cloner class that can be use to clone partition elements using on-heap or off-heap buffers.
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();
}
}
Interface indicating a value can be represented/identified by a comparable
ByteSource.Simple utility methods to make working with bytes (blob) easier.
A stream of bytes, used for byte-order-comparable representations of data, and utilities to convert various values
to their byte-ordered translation.
Variable-length encoding.
Combination of multiple byte sources.
Construct the shortest common prefix of prevMax and currMin that separates those two byte streams.
Fixed length signed floating point number encoding.
Fixed length signed number encoding.
Variable-length encoding for signed integers.
Variable-length encoding for unsigned integers.
Contains inverse transformation utilities for
ByteSources.A partition stored in the partition cache.
Metrics for
ICache.An adapter from a Caffeine cache to the ICache interface.
Metrics for tracking information about CAS write requests.
Abstract the conditions and updates for a CAS operation.
CassandraAuthorizer is an IAuthorizer implementation that keeps
user permissions internally in C* using the system_auth.role_permissions
table.
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
CassandraStreamReader that reads from streamed compressed SSTable
CassandraStreamWriter for compressed SSTable.
The
CassandraDaemon is an abstraction for a Cassandra daemon
service, which defines not only a way to activate and deactivate it, but also
hooks into its lifecycle methods (see CassandraDaemon.setup(), CassandraDaemon.start(),
CassandraDaemon.stop() and CassandraDaemon.setup()).CassandraEntireSSTableStreamReader reads SSTable off the wire and writes it to disk.
CassandraEntireSSTableStreamWriter streams the entire SSTable to given channel.
used to receive the part(or whole) of a SSTable data file.
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.
LoginModule which authenticates a user towards the Cassandra database using
the internal authentication mechanism.
Makes integrating 3.0 metrics API with 2.0.
A value class encapsulating a metric's owning class and name.
used to transfer the part(or whole) of a SSTable data file
This class implements the
Principal interface
and represents a user.A class that extracts system properties for the cassandra node it runs within.
Responsible for the creation, maintenance and deletion of roles
for the purposes of authentication and authorization.
Implements the streaming interface for the native cassandra storage engine.
CassandraStreamReader reads from stream and writes to SSTable.
CassandraStreamWriter writes given section of the SSTable to given channel.
This class packages several UInt utility methods so we can easily change it's implementation when needed.
Implements versioning used in Cassandra and CQL.
Casting functions
Allows to build ClusteringPrefixes, either Clustering or ClusteringBound.
ByteBuf utility methods.
A cell is our atomic unit for a single value of a single column.
A path for a cell belonging to a complex column type (non-frozen collection or UDT).
Static methods to work on cells.
A cell's source data object.
A wrapped
Cell that includes a reference to the cell's source table via CellSourceIdentifierA proxy of a FileChannel that:
- implements reference counting
- exports only thread safe FileChannel operations
- wraps IO exceptions into runtime exceptions
Tested by RandomAccessReaderTest.
A
RandomAccessReader wrapper that calculates the CRC in place.Metrics for
ICache.RandomFileReader component that reads data from a file into a provided buffer and may have requirements over the
size and alignment of reads.
Contains a CIDR, and operations on it
Captures metrics of CIDR authorizer
Virtual tables capturing metrics related to CIDR filtering
Virtual table capturing counts i.e, non-latency metrics related to CIDR filtering
Virtual table capturing latency metrics related to CIDR filtering
mbean to expose CIDR filtering metrics virtual table to JMX/nodetool
Nodetool command to view stats related to CIDR filtering
CIDR groups mapping cache.
This class implements CIDR Interval tree and the ability to find longest matching CIDR for the given IP.
Reads the table
AuthKeyspace.CIDR_GROUPS and populates CIDR groups mapping data structures.This class provides utility functions to list/update/drop CIDR groups mappings.
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
Builder to add CIDR to CIDR groups mappings and construct a mapping table with them
Contains CIDR permissions of a role
Builder to generate CIDR Permissions
Provides functionality to list/update/drop CIDR permissions of a role
Backend to build Role to CIDR permissions cache
JMX functions related to CIDR permissions cache and table
A factory for loading encryption keys from
KeyProvider instances.Message to cleanup repair resources on replica nodes.
Performs garbage collection of index entries during a cleanup.
Adds ability to reset a histogram
Metrics to track the size of incoming and outgoing bytes at Cassandra server.
Metrics for tracking information about range requests.
State related to a client connection.
Metrics for tracking information about write requests.
Wrapper around time related functions that are either implemented by using the default JVM calls
or by using a custom implementation for testing purposes.
Allow cloning of partition elements
Deprecated.
See CASSANDRA-18438
Common class for objects that are identified by a clustering prefix, and can be thus sorted by a
ClusteringComparator.Serializer for Clustering object.
The start or end of a range of clusterings, either inclusive or exclusive.
The threshold between two different ranges, i.e.
This class defines a threshold between ranges of clusterings.
Index on a CLUSTERING_COLUMN column definition.
A comparator of clustering prefixes (or more generally of
Clusterable}.A filter that selects a subset of the rows of a given partition by using the "clustering index".
A filter selecting rows given their clustering value.
A filter over a single partition.
A clustering prefix is the unit of what a
ClusteringComparator can compare.Helper class that makes the deserialization of clustering prefixes faster.
The kind of clustering prefix this actually is.
Thrown when a suitable
TypeCodec cannot be found by CodecRegistry instances.A registry for
TypeCodecs.A set of utility methods to deal with type conversion and serialization.
Manages building an entire index from column family data.
Index on the element and value of cells participating in a collection.
Native CQL functions for collections (sets, list and maps).
Index on the collection element of the cell name of a collection.
Common superclass for indexes that capture collection keys, including
indexes on such keys themselves.
The abstract validator that is the base for maps, sets and lists (both frozen and non-frozen).
Index the value of a collection cell.
Some extra Collector implementations.
Utility class for creating and reading the column completion marker,
IndexComponent.COLUMN_COMPLETION_MARKER.A CQL3 condition on the value of a column or collection element.
A set of
ColumnConditions.A
Builder for ColumnConditions.Generic interface for the data of a given column (inside a row).
Reason for initiating a memtable flush.
The MBean interface for ColumnFamilyStore
Represents which (non-PK) columns (and optionally which sub-part of a column for complex columns) are selected
by a query.
A builder for a
ColumnFilter object.ColumnFilter sub-class for queries with selected columns.ColumnFilter sub-class for wildcard queries.Represents an identifer for a CQL column definition.
A
VirtualTable providing a system view of per-column storage-attached index metadata.Dynamic data mask that can be applied to a schema column.
A parsed but not prepared column mask.
The type of CQL3 column this definition represents.
An immutable and sorted list of (non-PK) columns for a given table.
Handles the selection of a subpart of a column.
Metrics for commit log
Contains a segment id and a position for CommitLogSegment identification.
A simple class for tracking information about the portion of a segment that has been allocated to a log write.
Read each sync section of a commit log, iteratively.
Groups ranges with identical endpoints/transient endpoints
Class that abstracts away the actual writing of files to make it possible to use CompactionTask for more
use cases.
Manage compaction options.
Merge multiple iterators over the content of sstable into a "compacted" iterator.
This will produce the compaction strategy's starting information.
This is an interface to allow writing to a different interface.
A singleton which manages a private executor of ongoing compactions.
Compaction related SSTable metadata.
Metrics for compaction.
Manages the compaction strategies.
Performs garbage collection of stale index entries during a regular compaction.
Utility methods linked to comparing comparable values.
The data for a complex column, that is it's cells and potential complex
deletion time.
SSTables are made up of multiple components in separate files.
WARNING: Be careful while changing the names or string representation of the enum
members.
SSTable components and their sizes to be tranfered via entire-sstable-streaming
InputStream which reads compressed chunks from the underlying input stream and deals with decompression
and position tracking.
Compressed commit log segment.
Class to hold a mark to the position of the file
Container that carries compression parameters and chunks to decompress data from stream.
Holds metadata about compressed file
TODO extract interface ICompressionMetadata which will just provide non-resource properties
Holds offset and length of the file chunk
A variant of BiMap that permits concurrent access, and expects uniqueness of values in both domain and range.
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.An asynchronous
Condition.A
Condition based on its object monitor.Conditions that can be applied to a mutation statement.
A class that contains configuration properties for the cassandra node it runs within.
Which timestamp should be used to represent a base for replica-side timeouts.
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
Select the kind of paxos state purging to use.
The variants of paxos implementation and semantics supported by Cassandra.
Base class for consistent Local and Coordinator sessions
The possible states of a
ConsistentSession.Static helper methods and classes for constants.
A constant value, i.e.
A strategy for making back-off decisions for Paxos operations that fail to make progress because of other paxos operations.
The controller provides compaction parameters to the unified compaction strategy
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).
Coordinator side logic and state of a consistent repair session.
Container for all consistent repair sessions a node is coordinating
An implementation of a partitioned counter context.
Helper class to work on contexts (works by iterating over them).
Processed CAS conditions and update on potentially multiple rows of the same partition.
Utility class to facilitate the creation of the CQL representation of
SchemaElements.Helper class to encapsulate common code that calls one of the generated methods in
CqlParser.Implementation of
AbstractMessageHandler for processing CQL messages which comprise a Message wrapped
in an Envelope.Utility to write SSTables.
A Builder for a CQLSSTableWriter object.
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.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.
Custom QueryHandler that sends custom request payloads back with the result.
This class blocks for a quorum of responses _in all datacenters_ (CL.EACH_QUORUM).
This class blocks for a quorum of responses _in the local datacenter only_ (CL.LOCAL_QUORUM).
Input stream around a single ByteBuffer.
Extension to DataInput that provides support for reading varints
Wrapper around an InputStream that provides no buffering but can decode varints
Object in charge of tracking if we have fetch enough data for a given query.
An implementation of the DataOutputStream interface using a FastByteArrayOutputStream and exposing
its buffer so copies can be avoided.
An implementation of the DataOutputStream interface using a FastByteArrayOutputStream and exposing
its buffer so copies can be avoided.
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.
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.
Groups both the range of partitions to query, and the clustering index filter to
apply for each partition (for a (partition) range query).
Specialized
DataRange used for the paging case.Represents a data rate type used for cassandra configuration.
Represents a data rate used for Cassandra configuration.
The primary type of resource in Cassandra.
Represents an amount of data storage.
Represents a data storage quantity used for Cassandra configuration.
Represents a data storage quantity used for Cassandra configuration.
Represents a data storage quantity used for Cassandra configuration.
Represents a data storage quantity used for Cassandra configuration.
Represents a data storage quantity used for Cassandra configuration.
a pared-down version of DataTracker and DT.View.
Data types supported by cassandra.
Instances of this class represent collection types, that is, lists, sets or maps.
A "custom" type is a type that cannot be expressed as a CQL type.
The CQL type name.
Instances of this class represent CQL native types, also known as CQL primitive types.
Deprecated.
This is the old version of TimestampType, but has been replaced as it wasn't comparing pre-epoch timestamps
correctly.
Interface to include on a Runnable or Callable submitted to the
SharedExecutorPool to provide more
detailed diagnostics.Wraps a
DebuggableTask to include the name of the thread running it.A decaying histogram reservoir where values collected during each minute will be twice as significant as the values
collected in the previous minute.
Represents a decorated key, handy for certain operations
where just working with strings gets slow.
The default compaction writer - creates one output file in L0
Default crypto provider tries to install AmazonCorrettoCryptoProvider.
A
MaskingFunction that returns a fixed replacement value for the data type of its single argument.MetricNameFactory that generates default MetricName of metrics.
Cassandra's default implementation class for the configuration key
ssl_context_factory.A
DELETE parsed from a CQL query statement.A combination of a top-level (partition) tombstone and range tombstones describing the deletions
within a partition.
Information on deletion of a storage engine object.
Simple tokenizer based on a specified delimiter (rather than whitespace).
The differents
DESCRIBE statements parsed from a CQL statement.DescribeStatement implementation used for describe queries for a single schema element.DescribeStatement implementation used for describe queries that only list elements names.Object descriptor for SASIIndex files.
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.
Flag affecting deserialization behavior (this only affect counters in practice).
Base class for internally emitted events used for diagnostics and testing.
Simple on-heap memory store that allows to buffer and retrieve a fixed number of events.
Manages storing and retrieving events based on enabled
DiagnosticEventStore implementation.Service for publishing and consuming
DiagnosticEvents.Provides JMX enabled attributes and operations implemented by
DiagnosticEventService.Enables storing and retrieving
DiagnosticEvents.Provides a means to take snapshots when triggered by anomalous events or when the breaking of invariants is
detected.
Just holds all differences between the hosts involved in a repair
Encapsulate handling of paths to the data files.
Data directories used to store keyspace data.
The type of files that can be listed by SSTableLister, we never return txn logs,
use LifecycleTransaction.getFiles() if you need txn logs.
How to handle a failure to read a txn log file.
Walks directory recursively, summing up total contents of files within.
Starts
DiskUsageMonitor to monitor local disk usage state and broadcast new state via Gossip.Schedule periodic task to monitor local disk usage and notify
DiskUsageBroadcaster if local state changed.Immutable snapshot of the current schema along with its version.
Top level class for exceptions thrown by the driver.
An unexpected error happened internally.
Nodetool command to drop a CIDR group and associated mapping from the table
AuthKeyspace.CIDR_GROUPSCqlsh statement to remove identity from identity_to_roles table.
Metrics for dropped messages by verb.
Represents a duration.
Represents a duration.
Represents a positive time duration.
Represents a duration used for Cassandra configuration.
Represents a duration used for Cassandra configuration.
Represents a duration used for Cassandra configuration.
Represents a duration used for Cassandra configuration.
Represents a duration used for Cassandra configuration.
Represents a duration used for Cassandra configuration.
Represents a duration used for Cassandra configuration.
Represents a duration.
A dynamic snitch that sorts endpoints by latency with an adapted phi failure detector
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.
A snitch that assumes an EC2 region is a DC and an EC2 availability_zone
is a rack.
An embedded, in-memory cassandra storage service.
A placeholder index for when there is no on-disk index.
A type that only accept empty data.
A guardrail that enables the use of a particular feature.
Stats used for the encoding of the rows and tombstones of a given source.
Each segment of an encrypted file may contain many encrypted chunks, and each chunk needs to be individually decrypted
to reconstruct the full segment.
Writes encrypted segments to disk.
A (largely) immutable wrapper for the application-wide file-level encryption settings.
This holds various options used for enabling SSL/TLS encryption.
Encryption and decryption functions specific to the commit log.
Map of hosts to their known current messaging versions.
A collection of Endpoints for a given ring position.
A ReplicaCollection where all Replica are required to cover a range that fully contains the range() defined in the builder().
A ReplicaCollection where all Replica are required to cover a range that fully contains the token() defined in the builder().
MBean exposing standard Snitch info
This abstraction represents both the HeartBeatState and the ApplicationState in an EndpointState
instance.
ErrorListener that collect and enhance the errors send by the CQL lexer and parser.Listener used to collect the syntax errors emitted by the Lexer and Parser.
Message to indicate an error to the client.
Exceptions code, as defined by the binary protocol.
AbstractBounds containing neither of its endpoints: (left, right).
Standardised handling of failures during execution - mostly this involves invoking a thread's
Thread.UncaughtExceptionHandler or
JVMStabilityInspector.uncaughtException(Thread, Throwable),
with special handling for CompactionInterruptedException.Configure an executor before creating it.
Entry point for configuring and creating new executors.
Entry point for configuring and creating new executors.
Entry point for configuring and creating new executors.
Cassandra's extension of
ExecutorService, using our own Future, supporting
ExecutorPlus.inExecutor(), and execution with associated resources ExecutorPlus.execute(WithResources, Runnable)
(which is primarily used for encapsulating ExecutorLocals without leaking implementing classes).An implementation similar to Guava's Suppliers.memoizeWithExpiration(Supplier)
but allowing for memoization to be skipped.
Sample-based exponential moving average.
An
Expression is an internal representation of an index query operation.A representation of a column value in its raw and encoded form.
Archives binary log files immediately when they are rolled using a configure archive command.
This FailureDetector is an implementation of the paper titled
"The Phi Accrual Failure Detector" by Hayashibara.
Utility code to do optimized byte-array comparison.
Identifies a field in a UDT.
A thin wrapper around java.nio.file.Path to provide more ergonomic functionality.
Synchronous, file-based audit logger; just uses the standard logging mechansim.
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).Helper class for hot reloading SSL Contexts
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 provides access to a file for reading, including the ones written by various SequentialWriter
instances, and it is typically used by SSTableReader.Configures how the file will be read (compressed, mmapped, use cache etc.)
This is the same as DataInputBuffer, i.e.
Ownership markers on disk are compatible with the java property file format.
An
InMemoryKeyRangeIterator that filters the returned PrimaryKeys based on the provided keyRangeA wrapper that iterates over a delegate
PostingList, filtering out postings at
positions that are not present in a provided filter.A linked list of
FilterPipeline.Task objects.Creates a Pipeline object for applying n pieces of logic
from the provided methods to the builder in a guaranteed order
Executes all linked
FilterPipeline.Tasks serially on the provided input and returns a resultExecutes all linked Pipeline Tasks serially and returns
output (if exists) from the executed logic
A single task or set of work to process an input
and return a single output.
Tree-like structure to filter base table data using indexed expressions and non-user-defined filters.
An implementation that splits token ranges into a fixed number of subranges.
A container used to store a node -> message_id map for inter-DC write forwarding.
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.A Netty inbound handler that decodes incoming frames and passes them forward to
InboundMessageHandler for processing.A corrupted frame was encountered; this represents the knowledge we have about this frame,
and whether or not the stream is recoverable.
The payload bytes of a complete frame, i.e.
Framing format that protects integrity of data in movement with CRCs (of both header and payload).
Framing format that compresses payloads with LZ4, and protects integrity of data in movement with CRCs
(of both header and 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.Please see
FrameDecoderCrc for description of the framing produced by this encoder.Please see
FrameDecoderLZ4 for description of the framing produced by this encoder.Find the most frequent sample.
A fake type that is only used for parsing type strings that include frozen types.
Interface for handling file system errors.
Thrown when all the disks used by a given keyspace have been marked as unwriteable.
A logger that logs entire query contents after the query finishes (or times out).
Default
Arguments implementation.Class for dynamically building different overloads of a CQL
Function according to specific function calls.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.IResource implementation representing functions.
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.Netty's PromiseCombiner is not threadsafe, and we combine futures from multiple event executors.
A delegating future, that we can extend to provide subtly modified behaviour.
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
A FutureTask that utilises Cassandra's
AsyncFuture, making it compatible with ExecutorPlus.A FutureTask that utilises Cassandra's
AsyncFuture, making it compatible with ExecutorPlus.Prints all the configurations for AutoRepair through nodetool.
Nodetool command to get CIDR groups(s) of given IP
Collection of (typed) CQL values that can be retrieved by index (starting at zero).
Collection of (typed) CQL values that can be retrieved by name.
Collection of (typed) CQL values that can be retrieved either by index (starting at zero) or by
name.
A snitch that assumes an GCE region is a DC and an GCE availability_zone
is a rack.
Contains information about a specified list of Endpoints and the largest version
of the state they have generated as known by the local endpoint.
This ack gets sent out as a result of the receipt of a GossipDigestSynMessage by an
endpoint.
This ack gets sent out as a result of the receipt of a GossipDigestAckMessage.
This is the first message that gets sent out as a start of the Gossip protocol in a
round.
This module is responsible for Gossiping information for the local endpoint.
DiagnosticEvent implementation for
Gossiper activities.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.
GroupMaker state.A
GroupMaker can be used to determine if some sorted rows belongs to the same group or not.General class defining a given guardrail that guards against some particular usage/condition.
Entry point for Guardrails, storing the defined guardrails and providing a few global methods over them.
Configuration settings for guardrails.
Provider of
GuardrailsConfigs for a ClientState.Default implementation of
GuardrailsConfigProvider that always returns the GuardrailsConfig
parsed from cassandra.yaml, independently of the ClientState.JMX entrypoint for updating the default guardrails configuration parsed from
cassandra.yaml.Configuration settings for guardrails populated from the Yaml file.
A
MaskingFunction that replaces the specified column value by its hash according to the specified
algorithm.Cloner class that can be use to clone partition elements on heap.
Utility to log heap histogram.
HeartBeat State associated with any given endpoint.
Encapsulates the hinted mutation, its creation time, and the gc grace seconds param for each table involved.
Metrics for
HintsService.The message we use to dispatch and forward hints.
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.
Metrics for
HintsService.Verb handler used both for hint dispatch and streaming.
Simple class for constructing an EsimtatedHistogram from a set of predetermined values
This interface exists to avoid boxing primitive ints to Integers (otherwise
BiConsumer<Integer, Integer> would have been sufficient).Tracks the differences for a single host
Performs the actual SASL negotiation for a single authentication attempt.
Primary Cassandra authorization interface.
Interface that defines how to generate
KeyspaceRepairAssignments.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.
Backend for CIDR authorization feature
Supported modes by CIDR authorizer
Ways that a particular instance of ICompressor should be used internally in Cassandra.
Interface on which interested parties can be notified of high level endpoint
state changes.
This interface helps determine location of node in the datacenter relative to another node.
This is called by an instance of the IEndpointStateChangePublisher to notify
interested parties about changes in the the state associated with any endpoint.
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.
An interface that provides an application with the ability
to query liveness information of a node in the cluster.
Enum that represents connection type of internode connection.
Metadata component serializer
Interface for SSTable metadata serializer
Implementation of
AbstractMessageHandler for processing internode messages from peers.An aggregation of
InboundMessageHandlers for all connections from a peer.A message sink that all inbound messages go through.
AbstractBounds containing only its left endpoint: [left, right).
Tracks incoming streams for a single host
The counterpart of
OutgoingStream on the receiving side.This class is a variant of
IncrementalTrieWriterPageAware which is able to build even very deep
tries.Common interface for incremental trie writers.
IncrementalTrieWriterBase<VALUE,DEST,NODE extends org.apache.cassandra.io.tries.IncrementalTrieWriterBase.BaseNode<VALUE,NODE>>
Helper base class for incremental trie builders.
Incremental builders of on-disk tries which packs trie stages into disk cache pages.
Incremental builder of on-disk tries.
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.
Default implementation of
IndexBuildingSupport which uses a ReducingKeyIterator to obtain a
collated view of the data in the SSTables.Class providing grouped operations for indexes that communicate with each other.
Group key is used to uniquely identify a
Index.Group within a tableProvider of
SecondaryIndexBuilder instances.Listener for processing events emitted during a single partition update.
Supported loads.
Specifies a set of compatible indexes to be used with a query according to its
RowFilter, ignoring data
ranges, limits, etc.Performs the actual index lookup during execution of a ReadCommand.
This is a definitive list of all the on-disk components for all versions
The
IndexDescriptor is an analog of the SSTable Descriptor and provides version
specific information about the on-disk state of a StorageAttachedIndex.Entries in indexes on non-compact tables (tables with composite comparators)
can be encapsulated as IndexedEntry instances.
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.
This is a simple wrapper around the index identity.
IndexInfo is embedded in the indexed version of RowIndexEntry.This is a wrapper over a Cassandra
RandomAccessReader that provides an IndexInput
interface for Lucene classes that need IndexInput.An immutable representation of secondary index metadata.
Thrown if a secondary index is not currently available.
This is a wrapper over a Cassandra
SequentialWriter that provides a Lucene IndexOutput
interface for the Lucene index writers.The collection of all Index instances for a base table.
Abstract reader for individual segments of an on-disk index.
Handles the status of an index across the ring, updating the status per index and endpoint
in a per-endpoint map.
Represents a boundary that is guaranteed fully readable in the summary, index file and data file.
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.
This class is a representation of an
AbstractType as an indexable type.Base interface for the handling of index updates.
Used to differentiate between type of index transaction when obtaining
a handler from Index implementations.
Maintain an atomic view for read requests, so that requests can read all data during concurrent compactions.
Per-index config for storage-attached index writers.
A class to replace the usage of InetAddress to identify hosts in the cluster.
Serializer for handling FWD_FRM message parameters.
As of version 4.0 the endpoint description includes a port number as an unsigned short
Added to the Netty pipeline whenever a new Channel is initialized.
Fired when we load SSTables during the Cassandra initialization phase.
In-memory trie built for fast modification and reads executing concurrently with writes from a single mutator thread.
In-memory trie built for fast modification and reads executing concurrently with writes from a single mutator thread.
Because we use buffers and 32-bit pointers, the trie cannot grow over 2GB of size.
Somewhat similar to
Trie.MergeResolver, this encapsulates logic to be applied whenever new content is being
upserted into a InMemoryTrie.Created by IntelliJ IDEA.
Marker interface for file positions as provided by the various ChecksummedDataReader implementations.
A
NavigableSet that enforces in-order insertion of elements.Wraps an ICache in requests + hits tracking.
Mutable integer interval class, thread-safe.
A mutable set of closed integer intervals, stored in normalized form (i.e.
Class that contains certificate utility methods.
Discard handler releases the received data silently.
Metrics for internode connections.
Metrics for internode connections.
A Task that only runs on NORMAL states
An immutable set of closed intervals, stored in normalized form (i.e.
Builder of interval sets, applying the necessary normalization while adding ranges.
IntervalTree<C extends Comparable<? super C>,D extends Comparable<? super D>,I extends Interval<C,D>>
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.
Nodetool command to invalidate CIDR permissions cache, for a give role or for all roles in the cache.
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.Versioned serializer where the serialization depends on partitioner.
The interface at the core of Cassandra authorization.
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.
Supported options for CREATE ROLE/ALTER ROLE (and
CREATE USER/ALTER USER, which are aliases provided
for backwards compatibility).
Tells jvm-dtest that a class should be isolated and loaded into the instance class loader.
The purpose of this interface is to provide pluggable mechanism for creating custom JSSE and Netty SSLContext
objects.
Indicates if the process holds the inbound/listening (Server) end of the socket or the outbound side (Client).
An ISSTableScanner is an abstraction allowing multiple SSTableScanners to be
chained together under the hood.
This is the interface is used by the streaming code read a SSTable stream off a channel.
Trigger interface, For every partition update received by the coordinator
ITrigger.augment(Partition)
is called.IVerbHandler provides the method that all verb handlers need to implement.
Base class for all Java UDFs.
Utility method to retrieve information about the JRE.
A
KeyProvider that retrieves keys from a java keystore.Holds dedicated executor for JMX event handling.
JMXNotificationProgressListener uses JMX Notification API to convert JMX Notification message to progress event
and notifies its
ProgressListeners.ProgressListener that translates ProgressEvent to JMX Notification message.
Crypto provider which does nothing.
Term-related classes for INSERT JSON support.
Represents a literal JSON string in an INSERT JSON statement.
Represents a marker for a JSON string in an INSERT JSON statement.
A prepared, full set of JSON values.
Responsible for deciding whether to kill the JVM if it gets in an "unstable" state (think OOM).
This class is usually used to avoid JVM exit when running junit tests.
The
KeyAnalyzer provides bit-level access to keys
for the PatriciaTrie.A simple wrapper of possibly global cache with local metrics.
Provides read access to an on-disk sequence of partition or clustering keys written by
KeyStoreWriter.Metadata produced by
KeyStoreWriter, needed by KeyLookup.Customizable key retrieval mechanism.
KeyRangeConcatIterator takes a list of sorted range iterators and concatenates them, leaving duplicates in
place, to produce a new stably sorted iterator.A simple intersection iterator that makes no real attempts at optimising the iteration apart from
initially sorting the ranges.
An abstract implementation of
AbstractGuavaIterator that supports the building and management of
concatanation, union and intersection iterators.Range Union Iterator is used to return sorted stream of elements from multiple RangeIterator instances.
Reads keys from an SSTable.
It represents a Keyspace.
An immutable representation of keyspace metadata (name, params, tables, types, and functions).
Metrics for
ColumnFamilyStore.An immutable class representing keyspace parameters (durability and replication).
A grouping of repair assignments that were generated for a particular keyspace for a given priority.
Keyspace level hook for repair.
Encapsulates an intent to repair the given keyspace's tables
Writes a sequence of partition keys or clustering keys for use with
KeyLookup.Provides a list of event types and the corresponding highest event IDs.
Metrics about latencies
Callback that
DynamicEndpointSnitch listens to in order
to update host scores.Abstract class to create UnfilteredRowIterator that lazily initializes itself.
a FilterInputStream that returns the remaining bytes to read from available()
regardless of whether the device is ready to provide them.
An interface for tracking new sstables added to a LifecycleTransaction, possibly through some proxy.
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.
A simple thread local object reuse facility with limited capacity and no attempt at rebalancing pooling between
threads.
Rebufferer wrapper that applies rate limiting.
Nodetool command to list available CIDR groups, in the table
AuthKeyspace.CIDR_GROUPSStatic helper methods and classes for lists.
Basically similar to a Value, but with some non-pure function (that need
to be evaluated at execution time) in it.
A marker for List values and IN relations
Executes
Expressions against the trie-based terms dictionary for an individual index segment.Synchronous reader of terms dictionary and postings lists to produce a
PostingList with matching row ids.Builds an on-disk inverted index structure: terms dictionary and postings lists.
Stores the information relating to the liveness of the primary key columns of a row.
An extension of
NonBlockingHashMap where all values are wrapped by Future.Thrown when unloading a value failed.
An
ExecutorPlus that is aware of, and propagates to execution, any ExecutorLocalsA
SequentialExecutorPlus that is aware of, and propagates to execution, any ExecutorLocalsA date with no time components, no time zone, in the ISO 8601 calendar.
Basically just a record of a local session.
helper for JMX management functions
Manages all consistent repair sessions a node is participating in.
LocalSyncTask performs streaming between local(coordinator) node and remote replica.
Encapsulates all logback-specific implementations in a central place.
Common abstraction of functionality which can be implemented for different logging backend implementations (slf4j bindings).
Dynamically loads and instantiates an appropriate
LoggingSupport implementation according to the used slf4j binding.Virtual table for holding Cassandra logs.
A set of log replicas.
Abstraction over a long-indexed array of longs.
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.
Static helper methods and classes for maps.
A collection of
MaskingFunctions for dynamic data masking, meant to obscure the real value of a column.A
NativeScalarFunction that totally or partially replaces the original value of a column value,
meant to obscure the real value of the column.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.MaxThreshold for maximum guardrails, the value is checked to see if it is greater than the warn and fail thresholds.Helper class to avoid catching and rethrowing checked exceptions on MBean and
allow turning of MBean registration for test purposes.
The result of the computation of an MD5 digest.
An off-heap region of memory that must be manually free'd when no longer needed.
This class provides a way to stream the writes into the
MemoryMemtable interface.
Factory interface for constructing memtables, and querying write durability features.
A collection of partitions for flushing plus some information required for writing an sstable.
Special commit log position marker used in the upper bound marker setting process
(see
ColumnFamilyStore.setCommitLogUpperBound(java.util.concurrent.atomic.AtomicReference<org.apache.cassandra.db.commitlog.CommitLogPosition>) and Memtable.accepts(org.apache.cassandra.utils.concurrent.OpOrder.Group, org.apache.cassandra.db.commitlog.CommitLogPosition))Interface for providing signals back and requesting information from the owner, i.e.
Mark the BB as unused, permitting it to be reclaimed
The cleaner is used by
MemtableCleanerThread in order to reclaim space from memtables, normally
by flushing the largest memtable.A thread that reclaims memory from a MemtablePool on demand.
Column index writer that flushes indexed data directly from the corresponding Memtable index, without buffering index
data in memory.
Analogue of
SegmentOrdering, but for memtables.Memtable types and options are specified with these parameters.
Represents an amount of memory used for a given purpose, that can be allocated to specific tasks through
child MemtableAllocator objects.
Iterator over a token range bounded segment of a Memtable index.
Merges sorted input iterators which individually contain unique items.
Accumulator that collects values of type A, and outputs a value of type B.
Merges multiple
PostingList which individually contain unique items into a single list.A MerkleTree implemented as a binary tree.
Hash value representing a row, to be used to pass hashes to the MerkleTree.
The public interface to a range in the tree.
Returns the leaf (range) of a given tree in increasing order.
Wrapper class for handling of multiple MerkleTrees at once.
Immutable main unit of internode communication - what used to be
MessageIn and MessageOut fused
in one class.A message from the CQL binary protocol.
Split into a separate object to allow partial message deserialization without wasting work and allocation
afterwards, if the entire message is necessary and available.
Each message contains a header with several fixed fields, an optional key-value params section, and then
the message payload itself.
Binary message flags to be passed as
flags field of Message.Metrics for messages
MessagingService implements all internode communication - with the exception of SSTable streaming (for now).
MBean exposing MessagingService metrics plus allowing to enable/disable back-pressure.
Keeps metadata on the connected cluster, including known nodes and schema definitions.
MetadataComponent is a component for SSTable metadata and serialized to Stats.db.
Metadata serializer for SSTables
version >= 'na'.Defines Metadata component type.
Migration coordinator is responsible for tracking schema versions on various nodes and, if needed, synchronize the
schema.
MinThreshold for minimum guardrails, the value is checked to see if it is lesser than the warn and fail thresholds.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).Provides non-blocking, random access to a stream written with
MonotonicBlockPackedWriter.A writer for large monotonically increasing sequences of positive longs.
Wrapper around time related functions that are either implemented by using the default JVM calls
or by using a custom implementation for testing purposes.
An interface for providing new partitions for a partitions iterator.
An interface for providing new row contents for a partition.
Builder that allow to build multiple Clustering/ClusteringBound at the same time.
A relation using the tuple notation, which typically affects multiple columns.
An IN restriction that uses a single marker for a set of IN values that are tuples.
An IN restriction that has a set of terms for in values.
Pager over a list of SinglePartitionReadQuery.
This class generates a BigIntegerToken using a Murmur3 hash.
This is a very fast, non-cryptographic hash suitable for general hash-based
lookup.
A mutable implementation of
DeletionInfo.Builds DeletionInfo object from (in order) range tombstone markers.
Collects finalized partition updates
Interface for building mutations geared towards human.
Interface for certificate validation and authorization for mTLS authenticators.
This authenticator can be used in optional mTLS mode, If the client doesn't make an mTLS connection
this fallbacks to password authentication.
If mx4j-tools is in the classpath call maybeLoad to load the HTTP interface of mx4j.
A simple, thread-safe memory usage tracker, named to reflect a particular scope.
This class is an implementation of the ThreadFactory interface.
Base class for the
AggregateFunction native classes.This NativeAllocator uses global slab allocation strategy
with slab size that scales exponentially from 8KiB to 1MiB to
serve allocation of up to 128KiB.
Use this API only for data which are stored in-memory
and not serialized directly (without converting to Java primitives) to disk and network
Base class for our native/hardcoded functions.
A container of native functions.
A
NativeLibraryWrapper implementation for Darwin/Mac.A
NativeLibraryWrapper implementation for Linux.An interface to implement for using OS specific native methods.
Base class for the
ScalarFunction native classes.Handles native transport server lifecycle and associated resources.
An iterator over
RowIdWithScore that lazily consumes a NeighborQueue.Annotate fields, particularly important volatile fields, where the system should adversarially schedule
thread events around memory accesses (read or write).
This Replication Strategy takes a property file that gives the intended
replication factor in each datacenter.
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.
JMX client operations for Cassandra.
An iterator over
RowIdWithScore sorted by score descending.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.
Analyzer that does *not* tokenize the input.
Analyzer that does *not* tokenize the input.
Default noOp tokenizer.
No-Op implementation of
IAuditLogger to be used as a default audit logger when audit logging is disabled.A Compressor which doesn't actually compress any data.
A fallback implementation with empty implementations which ensures other slf4j bindings (logging implementations)
than the default supported framework can be used.
Bypasses the read repair path for short read protection and testing
Empty message payload - primarily used for responses.
Logging that limits each log statement to firing based on time since the statement last fired.
Levels for programmatically specifying the severity of a log statement
A
MaskingFunction that always returns a null column.Base type for the numeric types.
Base class for numeric type
ArgumentDeserializer.Executes
Expressions against the balanced tree for an individual index segment.Specialized writer for values, that builds them into a
BlockBalancedTreeWriter with auxiliary
posting lists on eligible tree levels.A convenience class for wrapping access to MemoryMeter.
Off-heap bitset,
file compatible with OpeBitSet
Update handler which works only in memory.
An interface to the on-disk format of an index.
An UPDATE or DELETE operation.
A parsed raw DELETE operation.
A parsed raw UPDATE operation.
Thrown when an operation problem has occured (e.g.
Operation functions (Mathematics).
A set of
Operations.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.
Represents a group of identically ordered operations, i.e.
Allows the vector index searches to be optimised for latency or recall.
Message to indicate that the server is ready to receive requests.
A single element of an ORDER BY clause.
An expression used in Approximate Nearest Neighbor ordering.
Represents ANTLR's abstract syntax tree of a single element in the
ORDER BY clause.Represents a single column in
ORDER BY columnRepresents a connection type to a peer, and handles the state transistions on the connection and the netty
Channel.A
ChannelHandler to execute the send-side of the internode handshake protocol.The result of the handshake.
OutboundConnectionInitiator.Result.Success<SuccessType extends OutboundConnectionInitiator.Result.Success>
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).
A collection of settings to be passed around for outbound connections.
A message sink that all outbound messages go through.
Some subset of data to be streamed.
A class for iterating sequentially through an ordered collection and efficiently
finding the overlapping set of matching intervals.
Adapter class for
PackedLongValues to expose it as PostingList.Marks the last row returned by paging, the one from which paging should continue.
Type names and serializers for various parameters that can be put in
Message params map.Simple utility class used to help parsing CQL values (mainly UDT and collection ones).
A
MaskingFunction applied to a StringType value that,
depending on PartialMaskingFunction.Kind:
Replaces each character between the supplied positions by the supplied padding character.A partial application of a function.
In-memory representation of a Partition.
PartitionDenylist uses the system_distributed.partition_denylist table to maintain a list of denylisted partition keys
for each keyspace/table.
for sorting columns representing row keys in the row ordering as determined by a partitioner.
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.
Iterator of index positions covered between two keys.
Provides methods to read the partition index trie.
An iterator over a number of (filtered) partition.
Index on a PARTITION_KEY column definition.
Pages a PartitionRangeReadQuery.
A read command that selects a (part of a) range of partitions.
A
ReadQuery for a range of partitions.Stores updates made on a partition.
Builder for PartitionUpdates
This class is not thread safe, but the PartitionUpdate it produces is (since it is immutable).
A counter mark is basically a pointer to a counter update inside this partition update.
Interface for building partition updates geared towards human.
Interface to build range tombstone.
PasswordAuthenticator is an IAuthenticator implementation
that keeps credentials (rolenames and bcrypt-hashed passwords)
internally in C* - in system_auth.roles CQL3 table.
Obfuscates passwords in a given string
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.
PATRICIA
TrieThis class serves as an entry-point to Cassandra's implementation of Paxos Consensus.
Tracks the highest paxos ballot we've seen, and the lowest ballot we can accept.
Perform one paxos "prepare" attempt, with various optimisations.
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.
PaxosPropose<OnDone extends 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.
The proposal request handler, i.e.
Facility to finish any in-progress paxos transaction, and ensure that a quorum of nodes agree on the most recent operation.
The proposal request handler, i.e.
Tracks the state of paxos repair cleanup work
Determines the highest ballot we should attempt to repair
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.
Tracks uncommitted and ballot high/low bounds
Coordinates repairs on a given key to prevent multiple repairs being scheduled for a single key
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.
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.
A peekable wrapper around a
PostingList that allows the next value to be
looked at without advancing the state of the PostingListSslContextFactory for the PEM standard encoded PKCS#8 private keys and X509 certificates/public-keys.
This is a helper class to read private keys and X509 certifificates encoded based on PEM (RFC 1421)
format.
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.
A
Threshold guardrail whose values represent a percentageMaintains a mapping of
IndexComponents to associated FileHandles for
read operations on the components.Creates the on-disk components for a given column index.
An enum encapsulating the set of possible permissions that an authenticated user can have on a resource.
Sets of instances of this class are returned by IAuthorizer.listPermissions() method for LIST PERMISSIONS query.
Writes all SSTable-attached index files.
Indicates to the recipient which
ConnectionType should be used for the response.Takes care of intializing a Netty Channel and Pipeline for client protocol connections.
Interface for advancing on and consuming a posting list.
A key iterator based on a
PostingList derived from a single index segment.Reads, decompresses and decodes postings lists written by
PostingsWriter.Encodes, compresses and writes postings lists to disk.
A guardrail based on two predicates.
A function used to build the warning or error message of a triggered
Predicates guardrail.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.
Pre-V5 exception handler which closes the connection if an
ProtocolException
is thrownWraps an
Dispatcher so that it can be used as an
channel inbound handler in pre-V5 pipelines.Simple adaptor to allow
Message.Decoder.decodeMessage(Channel, Envelope)
to be used as a handler in pre-V5 pipelinesSimple adaptor to plug CQL message encoding into pre-V5 pipelines
Representation of the primary key for a row consisting of the
DecoratedKey and
Clustering associated with a Row.See the javadoc for
PrimaryKey.kind() for how this enum is used.A bidirectional map of
PrimaryKey to row ID.A factory for creating
PrimaryKeyMap instances.A sorted set of
PrimaryKeys.A PrimaryKey with one piece of metadata.
Encapsulates a devised plan to repair tables, grouped by their keyspace and a given priority.
An iterator over a priority queue.
Progress event
Interface for
ProgressEvent publisher.Provides basic, thread safe ProgressEvent notification support
Progress event type.
ProgressInfo contains stream transfer progress.
Direction of the stream.
Listener interface to handle
ProgressEventA Promise that integrates
Promise with our Future API
to improve clarity and coherence in the codebase.Utility class for working with
Property types.
Used to determine if two IP's are in the same datacenter or on the same rack.
ProposeCallback has two modes of operation, controlled by the failFast parameter.
Exceptions thrown when a client didn't respect the protocol.
The native (CQL binary) protocol version.
This class tracks the last 100 connections per protocol version
Class for the names of the keyspace-prefixed elements (e.g.
Abstract class for statements that work on sub-keyspace level (tables, views, indexes, functions, etc.)
Tracks state relevant to the execution of a single query, including metrics and timeout monitoring.
Listener that gets notified during storage-attached index query execution.
Collector for balanced tree file related metrics.
Collector for posting file related metrics.
A CQL query
Options for a query.
Perform a query, paging it by page of a given size.
Primarily used as a recorder for server-generated timestamps (timestamp, in microseconds, and nowInSeconds - in, well, seconds).
Build a query specific view of the on-disk indexes for a query.
Native Queue Backpressure mechanism.
A simple endpoint snitch implementation that assumes datacenter and rack information is encoded
in the 2nd and 3rd octets of the ip address, respectively.
This class generates a BigIntegerToken using MD5 hash.
A representation of the range that a node is responsible for on the DHT ring.
Helper class to check if a token is contained within a given collection of ranges
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.BounceIntersectionIterator<K extends 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.LookupIntersectionIterator<K extends 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.
A ReplicaCollection for Ranges occurring at an endpoint.
Assists in streaming ranges to this node.
Source filter which only includes endpoints contained within a provided set.
Source filter which excludes nodes from local DC.
Source filter which excludes the current node from source calculations
Source filter which excludes any endpoints that are not alive according to a
failure detector.
Source filter which excludes any endpoints that are not in a specific data center.
This is required since IntervalTree doesn't support custom Comparator
implementations and relied on items to be comparable which "raw" terms are not.
This is required since IntervalTree doesn't support custom Comparator
implementations and relied on items to be comparable which "raw" terms are not.
A range tombstone is a tombstone that covers a slice/range of rows.
A range tombstone marker that represents a boundary between 2 range tombstones (i.e.
A range tombstone marker that indicates the bound of a range tombstone (start or end).
Data structure holding the range tombstones of a ColumnFamily.
A marker for a range tombstone bound.
Utility class to help merging range tombstone markers coming from multiple inputs (UnfilteredRowIterators).
Range Union Iterator is used to return sorted stream of elements from multiple RangeIterator instances.
Special Read Failure which is caused by user query; implies a user request is not allowed and not that Cassandra had an issue.
General interface for storage-engine read commands (common to both range and
single partition commands).
Base class for the RandomAccessReader components that implement reading.
Only performs the collection of data responses and reconciliation of them, doesn't send repair mutations
to replicas.
Generic abstraction for read queries.
Metrics related to Read Repair.
Message to indicate that the server is ready to receive requests.
Rebufferer for reading data by a RandomAccessReader.
Interface for the classes that can be used to instantiate rebufferers over a given file.
Rough equivalent of BufferedInputStream and DataInputStream wrapping a ByteBuffer that can be refilled
via rebuffer.
Supplier that caches the last computed value until it is reset, forcing every caller of
RecomputingSupplier.get(long, TimeUnit) to wait until this value is computed if
it was not computed yet.Sidekick helper for snitches that want to reconnect from one IP addr for a node to another.
Annotation supposed to be placed on any field in Config (and its subproperties in embedded configuration classes)
which will be redacted e.g.
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.
Caller must acquire and release references to the sstables used here.
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.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.
A collection of managed Ref references to RefCounted objects, and the objects they are referencing.
Columns (or a subset of the columns) that a partition contains.
Index on a REGULAR column definition on a composite type.
Represents a request to reject the current operation
Nodetool command to reload CIDR groups cache
Supports listing and failing incremental repair sessions
Defines a repair assignment to be issued by the autorepair framework.
Convenience
Iterator implementation to assist implementations of
IAutoRepairTokenRangeSplitter.getRepairAssignments(boolean, List) by passing KeyspaceRepairPlan
to a custom RepairAssignmentIterator.next(int, KeyspaceRepairPlan) method in priority order.Tracks the repaired state of token ranges per table, and is effectively an
in memory representation of the on-disk local incremental repair state.
Exception thrown during repair
RepairJob runs repair on given ColumnFamily.
RepairJobDesc is used from various repair processes to distinguish one RepairJob to another.
Base class of all repair related request/response messages.
Handles all repair related message.
Repair options.
Specify the degree of parallelism when calculating the merkle trees in a repair job.
RepairJob's result
Coordinates the (active) repair of a list of non overlapping token ranges.
Repair session result
The default implementation of
IAutoRepairTokenRangeSplitter that attempts to:
Create smaller, consistent repair times
Minimize the impact on hosts
Reduce overstreaming
Reduce number of repairs
Conveinence builder for establishing defaults by repair type.
Implementation of RepairAssignment that also assigns an estimation of bytes involved
in the repair.
A
MaskingFunction that replaces the specified column value by a certain replacement value.Holder for replacements to support backward compatibility between old and new names and types
of configuration parameters (CASSANDRA-15234)
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.
Concatenating annotation type for the repeatable annotation
ReplacesA Replica represents an owning node for a copy of a portion of the token ring.
A collection like class for Replica objects.
A mutable (append-only) extension of a ReplicaCollection.
Passed to add() and addAll() as ignoreConflicts parameter.
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).The relevant replicas for an operation over a given range or token.
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.
implementors of
RequestCallback need to make sure that any public methods
are threadsafe with respect to RequestCallback.onResponse(org.apache.cassandra.net.Message<T>) being called from the message
service.An expiring map of request callbacks.
Utility methods use to perform request validation.
A wrapper around
ByteBuffersIndexOutput that adds several methods that interact
with the underlying delegate.A cheaper, thread-unsafe permit container to be used for unshared limits.
A thread-safe permit container.
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.
Represents permits to utilise a resource and ways to allocate and release them.
A meter metric which measures mean throughput as well as fifteen-minute and two-hour
exponentially-weighted moving average throughputs.
Implementation of this class must be immutable.
Sets of restrictions
The metadata for the query parameters in a prepared statement.
The metadata for the results of executing a query or prepared statement.
Thread-unsafe reverse value iterator for on-disk tries.
Interface representing a position on the ring.
IResource implementation representing database roles.
Storage engine representation of a row.
Interface for building rows.
A row deletion/tombstone.
Utility class to help merging rows from multiple inputs (UnfilteredRowIterators).
Row builder interface geared towards human.
An iterator that merges a source of rows with the range tombstone and partition level deletion of a give partition.
A sentinel object for row caches.
Interface that allows to act on the result of merging multiple rows.
A filter on which rows a given query should include or exclude.
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.
An expression of the form 'column' 'op' 'value'.
A user defined filtering expression.
An iterator over scored primary keys ordered by the score descending
Not skippable.
Represents a row id with its computed score.
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.
Base class to access
IndexInfo objects.Reader class for row index files created by
RowIndexWriter.An iterator over rows belonging to a partition.
Static methods to work with row iterators.
In memory representation of
PrimaryKey to row ID mappings which only contains
Row regardless of whether it's live or deleted.Static utilities to work on Row objects.
A Row wrapper that has a
CellSourceIdentifier that gets added to cell as part of the
RowWithSource.getCell(ColumnMetadata) and RowWithSource.getCell(ColumnMetadata, CellPath) calls.A transformation that appends an RT bound marker to row iterators in case they don't have one.
A validating transformation that sanity-checks the sequence of RT bounds and boundaries in every partition.
Represents the ranked items collected during a sample period
Determines a single output value based on any number of input values.
A reservoir that scales the values before updating.
Scale the input value.
A custom
RangeCommandIterator that queries all replicas required by consistency level at once with data range
specify in PartitionRangeReadCommand.Centralized location for shared executors
Like ExecutorPlus, ScheduledThreadPoolExecutorPlus always
logs exceptions from the tasks it is given, even if Future.get is never called elsewhere.
Task scheduler that limits the number of concurrent tasks across multiple executors.
Manages shared schema, keyspace instances and table metadata refs.
Registers schema change listeners and sends the notifications.
When adding new String keyspace names here, double check if it needs to be added to PartitionDenylist.canDenylistKeyspace
Helper methods to represent TableMetadata and related objects in CQL format
A schema element (keyspace, udt, udf, uda, table, index, view).
system_schema.* tables and methods for manipulating them.
Sends it's current schema state in form of mutations in response to the remote node's request.
Called when node receives updated schema state from the schema migration coordinator node.
The result of applying (on this node) a given schema transformation.
Factory and utility methods to create simple schema transformation.
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.
Provides the instance of SchemaUpdateHandler factory pointed by
CassandraRelevantProperties.SCHEMA_UPDATE_HANDLER_FACTORY_CLASS system property.Iterator over the partitions of an sstable used for scrubbing.
Manages building an entire index from column family data.
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.
Used by
ThreadAwareSecurityManager to determine whether access-control checks needs to be performed.IndexInput adapter that exposes it as a RandomAccessInput.Each segment represents an on-disk index structure (balanced tree/terms/postings) flushed by memory limit or token boundaries.
Creates an on-heap index data structure to be flushed to an SSTable index.
Multiple
SegmentMetadata are stored in IndexComponent.META file, each corresponds to an on-disk
index segment.A
SegmentOrdering orders an index and produces a stream of PrimaryKeyWithScores.A specialized data structure that stores segment row id to ordinal pairs efficiently.
A
VirtualTable providing a system view of SSTable index segment metadata.On-heap buffer for values that provides a sorted view of itself as an
Iterator.Selectable for Selectable between parentheses or tuples.In the selection clause, the parser cannot differentiate between Maps and UDTs as a column identifier and field
identifier have the same syntax.
Selectable for literal Lists.Represents the selection of an element of a collection (eg.
Represents the selection of the field of a UDT (eg.
Selectable for literal Maps or UDTs.Selectable for literal Sets.Represents the selection of a slice of a collection (eg.
Selectable for type hints (e.g.Separately maintains the ColumnSpecifications and their mappings to underlying
columns as we may receive null mappings.
Represents a mapping between the actual columns used to satisfy a Selection
and the column definitions included in the resultset metadata for the query.
A
Selector is used to convert the data returned by the storage engine into the data requested by the
user.A factory for
Selector instances.A row of data that need to be processed by a
SelectorThe
Selector kinds.Encapsulates a completely parsed SELECT query, including the target
column family, expression, result count, and ordering clause.
Generation identifier based on sequence of integers.
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.Adds buffering, mark, and fsyncing to OutputStream.
Class to hold a mark to the position of the file
SequentialWriter option
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.
An abstraction of a node given to the trie serializer to write.
Serializes cache values off-heap.
Exceptions thrown when a client didn't respect the protocol.
Stream session info.
Allows to set AutoRepair configuration through nodetool.
Static helper methods and classes for sets.
Collection of (typed) CQL values that can be set by index (starting at zero).
Collection of (typed) CQL values that can set by name.
Collection of (typed) CQL values that can be set either by index (starting at zero) or by name.
Holds boundaries (tokens) used to map a particular token (so partition key) to a shard id.
A
CompactionAwareWriter that splits the output sstable at the partition boundaries of the compaction
shards used by UnifiedCompactionStrategy.A
SSTableMultiWriter that splits the output sstable at the partition boundaries of the compaction
shards used by UnifiedCompactionStrategy.A proof-of-concept sharded memtable implementation.
A wrapper for possibly sharing portions of a single,
BufferPools.forNetworking() managed, ByteBuffer;
optimised for the case where no sharing is necessary.Tells jvm-dtest that a class should be shared across all
ClassLoaders.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.
A simple abstract implementation of SharedCloseable
Access methods to shared resources and services.
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.
A pool of worker threads that are shared between all Executors created with it.
We have a potential short read if the result from a given node contains the requested number of rows
(i.e.
A very simple Bytebuffer pool with a fixed allocation size and a cached max allocation count.
A DataSet implementation that is filled on demand and has an easy to use API for adding rows.
The Factory for
SimpleSelector.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.
This class returns the nodes responsible for a given
key but does not respect rack awareness.
Enable certain features for a specific method or class.
Relations encapsulate the relationship between an entity of some kind, and
a value (term).
Common interface to single partition queries (by slice and by name).
A read command that selects a (part of a) single partition.
Groups multiple single partition read commands.
A
ReadQuery for a single partition.Groups multiple single partition read queries.
A single restriction/clause on one or multiple column.
Special compaction task that does not do any compaction, instead it
just mutates the level metadata on the sstable and notifies the compaction
strategy.
An
Index.Group containing a single Index, to which it just delegates the calls.Utility class for sizing, writing and reading ints with length stored separately.
A very simplistic/crude partition count/size estimator.
Adopted copy of
SJK from https://github.com/aragozin/jvm-tools.A
PrimaryKeyMap for skinny tables (those with no clustering columns).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.
+ * 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.
A slice represents the selection of a range of rows.
Represents a sliced view of a trie, i.e.
Represents the selection of multiple range of rows within a partition.
Builder to create
Slices objects.In simple object that allows to test the inclusion of rows in those slices assuming those rows
are passed (to
Slices.InOrderTester.includes(org.apache.cassandra.db.Clustering<?>)) in clustering order (or reverse clustering ordered, depending
on the argument passed to Slices.inOrderTester(boolean)).Loads snapshot metadata from data directories
SnapshotTask is a task that sends snapshot request.
A factory for building Netty
Channels.This is a special exception which states "I know something failed but I don't have access to the failure".
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.
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.Builder<P extends SortedTablePartitionWriter,I extends SortedTableWriter.AbstractIndexWriter,W extends SortedTableWriter<P,I>,B extends SortedTableWriter.Builder<P,I,W,B>>
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.
Partition splitter.
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
A Factory for providing and setting up client
SSLSockets.This class represents an abstract sstable on disk whose keys and corresponding partitions are stored in
a
SSTableFormat.Components.DATA file in order as imposed by DecoratedKey.comparator.A builder of this sstable representation.
Notification sent after SSTables are added to their
ColumnFamilyStore.An
SSTableContext is created for an individual sstable and is shared across column indexes to track per-sstable
index files.Manages per-sstable
SSTableContexts for StorageAttachedIndexGroupFired right before removing an SSTable.
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.
Export SSTables to JSON format.
Observer for events in the lifecycle of writing out an sstable.
Provides the accessors to data on disk.
Represents a unique identifier in the sstable descriptor filename.
Builder that can create instances of certain implementation of
SSTableId.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
A
VirtualTable providing a system view of SSTable index metadata.Column index writer that accumulates (on-heap) indexed data from a compacted SSTable as it's being flushed to disk.
A Cell Iterator over SSTable
Reset level to 0 on a given set of sstables
Cassandra SSTable bulk loader.
Shows the contents of sstable metadata
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):
[][][]
[ ][][][]
[ ]
[ ]
...
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.
A builder of this sstable reader.
One instance per SSTableReader we create.
TODO: Move someplace reusable
SSTableReaderWithFilter.Builder<R extends SSTableReaderWithFilter,B extends SSTableReaderWithFilter.Builder<R,B>>
Listener for receiving notifications associated with reading SSTables.
The reasons for selecting an SSTable
The reasons for skipping an SSTable
Provides a way to set the repaired state of SSTables without any downtime through nodetool.
A Cell Iterator in reversed clustering order over SSTable
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<S,E,I>.BaseKeyScanningIterator>
Tracks all sstables in use on the local node.
Utility class to handle deserializing atom from sstables.
Notification triggered by a
SSTablesGlobalTracker when the set of sstables versions in use on this node
changes.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.
A root class for a writer implementation.
A builder of this sstable writer.
Parameters for calculating the expected size of an SSTable.
Internal interface for supporting versioned grammars.
Various options for controlling tokenization and enabling
or disabling features
A test to determine if the system is in a valid state to start up.
Verifies that the system and environment is in a fit state to be started.
An exception thrown during system startup, indicating the environment or system
is not in a valid state to startup.
The initial message of the protocol.
The restrictions corresponding to the relations specified on the where-clause of CQL query.
Intended usage of this class is to be used in place of
DynamicTokenTreeBuilder
when multiple index segments produced by PerSSTableIndexWriter are stitched together
by PerSSTableIndexWriter.complete().Interface for the Stats property bag
SSTable metadata that always stay on heap.
Interface for the Stats printer, that'd output statistics
given the
StatsHolderComparator to sort StatsTables by a named statistic.
Returns a SnowballStemmer instance appropriate for
a given language
Filters for performing Stemming on tokens
Provides a list of Stop Words for a given language
Filter implementations for input matching Stop Words
Multiple storage-attached indexes can start building concurrently.
Orchestrates building of storage-attached indices, and manages lifecycle of resources shared between them.
Writes all on-disk index structures attached to a given SSTable.
The mode of compatibility with older Cassandra versions.
Metrics related to Storage.
This abstraction contains the token/identifier of this node
on the identifier space.
Gets the concurrency settings for processing stages
A serialiazer for stream compressed files (see package-level documentation).
StreamCoordinator is a helper class that abstracts away maintaining multiple
StreamSession and ProgressInfo instances per peer.The task that performs the actual deserialization.
Keeps track of where a node needs to stream a given range from.
Metrics for streaming.
Responsible for sending
StreamMessages to a given peer.StreamingRepairTask performs data streaming between two remote replicas, neither of which is repair coordinator.
Histogram that can be constructed from streaming of data.
StreamInitMessage is first sent from the node where
StreamSession is started,
to initiate corresponding StreamSession on the other side.StreamManager manages currently running
StreamResultFutures and provides status of all operation invoked.StreamMessage is an abstract base class that every messages in streaming protocol inherit.
StreamMessage serializer
StreamMessage types
StreamMessageHeader is appended before sending actual data to describe what it's sending.
StreamPlan is a helper class that builds StreamOperation of given configuration.StreamReceiver acts as a staging area for incoming data.
Task that manages receiving files for the session for certain ColumnFamily.
A future on the result (
StreamState) of a streaming plan.Handles the streaming a one or more streams to and from a specific remote node.
State Transition:
Current snapshot of streaming progress.
Store and update available ranges (data already received) to system keyspace.
Summary of streaming.
StreamTask is an abstraction of the streaming task performed over specific ColumnFamily.
StreamTransferTask sends streams for a given table
When a group of subnets are needed, this class can be used to represent the group as if it was a single subnet.
Message to indicate that the server is ready to receive requests.
SymmetricRemoteSyncTask sends
SyncRequest to remote(non-coordinator) node
to repair(stream) data with other replica.Netty's DefaultPromise uses a mutex to coordinate notifiers AND waiters between the eventLoop and the other threads.
SyncNodePair is used for repair message body to indicate the pair of nodes.
Extends
SyncFuture to implement the Promise interface.Body part of SYNC_REQUEST repair message.
Statistics about synchronizing two replica
Migrate 3.0 versions of some tables to 4.1.
Build and print table.
Share max offsets across multiple TableBuilders
The unique identifier of a table.
Encapsulates a volatile reference to an immutable
TableMetadata instance.Metrics for
ColumnFamilyStore.Contains multiple the Table Metric virtual tables.
Table level hook for repair
An immutable container for a keyspace's Tables.
The main streaming hook for a storage implementation.
Groups all the views for a given table.
Special rebufferer that replaces the tail of the file (from the specified cutoff point) with the given buffer.
A simple mechanism to impose our desired semantics on the execution of a task without requiring a specialised
executor service.
DataInput that also stores the raw inputs into an output buffer
This is useful for storing serialized buffers as they are deserialized.
Base type for temporal types (timestamp, date ...).
A CQL3 term, i.e.
A non terminal term, i.e.
A parsed, non prepared (thus untyped) term.
A terminal term, one that can be reduced to a byte buffer directly.
A set of
TermsSelector representing a simple term (literals or bound variables).
An iterator over the contents of an index that extends
Iterator<IndexEntry> that provides the min and max
terms in the index.Custom
SecurityManager and Policy implementation that only performs access checks
if explicitly enabled.Utility class that allow buffers to be reused by storing them in a thread local instance.
This class incorporates some Executor best practices for Cassandra.
Configure a
ThreadPoolExecutorPlus, applying Cassandra's best practices by default
Core threads may timeout, and use a default ThreadPoolExecutorBuilder.keepAlive time in ThreadPoolExecutorBuilder.keepAliveUnits
Threads share the same ThreadGroup, which may be configurably a child of a specified ThreadGroup
descended from the same parent of the NamedThreadFactory.MetaFactory
By default queues are unbounded in length
The default RejectedExecutionHandler is implementation dependent, but may be overridden
The default Thread.UncaughtExceptionHandler is inherited from NamedThreadFactory.MetaFactory, which in turn receives it
from the ExecutorBuilderFactoryA
ThreadPoolExecutorBase adapter to expose it via JMX.This class inherits Executor best practices from
ThreadPoolExecutorBase
and ThreadPoolExecutorBuilder.Metrics for
ThreadPoolExecutor.A guardrail based on numeric threshold(s).
A utility class to split the given
UnfilteredRowIterator into smaller chunks each
having at most ThrottledUnfilteredIterator.throttle + 1 unfiltereds.Function that rounds a date down to the closest multiple of a duration.
Function that rounds a timestamp down to the closest multiple of a duration.
Function that rounds a timeUUID down to the closest multiple of a duration.
Type for date-time values.
Nanosecond resolution time values
Tracks the assignment of racks and endpoints in each datacenter for all the "normal" endpoints
in this TokenMetadata.
Events related to
TokenMetadata changes.Holds token range informations for the sake of
StorageService.describeRing(java.lang.String).A relation using the token function.
Restriction using the token function.A snapshot or finished histrogram of tombstones for a sstable, as generated from
StreamingTombstoneHistogramBuilder.Deprecated.
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
ThreadLocal state for a tracing session.
ThreadLocal state for a tracing session.
A trace session context.
This class is to track bytes read from given DataInput
This class is to track bytes read from given DataInputStream
Tracker tracks live
View of data store for a table.An abstraction for Transactional behaviour.
A simple abstract implementation of Transactional behaviour.
We have a single common superclass for all Transformations to make implementation efficient.
Merkle tree response sent from given endpoint.
Base class for tries.
Defines the interface for a prefix tree, an ordered tree data structure.
Resolver of content of merged nodes.
A trie cursor.
Resolver of content of merged nodes, used for two-source merges (i.e.
Used by
Trie.Cursor.advanceToContent(org.apache.cassandra.db.tries.Trie.ResettingTransitionsReceiver) to track the transitions and backtracking taken.Used by
Trie.Cursor.advanceMultiple(org.apache.cassandra.db.tries.Trie.TransitionsReceiver) to feed the transitions taken.Adapter interface providing the methods a
Trie.Walker to a Consumer, so that the latter can be used
with Trie.process(org.apache.cassandra.db.tries.Trie.Walker<T, R>).A push interface for walking over the trie.
Convertor of trie entries to iterator where each entry is passed through
TrieEntriesIterator.mapContent(T, byte[], int) (to be implemented by
descendants).Walker of trie entries, used with Trie.process to walk all content in order and provide the path through which values
are reached.
This is an in-memory index using the
InMemoryTrie to store a ByteComparable
representation of the indexed values.Trie memtable implementation.
Trie node types and manipulation mechanisms.
A collection of
Trie utilitiesPage-aware random access reader for a trie terms dictionary written by
TrieTermsDictionaryWriter.Writes terms dictionary to disk in a trie format (see
IncrementalTrieWriter).A truncate operation descriptor
This message is sent back the truncate operation and basically specifies if
the truncate succeeded.
Fired during truncate, after the memtable has been flushed but before any
snapshot is taken and SSTables are discarded
Static helper methods and classes for tuples.
Similar to Value, but contains at least one NonTerminal, such as a non-pure functions or bind marker.
Represents a marker for a set of IN values that are tuples, like "SELECT ...
A raw marker for an IN list of tuples, like "SELECT ...
A terminal value for a list of IN values that are tuples.
A raw, literal tuple.
Represents a marker for a single tuple, like "SELECT ... WHERE (a, b, c) > ?"
A raw placeholder for a tuple of values for different multiple columns, each of which may have a different type.
A tuple of terminal values (e.g (123, 'abc')).
A tuple type.
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.
A value for a Tuple.
Base class for codecs mapping CQL
tuples to Java objects.Base class for codecs mapping CQL
user-defined types (UDTs) to Java objects.A codec that is capable of handling primitive booleans, thus avoiding the overhead of boxing
and unboxing such primitives.
A codec that is capable of handling primitive bytes, thus avoiding the overhead of boxing and
unboxing such primitives.
A codec that is capable of handling primitive doubles, thus avoiding the overhead of boxing and
unboxing such primitives.
A codec that is capable of handling primitive floats, thus avoiding the overhead of boxing and
unboxing such primitives.
A codec that is capable of handling primitive ints, thus avoiding the overhead of boxing and
unboxing such primitives.
A codec that is capable of handling primitive longs, thus avoiding the overhead of boxing and
unboxing such primitives.
A codec that is capable of handling primitive shorts, thus avoiding the overhead of boxing and
unboxing such primitives.
Parse a string containing an Type definition.
An immutable container for a keyspace's UDTs.
Utility methods to create
TypeToken instances.Base class for user-defined-aggregates.
Verifies Java UDF byte code.
Provides context information for a particular user defined function.
Package private implementation of
UDFContextRepresents a data type used within the UDF/UDA.
Base class for User Defined Functions.
A value for a User Defined Type.
Base class for DataOutput implementations that does not have an optimized implementations of Plus methods
and does no buffering.
Unchecked
InterruptedException, to be thrown in places where an interrupt is unexpectedOn memtable flush
Unfiltered is the common class for the main constituent of an unfiltered partition.
Helper class to deserialize Unfiltered object from disk efficiently.
An iterator over a number of unfiltered partitions (i.e.
Static methods to work with partition iterators.
Serialize each UnfilteredSerializer one after the other, with an initial byte that indicates whether
we're done or not.
An iterator over the rows of a given partition that also includes deletion informations.
Static methods to work with atom iterators.
Interface for a listener interested in the result of merging multiple versions of a given row.
Serialize/Deserialize an unfiltered row iterator.
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).
Serialize/deserialize a single Unfiltered (both on-wire and on-disk).
Common data access interface for sstables and memtables.
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.
The design of the unified compaction strategy is described in the accompanying UnifiedCompactionStrategy.md.
A level: index, sstables and some properties.
The sole purpose of this class is to currently create a
ShardedCompactionWriter.Exception thrown when we read an index id from a serialized ReadCommand and no corresponding IndexMetadata
can be found in the TableMetadata#indexes collection.
Catch-all codec for any unsupported legacy messages.
a utility for doing internal cql-based queries
Nodetool command to insert/update a CIDR group and associated mapping in the table
AuthKeyspace.CIDR_GROUPSAn interface defining the method to be applied to the existing and replacing object in a BTree.
Groups the parameters of an update query, and make building updates easier.
An
UPDATE statement parsed from a CQL query statement.A parsed INSERT JSON statement.
Handling of index updates on the write path.
A non-native, user-defined function, like UDFs and UDAs.
An immutable container for a keyspace's UDAs and UDFs.
A User Defined Type (UDT).
A user defined type.
A UDT field.
Static helper methods and classes for user types.
SSTable generation identifiers that can be stored across nodes in one directory/bucket
The goods are here: www.ietf.org/rfc/rfc4122.txt.
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
- 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
A version specific implementation of the
SSTableIndex where the
index is segmentedA collection of static validation functions reused across statements.
SSTable metadata component used only for validating SSTable.
ValidationRequest
ValidationComplete message is sent when validation compaction completed successfully.
ValidationTask sends
ValidationRequest to a replica.Handles the building of a merkle tree for a column family.
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.
Creates db objects using the given accessors value type.
Thread-unsafe value iterator for on-disk tries.
A guardrail that warns about some specific values, warns about but ignores some other values, and/or rejects the use
of some other values.
TypeCodec for the CQL type vector.Executes ANN search against a vector graph for an individual index segment.
Basically similar to a Value, but with some non-pure function (that need
to be evaluated at execution time) in it.
Processor that scans all rows from given partitions and selects rows with top-k scores based on vector indexes.
A vector type.
Note that priorities except P0 are presently unused.
Format version of indexing component, denoted as [major][minor].
A set of feature flags associated with a SSTable format
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.
A unique version number generator for any state that is generated by the
local node.
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).
A View copies data from a base table into a view table which can be queried independently from the
base.
The View is an immutable, point in time, view of the avalailable
SSTableIndexes for an index.Manages
View's for a single ColumnFamilyStore.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).
Borrows idea from
https://developers.google.com/protocol-buffers/docs/encoding#varints
Throw when attempting to decode a vint and the output type
doesn't have enough space to fit the value that was decoded
A specialised IMutation implementation for virtual keyspaces.
A system view used to expose system information.
Appends Cassandra logs to virtual table system_views.system_logs
A relatively easy to use utility for general purpose thread signalling.
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).
An abstract signal implementation
TODO: use intrusive linked list
Thread-unsafe trie walking helper.
Weighted queue is a wrapper around any blocking queue that turns it into a blocking weighted queue.
An extension of the
SkinnyPrimaryKeyMap for wide tables (those with clustering columns).Function to skip cells (from an iterator) that are not part of those queried by the user
according to the provided
ColumnFilter.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.Simple wrapper class to be used when a lambda function
needs to modify a variable outside it's scope.
Simple wrapper for native boolean type
When possible use
WrappedDataOutputStreamPlus instead of this class, as it will
be more efficient when using Plus methods.Wrapped runtime exception for lambda functions
An implementation of SharedCloseable that wraps a normal AutoCloseable,
ensuring its close method is only called when all instances of SharedCloseable have been
Instantiated once per RandomAccessReader, thread-unsafe.
Abstract class to make writing unfiltered iterators that wrap another iterator
easier.
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.
Handles blocking writes for ONE, ANY, TWO, THREE, QUORUM, and ALL consistency levels.
ZSTD Compressor