Index

Symbols

• 2PC (two-phase commit), Transactions, ACID-ity, and Two-Phase Commit, Lightweight Transactions and Paxos

A

• AbstractCompactionStrategy class, Compaction
• AbstractRead Executor class, Anti-Entropy, Repair, and Merkle Trees
• AbstractReplicationStrategy class, Replication Strategies
• access control, Role-Based Access Control-Role-Based Access Control, JMX Security, Translating Relationships
• accrual failure detection, Gossip and Failure Detection
• ACID (atomic, consistent, isolated, durable), Transactions, ACID-ity, and Two-Phase Commit-Transactions, ACID-ity, and Two-Phase Commit
• ActiveRepairService class, Repair
• aggregates, System Keyspaces, Getting Statistics, Metrics, Examining Log Files
• ALL consistency level, Consistency Levels, Read Consistency Levels
• ALLOW FILTERING keyword, Secondary Indexes
• AllowAllAuthenticator, Password Authenticator
• AllowAllAuthorizer, Using CassandraAuthorizer
• AllowAllInternodeAuthenticator, Additional authentication providers
• ALTER TABLE command, Tables
• ALTER USER command, Adding users
• Amazon Dynamo, Cassandra in 50 Words or Less, Brewer’s CAP Theorem, Hinted Handoff, Anti-Entropy, Repair, and Merkle Trees
• Amazon DynamoDB, Hinted Handoff
• Amazon EC2, Snitches, Amazon Web Services
• Amazon Elastic Block Store (see EBS)
• Amazon Machine Images (AMIs), Amazon Web Services
• Amazon Simple Storage Service (see S3)
• Amazon Virtual Private Cloud (see VPC)
• Amazon Web Services (see AWS)
• analytics, Analyzing Data with Apache Spark
• Ant, downloading, Building from Source
• anti-entropy protocol, Anti-Entropy, Repair, and Merkle Trees
• anticompaction, Compaction
• ANY consistency level, Hinted Handoff, Write Consistency Levels, The Cassandra Write Path, Read Consistency Levels
• AP, primarily supporting availability and partition tolerance, Brewer’s CAP Theorem
• Apache Cassandra (see Cassandra)
• Apache Cloudstack, Snitches, Snitches
• Apache distribution, installing Cassandra, Installing the Apache Distribution-What’s in There?
• Apache Hadoop, Analyzing Data with Apache Spark
• Apache Incubator, Where Did Cassandra Come From?
• Apache Kafka, Schema, Managing Data Flow with Apache Kafka-Managing Data Flow with Apache Kafka
• Apache Lucene, Searching with Apache Lucene, SOLR, and Elasticsearch
• Apache SOLR, Searching with Apache Lucene, SOLR, and Elasticsearch
• Apache Spark, Bulk Loading, Analyzing Data with Apache Spark-The spark-cassandra-connector
• append-only storage model, Compaction
• APPLY BATCH command, Batches
• architecture, Cassandra, The Cassandra Architecture-System Keyspaces
  • anti-entropy, Anti-Entropy, Repair, and Merkle Trees-Anti-Entropy, Repair, and Merkle Trees
  • Bloom filters, Bloom Filters
  • caching, Caching
  • commit logs, Memtables, SSTables, and Commit Logs-Memtables, SSTables, and Commit Logs
  • compaction, Compaction-Compaction
  • consistency levels, Consistency Levels
  • data centers and racks, Data Centers and Racks-Data Centers and Racks
  • deletion and tombstones, Deletion and Tombstones
  • gossip and failure detection, Gossip and Failure Detection-Gossip and Failure Detection
  • hinted handoff, Hinted Handoff
  • lightweight transactions, Lightweight Transactions and Paxos
  • managers and services, Managers and Services-CQL Native Transport Server
  • memtables, Memtables, SSTables, and Commit Logs-Memtables, SSTables, and Commit Logs
  • Merkle tree, Anti-Entropy, Repair, and Merkle Trees
  • partitioners, Partitioners
  • Paxos, Lightweight Transactions and Paxos
  • queries and coordinator nodes, Queries and Coordinator Nodes
  • replication strategies, Replication Strategies
  • snitches, Snitches
  • SSTables, Memtables, SSTables, and Commit Logs-Compaction
  • system keyspaces, System Keyspaces-System Keyspaces
  • tokens and rings, Rings and Tokens-Rings and Tokens
  • virtual nodes, Virtual Nodes
• AS SELECT clause, Materialized Views
• ascii data type, Textual Data Types
• ASGs (Auto Scaling groups), Netflix Priam
• assassinating nodes, Assassinating a node
• Astyanax (client driver), Application Development with Drivers
• asynchronous execution, Asynchronous Execution, Other Cassandra Drivers
• atomic batches, Batches
• atomicity for transactions, Transactions, ACID-ity, and Two-Phase Commit, Transactions, ACID-ity, and Two-Phase Commit
• audit logging, Audit Logging
• authentication and authorization, Driver security, Authentication and Authorization-Using CassandraAuthorizer
• AuthenticationException, Connecting to a Cluster
• AuthProvider interface, Driver security
• auto bootstrapping, Seed Nodes
• Auto Scaling groups (see ASGs)
• autobootstrap property, Adding Nodes to an Existing Data Center
• automatic paging, Paging
• autonomy, microservice architecture, Cassandra and Microservice Architecture
• auto_snapshot property, Taking a Snapshot
• availability, Brewer’s CAP Theorem-Brewer’s CAP Theorem, Write Consistency Levels
  • (see also high availability)
• avg function, Built-in functions and aggregates
• AWS (Amazon Web Services), The Rise of NoSQL, Amazon Web Services-Amazon Web Services
• AWS CloudFormation, Amazon Web Services
• Azure Resource Manager, Microsoft Azure
• Azure Virtual Network (VNet), Microsoft Azure

B

• backup and recovery, Backup and Recovery-Restoring from Snapshot
• badness threshold, Snitches
• batches, Maintaining Consistency
  • system keyspaces, System Keyspaces
  • writing data, Batches-Batches
• batchlog, Batches, Networking and Timeouts
• BEGIN BATCH command, Batches
• benchmarking, performance tuning, Benchmarking and Stress Testing
• bigint data type, Numeric Data Types
• Bigtable, Cassandra in 50 Words or Less, Brewer’s CAP Theorem
• bin directory, What’s in There?
• binary large objects, Other Simple Data Types
• BinAuditLogger, Audit Logging
• bind marker, Query Builder
• BlacklistedDirectoriesMBean, Recovering from disk failure
• blob data type, Other Simple Data Types
• blocking (two-phase commits), Transactions, ACID-ity, and Two-Phase Commit
• blogs, Cassandra-related, Getting Involved
• Bloom filters, Bloom Filters, The Cassandra Read Path, SSTables
• Bloom, Burton, Bloom Filters
• boolean data type, Other Simple Data Types
• bootstrapping, Seed Nodes, Adding Nodes to an Existing Data Center
• bounded contexts, identifying in microservice architecture, Identifying Bounded Contexts
• BoundStatement, DataStax Java Driver, Bound statement
• Brewer, Eric, Brewer’s CAP Theorem, Brewer’s CAP Theorem
• Brewer’s CAP theorem, Brewer’s CAP Theorem-Brewer’s CAP Theorem
• bucketing, Breaking Up Large Partitions
• buffer cache, SSTables
• BuildableQuery interface, Query Builder
• Building Microservices (O’Reilly), Cassandra and Microservice Architecture
• built-in functions and aggregates, Built-in functions and aggregates
• bulk loading, for migration, Bulk Loading
• ByteOrderedPartitioner, Partitioners

C

• C# and .NET framework, Application Development with Drivers
• CA ERwin Data Modeler, Schema
• CA, primarily supporting consistency and availability, Brewer’s CAP Theorem
• CacheServiceMBean, Cache Service MBean
• caching
  • in Cassandra architecture, Caching
  • employing a caching layer, What’s Wrong with Relational Databases?
  • performance tuning, Caching-Saved Cache Settings
  • unified authentication, Authentication cache MBean
• Calvin transaction protocol, The Rise of NoSQL
• camel case, Creating a Keyspace and Table in cqlsh
• CAP theorem, Brewer’s CAP Theorem-Brewer’s CAP Theorem
• “CAP Twelve Years Later: How the ‘Rules’ Have Changed” (Brewer), Brewer’s CAP Theorem
• CAPI-RowCache, Row Cache
• case
  • DataStax Java Driver, Schema access
  • in cqlsh, Basic cqlsh Commands
  • snake vs. camel case styles, Creating a Keyspace and Table in cqlsh
• “The Case for Shared Nothing” (Stonebreaker), Sharding and Shared-Nothing Architecture
• Cassandra
  • application development with drivers, Application Development with Drivers-Other Cassandra Drivers
  • architecture, The Cassandra Architecture-System Keyspaces
  • cloud deployments, Hybrid Cloud and Multicloud Deployment, Cloud Deployment-Microsoft Azure
  • community resources, Getting Involved-Getting Involved
  • configuring, Configuring and Deploying Cassandra-Startup and JVM Settings
  • data modeling for, Data Modeling-Cassandra Data Modeling Tools
  • data, writing and reading, Writing and Reading Data-Deleting
  • deciding on fit for your project, Is Cassandra a Good Fit for My Project?-Hybrid Cloud and Multicloud Deployment
  • designing applications with, Designing Applications with Cassandra-Interactions Between Microservices
  • differences from RDBMS, The Relational Data Model, Design Differences Between RDBMS and Cassandra-Sorting is a design decision
  • distributions, Installing the Apache Distribution, Other Cassandra Distributions
  • geographical distribution of data, Geographical Distribution
  • installing, Installing Cassandra-Additional Build Targets
  • integrations, Common Integrations-The spark-cassandra-connector
  • introduction, Introducing Cassandra-Getting Involved
  • for large deployments, Large Deployments
  • maintenance, Maintenance-Cassandra Kubernetes Operators
  • migrating, Migrating and Integrating-Bulk Loading
  • monitoring, Monitoring-Full Query Logging
  • origins, Where Did Cassandra Come From?-Where Did Cassandra Come From?
  • performance tuning, Performance Tuning-Shenandoah Garbage Collector (JDK12)
  • planning cluster deployment, Planning a Cluster Deployment-Network
  • releases, Installing the Apache Distribution
  • running, Running Cassandra-Stopping Cassandra
  • writes, statistics and analysis, Lots of Writes, Statistics, and Analysis
• cassandra -f command, Starting the Server
• cassandra -p command, Stopping Cassandra
• “Cassandra: A Decentralized Structured Storage System” (Lakshman and Malik), Where Did Cassandra Come From?
• Cassandra Cluster Manager (see ccm)
• Cassandra Enhancement Proposal (see CEP)
• Cassandra Kubernetes Operators, Cassandra Kubernetes Operators-Cassandra Kubernetes Operators
• Cassandra Loader, Bulk Loading
• Cassandra Query Language (see CQL)
• Cassandra Sidecars, Cassandra Sidecars
• cassandra-cli (removed), Running the CQL Shell
• cassandra-env.sh file, Health Check, Garbage-First garbage collector (JDK 8 or JDK 11)
• cassandra-rackdc.properties file, Snitches, Amazon Web Services
• cassandra-stress, Using cassandra-stress-Using cassandra-stress
• cassandra-topology.properties file, Snitches
• cassandra.yaml file, What’s in There?, Setting the Environment, Virtual Nodes, Health Check
• CassandraAuthorizer, Using CassandraAuthorizer
• CassandraDaemon interface, Cassandra Daemon
• CassandraMetricsRegistry class, Metrics MBeans
• CassandraRoleManager, Configuring the authenticator
• CASSANDRA_HOME directory, Setting the Environment
• CassKop, Cassandra Kubernetes Operators
• causal consistency, Tuneable Consistency
• ccm (Cassandra Cluster Manager), Cassandra Cluster Manager-Dynamic Ring Participation
• CDC (change data capture), Interactions Between Microservices, Zero-Downtime Migration, Managing Data Flow with Apache Kafka
• cells (values), number in a partition, Calculating Partition Size
• CEP (Cassandra Enhancement Proposal), Getting Involved
• certificates, SSL, TLS, and Certificates, Client-to-Node Encryption
• change data capture (see CDC)
• cheap quorum, Read Repair
• Chebotko diagrams, Logical Data Modeling, Physical Data Modeling
• check-and-set semantics, Lightweight Transactions and Paxos
• choreography, Interactions Between Microservices
• chunk cache, Caching, Chunk Cache
• classes, Managers and Services, CQL Native Transport Server, Object Mapper
• clean (build target), Additional Build Targets
• cleanup, Cleanup
• CLI (command-line interface) client (removed), Running the CQL Shell
• client-to-node encryption, Client-to-Node Encryption
• clients, performance tuning, Shenandoah Garbage Collector (JDK12)
• client_encryption_options, Client-to-Node Encryption
• cloud environments
  • cluster topology, Cluster Topology and Replication Strategies
  • deployment into the cloud, New for the Third Edition, Hybrid Cloud and Multicloud Deployment, Cloud Deployment-Microsoft Azure
  • relational databases and, What’s Wrong with Relational Databases?
  • snitches for, Snitches, Snitches
• CloudstackSnitch, Snitches
• cluster-related MBeans, Cluster-Related MBeans
• clustering columns, Cassandra’s Data Model, Sorting is a design decision, Hotel Logical Data Model, Range Queries, Ordering and Filtering
• clusters, Adding Nodes to a Cluster
  • (see also nodes)
  • adding nodes, Adding Nodes to a Cluster, Adding a Data Center to a Cluster
  • Cassandra’s data model, Clusters
  • ccm, Cassandra Cluster Manager-Dynamic Ring Participation
  • connecting DataStax Java Driver, Connecting to a Cluster
  • creating, Creating a Cluster-Creating a Cluster
  • dedicated vs. shared, Services, Keyspaces, and Clusters
  • dynamic ring participation, Dynamic Ring Participation
  • name changes, Creating a Cluster
  • nodetool for monitoring, Getting Cluster Information-ring
  • planning deployment, Planning a Cluster Deployment-Network
  • replication strategies, Cluster Topology and Replication Strategies
  • selecting instances, Selecting Instances
  • sizing, Sizing Your Cluster
  • system keyspaces, System Keyspaces-System Keyspaces
  • topology, Cluster Topology and Replication Strategies
• CMS (Concurrent Mark Sweep) garbage collector, Memory
• Codd, Edgar F.
  • 12 Rules for relationsl data, What’s Wrong with Relational Databases?
  • “A Relational Model of Data for Large Shared Data Banks”, What’s Wrong with Relational Databases?
• collections, Collections-Collections, User-Defined Types
• column stores, The Rise of NoSQL
• column-oriented database, vs. Cassandra, Row-Oriented
• column-oriented store, The Rise of NoSQL, Cassandra’s Data Model
• ColumnFamilyStore class, Storage Engine
• ColumnFamilyStoreMBean, Column Family Store MBean, Compaction
• columns
  • Cassandra’s data model, Cassandra’s Data Model-Cassandra’s Data Model, Columns-Time to live (TTL)
  • creating a table, Creating a Keyspace and Table in cqlsh
  • partition size calculation, Calculating Partition Size
  • secondary index pitfalls, Secondary Indexes
  • static, Calculating Partition Size
• commit logs
  • in Cassandra architecture, Memtables, SSTables, and Commit Logs
  • data storage, Data Storage
  • performance tuning, Commit Logs
  • writing data, Writing, The Cassandra Write Path, Commit log files
• CommitLogMBean, Commit Log MBean
• commitlog_compression property, Commit Logs
• commitlog_directory property, Data Storage
• commitlog_sync element, Commit Logs
• commitlog_sync_period_in_ms property, Commit Logs
• commit_failure_policy property, Data Storage
• commit_log_sync_batch_window_in_ms, Commit Logs
• compaction
  • in Cassandra architecture, Compaction
  • large partition warning, Analyzing Performance Issues
  • nodetool cleanup command, Cleanup
  • performance tuning, Compaction-Compaction
  • tombstones and, Deleting
  • validation, Anti-Entropy, Repair, and Merkle Trees, Repair
• compaction strategies, Compaction, Sizing Your Cluster, Compaction
• compaction threshold, Compaction
• CompactionManager class, Compaction, Cassandra’s MBeans
• CompactionManagerMBean class, Compaction Manager MBean, Compaction
• CompactionParameters attribute, Compaction
• compaction_throughput_mb_per_sec property, Compaction
• compensation for two-phase commit, defined, Transactions, ACID-ity, and Two-Phase Commit
• complex event processing system, Schema
• composite key, Cassandra’s Data Model
• compression
  • client–node messages, Compression
  • commit log, Commit Logs
  • performance tuning, Shenandoah Garbage Collector (JDK12)
  • SSTables, Memtables, SSTables, and Commit Logs, SSTables
• CompressionInfo.db, SSTable component, SSTable files
• conceptual data modeling, Conceptual Data Modeling
• concurrency, performance tuning, Concurrency and Threading
• Concurrent Mark Sweep garbage collector (see CMS)
• concurrent_compactors property, Compaction
• conditional write statements, Lightweight Transactions
• conf directory, What’s in There?
• conferences, Cassandra community, Getting Involved
• configuration files, Startup and JVM Settings, Upgrading Cassandra
  • (see also cassandra.yaml file)
• configuring Cassandra, Configuring and Deploying Cassandra-Startup and JVM Settings
• connection errors, installing Cassandra, Running the CQL Shell
• connection heartbeat, DataStax Java Driver, Connection pooling
• connection pooling, Connection pooling
• consensus algorithms, Lightweight Transactions and Paxos
• consistency
  • Cassandra’s tuneable, Tuneable Consistency-Tuneable Consistency
  • defined, Transactions, ACID-ity, and Two-Phase Commit
  • LWT and Paxos, Lightweight Transactions and Paxos
  • maintaining among microservices, Interactions Between Microservices
  • relationship to availability and partition tolerance, Brewer’s CAP Theorem-Brewer’s CAP Theorem
  • scalability challenge and, What’s Wrong with Relational Databases?
  • SERIAL and LOCAL_SERIAL, Lightweight Transactions
  • types of, Tuneable Consistency-Tuneable Consistency
• CONSISTENCY command, Write Consistency Levels
• consistency levels
  • in Cassandra architecture, Consistency Levels
  • deletes, Deleting
  • maintaining during migration, Maintaining Consistency
  • performance tuning, Maintaining Consistency
  • reading data, Read Consistency Levels, Read Repair
  • repairs, Repair, Best practices for repair
  • replication factors and, Consistency Levels, Tracing, Role-Based Access Control
  • writing data, Write Consistency Levels-Write Consistency Levels, Lightweight Transactions
• ConstantReconnectionPolicy, Retrying failed queries
• ConstantSpeculativeExecutionPolicy, Speculative execution
• container deployments, Other Cassandra Distributions
• coordinator nodes, Queries and Coordinator Nodes, Lightweight Transactions and Paxos, The Cassandra Write Path-The Cassandra Write Path, The Cassandra Read Path
• COUNT function, Built-in functions and aggregates
• counter batches, Batches
• counter cache, Caching, Counter Cache
• counter data type, Other Simple Data Types
• counters, Batches
• counter_cache_size_in_mb, Counter Cache
• CP, primarily supporting consistency and partition tolerance, Brewer’s CAP Theorem
• CQL (Cassandra Query Language), The Cassandra Query Language-User-Defined Types
  • Cassandra's data model, Cassandra’s Data Model-Time to live (TTL)
  • client drivers and, DataStax Java Driver
  • CQL data types, CQL Types-User-Defined Types
  • defining database schema, Defining Database Schema-Cassandra Data Modeling Tools
  • introduction of, Row-Oriented
  • relational data model, The Relational Data Model
  • representing other database models in, Representing other database models in CQL
  • tools to manage, Cassandra Data Modeling Tools-Cassandra Data Modeling Tools
• CQL data types, CQL Types-User-Defined Types
  • collections, Collections-Collections
  • numeric data types, Numeric Data Types
  • textual data types, Textual Data Types
  • time and identity data types, Time and Identity Data Types-Time and Identity Data Types
  • tuples, Tuples
  • user-defined types, User-Defined Types-User-Defined Types
• CQL Native Protocol, CQL Native Transport Server, Connection pooling, System Views
• CQL shell, Running the CQL Shell-Writing and Reading Data in cqlsh, Textual Data Types
• CqlIdentifier class, Schema access
• CqlSession class, Connecting to a Cluster-Statements
• CqlSession object, Connecting to a Cluster-Statements
• CqlSession.Builder class, File-based configuration
• $CQLSH_HOST environment variable, Running the CQL Shell
• $CQLSH_PORT environment variable, Running the CQL Shell
• CREATE CUSTOM INDEX command, Secondary Indexes
• CREATE KEYSPACE command, Creating a Keyspace and Table in cqlsh
• CREATE MATERIALIZED VIEW command, Materialized Views
• CREATE OR REPLACE syntax, User-defined aggregates
• CREATE TABLE command, Creating a Keyspace and Table in cqlsh, Sorting is a design decision, Range Queries, Ordering and Filtering
• CREATE TYPE command, User-Defined Types
• CREATE USER command, Adding users
• CRUD services, Interactions Between Microservices
• cryptography, Partitioners, Node-to-Node Encryption

D

• DAO (Data Access Object), Object Mapper
• data
  • deleting, Deletion and Tombstones
  • refactoring access to, Refactoring Data Access
  • writing and reading, Writing and Reading Data-Deleting
• Data Access Object (see DAO)
• data center awareness, Load balancing
• data centers
  • adding nodes, Adding Nodes to an Existing Data Center
  • adding to a cluster, Adding a Data Center to a Cluster
  • application design considerations, Data Centers and Load Balancing
  • in Cassandra architecture, Data Centers and Racks
  • cloud deployment, Cloud Deployment
  • cluster topology, Cluster Topology and Replication Strategies-Cluster Topology and Replication Strategies, Planning the Deployment
  • coordinator nodes and multiple, The Cassandra Write Path
  • network authorization, Role-Based Access Control
  • removing, Removing a data center
  • timeouts, Network
• data consistency (see consistency)
• Data Definition Language (see DDL)
• data directory, Setting the Environment
• Data Manipulation Language (see DML)
• data modeling, Row-Oriented, Data Modeling-Cassandra Data Modeling Tools
  • (see also CQL)
  • adapting the model for migration, Adapting the Data Model-Translating Relationships
  • conceptual data modeling, Conceptual Data Modeling
  • defining application queries, Defining Application Queries
  • defining database schema, Defining Database Schema-Cassandra Data Modeling Tools
  • evaluating and refining, Evaluating and Refining-Breaking Up Large Partitions
  • logical, Logical Data Modeling-Reservation Logical Data Model
  • partitioned row store, Row-Oriented
  • physical, Physical Data Modeling-Reservation Physical Data Model
  • RDBMS design, RDBMS Design-Sorting is a design decision
  • relational vs. Cassandra’s data model, The Relational Data Model-Cassandra’s Data Model
  • schema-free, Row-Oriented
• data storage (see storage)
• data types
  • assigning, Physical Data Modeling-Reservation Physical Data Model
  • CQL, CQL Types-User-Defined Types
  • maintaining among microservices, Interactions Between Microservices
• Data.db, SSTable component, SSTable files
• database MBeans, Database MBeans-Cache Service MBean
• database vs. keyspace, Keyspaces
• datafiles, Setting the Environment, Data Storage, Decommissioning a node
• DataStax, Where Did Cassandra Come From?
• DataStax Academy, Getting Involved
• DataStax Bulk Loader (see DSBulk)
• DataStax C# Driver, Other Cassandra Drivers
• DataStax DevCenter, Cassandra Data Modeling Tools
• DataStax Enterprise, Other Cassandra Distributions, Representing other database models in CQL, Development Environment Configuration, Cassandra Kubernetes Operators, Encryption
• DataStax Java Driver, DataStax Java Driver-Driver metrics
  • asynchronous execution, Asynchronous Execution
  • authentication with, Authenticating via the DataStax Java Driver
  • batching with, Batches
  • configuration, Driver Configuration-Execution profiles
  • connecting to a cluster, Connecting to a Cluster
  • debugging, Debugging and Monitoring
  • development environment configuration, DataStax Java Driver
  • logging, Driver logging
  • metadata, Metadata
  • metrics, Driver metrics
  • microservice using, Design Choices for a Java Microservice
  • monitoring, Debugging and Monitoring
  • object mappers, Object Mapper-Object Mapper
  • query builder, Query Builder-Query Builder
  • statements, Statements-Bound statement
• DataStax Node.js Driver, Other Cassandra Drivers
• DataStax Ops Center, DataStax OpsCenter
• DataStax Python Driver, Other Cassandra Drivers
• DataStax Ruby and PHP Drivers, Other Cassandra Drivers
• DataStaxEnterprise-specific drivers, Development Environment Configuration
• data_file_directories property, Data Storage
• date data type, Time and Identity Data Types
• dateOf() function, Time and Identity Data Types
• dates and times data types, Time and Identity Data Types-Time and Identity Data Types
• DateTieredCompactionStrategy (see DTCS)
• DCAwareRoundRobinPolicy, Load balancing
• DDL (Data Definition Language), A Quick Review of Relational Databases
• DEBUG logging level, Logging
• debugging, DataStax Java Driver, Debugging and Monitoring
• decentralized database, Distributed and Decentralized-Distributed and Decentralized
• decimal data type, Numeric Data Types
• decommissioning nodes, Decommissioning a node, Decommissioning a node
• Dedicated Interconnect, Google Cloud Platform
• DELETE command, Writing and Reading Data in cqlsh, Collections
• deleting data, Deletion and Tombstones
• denormalization, What’s Wrong with Relational Databases?, Denormalization, Reservation Logical Data Model, Secondary Indexes, Maintaining Consistency
• deployment considerations
  • application design, Deployment and Integration Considerations-Interactions Between Microservices
  • cloud deployment, Cloud Deployment-Microsoft Azure
  • planning, Planning a Cluster Deployment-Network, Planning the Deployment
  • when deciding on Cassandra, Large Deployments
• DESCRIBE command, Describing the Environment in cqlsh
• DESCRIBE FUNCTIONS command, User-defined aggregates
• DESCRIBE KEYSPACE command, Describing the Environment in cqlsh, Creating a Keyspace and Table in cqlsh, User-Defined Types, Secondary Indexes
• DESCRIBE TABLE command, Creating a Keyspace and Table in cqlsh, Tables
• Designing Data-Intensive Applications (O’Reilly), Transactions, ACID-ity, and Two-Phase Commit
• DevCenter, Cassandra Data Modeling Tools
• development clusters, Generating Certificates for Development Clusters
• development environments, configuring, Development Environment Configuration
• DHT (distributed hash table), Partitioners
• diff command, Creating a Cluster, Upgrading Cassandra
• differential backups, Backup and Recovery
• digest requests, The Cassandra Read Path, The Cassandra Read Path
• Digest.crc32, SSTable component, SSTable files
• directory-based sharding, Sharding and Shared-Nothing Architecture
• disk configruation, cluster deployment, Storage
• disks
  • reads and seeks on writes, Writing
  • size calculation, Calculating Size on Disk-Calculating Size on Disk
  • writing files to, Writing Files to Disk-SSTable files
• disk_failure_policy property, Data Storage, Recovering from disk failure
• distributed database, Transactions, ACID-ity, and Two-Phase Commit-Transactions, ACID-ity, and Two-Phase Commit, Distributed and Decentralized-Distributed and Decentralized, Interactions Between Microservices
• distributed hash table (see DHT)
• distributed tracing, Tracing
• DML (Data Manipulation Language), A Quick Review of Relational Databases
• doc directory, What’s in There?
• Docker
  • creating a cluster in, Startup and JVM Settings
  • running Cassandra in, Other Cassandra Distributions, Running Cassandra in Docker-Running Cassandra in Docker
• document models, Representing other database models in CQL
• document stores, The Rise of NoSQL
• Domain-Driven Design (Evans), Microservice Architecture for a Hotel Application
• double data type, Numeric Data Types
• drivers, application development with, Application Development with Drivers-Other Cassandra Drivers
  • DataStax Java Driver, DataStax Java Driver-Driver metrics
  • other Cassandra drivers, Other Cassandra Drivers
• DROP AGGREGATE command, User-defined aggregates
• DROP command, Tuples
• DROP FUNCTION command, User-defined aggregates
• DROP INDEX command, Secondary Indexes
• DROP TABLE command, Writing and Reading Data in cqlsh
• DROP USER command, Adding users
• Dropwizard Metrics, Metrics MBeans
• DSBulk (DataStax Bulk Loader), Bulk Loading
• DTCS (DateTieredCompactionStrategy) (deprecated), Compaction
• dual-write technique, migration, Zero-Downtime Migration
• durability of transactions, Transactions, ACID-ity, and Two-Phase Commit
• durable writes, Creating a Keyspace and Table in cqlsh
• dynamic ring participation, Dynamic Ring Participation
• dynamic snitching, Snitches
• DynamicEndpointSnitch, Snitches, Snitches, Snitch MBeans
• DynamicEndpointSnitchMBean, Snitch MBeans
• Dynamo, Cassandra in 50 Words or Less, Brewer’s CAP Theorem, Hinted Handoff, Anti-Entropy, Repair, and Merkle Trees
• DynamoDB, Hinted Handoff

E

• EACH_QUORUM consistency level, Write Consistency Levels, Read Consistency Levels, Adding a Data Center to a Cluster
• EBS (Elastic Block Store), Amazon Web Services
• EC2 (Elastic Compute Cloud), Snitches, Amazon Web Services
• Ec2MultiRegionSnitch, Snitches
• Ec2Snitch, Snitches
• eden space, Default configuration (JDK 8 or JDK 11)
• elastic scalability, Elastic Scalability
• Elasticsearch, Searching with Apache Lucene, SOLR, and Elasticsearch
• Ellis, Jonathan, Where Did Cassandra Come From?
• EmbeddedCassandraService, Cassandra Daemon
• encapsulation, microservice architecture, Cassandra and Microservice Architecture
• encryption, Driver security, Encryption-Client-to-Node Encryption
• EndpointSnitchInfoMBean, Snitch MBeans
• endpoint_snitch property, Adding a Data Center to a Cluster
• entities, translating for migration, Translating Entities
• entity-relationship model, Conceptual Data Modeling
• enumerated values, converting to/from strings, Numeric Data Types
• environment script, Startup and JVM Settings
• epidemic protocols (see gossip protocol)
• ERROR logging level, Logging
• Evans, Eric
  • Domain-Driven Design, Microservice Architecture for a Hotel Application
• eventual consistency, Tuneable Consistency-Tuneable Consistency
• exceptions, Running the CQL Shell, Connecting to a Cluster, Bound statement, Retrying failed queries
• execution profiles, DataStax Java Driver, Execution profiles
• ExponentialReconnectionPolicy, Retrying failed queries
• extraction utilities, installing Cassandra, Extracting the Download

F

• -f (foreground) flag, starting Cassandra with, Starting the Server, Logging
• Facebook, Cassandra in 50 Words or Less, Where Did Cassandra Come From?
• failure detection, Gossip and Failure Detection-Gossip and Failure Detection
• FailureDetector class, Gossip and Failure Detection
• FailureDetectorMBean, Failure Detector MBean
• fault tolerance, High Availability and Fault Tolerance
• feature-based sharding, Sharding and Shared-Nothing Architecture
• file-based driver configuration, File-based configuration
• files, writing to disk, Writing Files to Disk-SSTable files
• file_cache_size_in_mb property, SSTables
• Filter.db, SSTable component, SSTable files
• filtering data, Range Queries, Ordering and Filtering, Additional load testing tools
• float data type, Numeric Data Types
• flush, Flush
• forums, Cassandra community, Getting Involved
• freezing collections, User-Defined Types
• FROM clause, Materialized Views
• full backups, Backup and Recovery
• full compaction, Compaction
• full repair, Full repair, incremental repair, and anti-compaction
• full replicas, Read Repair
• functional segmentation, Sharding and Shared-Nothing Architecture
• functions, System Keyspaces, User-defined functions-Built-in functions and aggregates

G

• G1GC (Garbage-First garbage collector), Garbage-First garbage collector (JDK 8 or JDK 11)
• Gang of Four Strategy pattern, Replication Strategies
• garbage collection (see GC)
• Garbage Collection Grace Seconds, Deletion and Tombstones
• Garbage-First garbage collector (see G1GC)
• GC (garbage collection), Garbage Collection MBeans, Garbage Collection
• GCE (Google Compute Engine), Google Cloud Platform
• GCInspectorMXBean, Garbage Collection MBeans
• GCP (Google Cloud Platform), Brewer’s CAP Theorem, Snitches, Google Cloud Platform
• gc_grace_seconds property, Deletion and Tombstones, Repairing Failed Nodes
• gc_warn_threshold_in_ms, Shenandoah Garbage Collector (JDK12)
• generation, SSTable, SSTable files
• geographical distribution of data, Cassandra support for, Geographical Distribution
• GoCQL Driver, Other Cassandra Drivers
• Google Bigtable, Cassandra in 50 Words or Less, Brewer’s CAP Theorem
• Google Cloud Launcher, Google Cloud Platform
• Google Cloud Platform (see GCP)
• Google Cloud Spanner, The Rise of NoSQL
• Google Cloud Stackdriver, Google Cloud Platform
• Google Compute Engine (see GCE)
• Google Spanner, Brewer’s CAP Theorem
• Google VPC, Google Cloud Platform
• GoogleCloudSnitch, Snitches, Google Cloud Platform
• gossip protocol, Gossip and Failure Detection, System Keyspaces, Adding Nodes to a Cluster, Snitches, Handling Node Failure
• Gossiper class, Gossip and Failure Detection
• GossiperMBean, Gossiper MBean
• GossipingPropertyFileSnitch, Snitches, Adding a Data Center to a Cluster
• Grafana dashboards, Metrics
• graph data models, Representing other database models in CQL
• graph databases, The Rise of NoSQL, Brewer’s CAP Theorem
• Gray, Jim
  • “The Transaction Concept: Virtues and Limitations”, Transactions, ACID-ity, and Two-Phase Commit
• guaranteed delivery, hinted handoff and, Hinted Handoff

H

• Hackolade, Cassandra Data Modeling Tools
• Hadoop, Analyzing Data with Apache Spark
• Hammerbacher, Jeff, Where Did Cassandra Come From?
• hash tree, Anti-Entropy, Repair, and Merkle Trees
• health check, Health Check
• heap memory, Key Cache, Memory
• Hector (client driver), Application Development with Drivers
• HELP command, cqlsh Help
• high availability, Distributed and Decentralized
• high performance, High Performance
• hinted handoff
  • in Cassandra architecture, Hinted Handoff
  • MBean, Hints Service MBean
  • performance tuning, Hinted Handoff
  • repairing failed nodes, Repairing Failed Nodes
  • system.hints table removal, System Keyspaces
  • timeouts, Networking and Timeouts
  • for write path, Writing
• hinted_handoff_throttle_in_kb property, Hinted Handoff
• hints, defined, Hinted Handoff
• HintsService class, Hinted Handoff
• HintsServiceMBean, Hints Service MBean
• hints_directory property, Hinted Handoff
• HOCON (Human-Optimized Config Object Notation) format, File-based configuration
• Hohpe, Gregor
  • “Starbucks Does Not Use Two-Phase Commit”, Transactions, ACID-ity, and Two-Phase Commit
• horizontal scaling, Transactions, ACID-ity, and Two-Phase Commit, The Rise of NoSQL, Elastic Scalability
• hotel application (example)
  • application design, Designing Applications with Cassandra-Interactions Between Microservices
  • defining application queries, Defining Application Queries
  • defining database schema, Defining Database Schema-Cassandra Data Modeling Tools
  • disk size calculation, Calculating Size on Disk-Calculating Size on Disk
  • entity-relationship model, Conceptual Data Modeling
  • logical data model, Hotel Logical Data Model-Reservation Logical Data Model
  • partition size calculation, Calculating Partition Size-Calculating Partition Size
  • physical data model, Hotel Physical Data Model-Reservation Physical Data Model
  • RDBMS design for, RDBMS Design
  • splitting partitions, Breaking Up Large Partitions
• hotspots, Partitioners
• hybrid cloud, Hybrid Cloud and Multicloud Deployment, Cluster Topology and Replication Strategies

I

• IAuthenticator interface, Additional authentication providers
• idempotence warning, Other Simple Data Types
• identity data types, Time and Identity Data Types
• IDEs (integrated development environments), Cassandra Data Modeling Tools, Query Builder, Monitoring Cassandra with JMX
• IEndpointSnitch interface, Snitches
• IF EXISTS clause, Lightweight Transactions
• IF NOT EXISTS clause, Lightweight Transactions, Lightweight Transactions, User-defined aggregates
• IFailureDetector interface, Gossip and Failure Detection
• IInternodeAuthenticator interface, Additional authentication providers
• IllegalStateException, Bound statement
• IMS (Information Management System), What’s Wrong with Relational Databases?
• IN clause, Range Queries, Ordering and Filtering
• incremental backups, enabling, Enabling Incremental Backup
• incremental repair, Full repair, incremental repair, and anti-compaction
• incremental_backups property, Enabling Incremental Backup
• Incubator, Where Did Cassandra Come From?
• Index.db, SSTable component, SSTable files
• indexes
  • caches, Saved Cache Settings
  • compaction and, Compaction
  • MBean, Column Family Store MBean
  • partition index, The Cassandra Read Path
  • rebuilding, Rebuilding Indexes
  • SASI, Secondary Indexes
  • search and, Searching with Apache Lucene, SOLR, and Elasticsearch
  • secondary, Secondary Indexes-Secondary Indexes, Translating Entities
  • SSTable, The Cassandra Read Path, Deleting, SSTables
  • summary, SSTables
• inet data type, Other Simple Data Types
• infinite loops with two-phase commits, Transactions, ACID-ity, and Two-Phase Commit
• INFO logging level, Logging
• Information Management System (see IMS)
• initial_token property, Virtual Nodes, Tokens and Virtual Nodes
• initServer method, Storage Service
• INSERT command, Writing and Reading Data in cqlsh, Tables, Query Builder, Lightweight Transactions
• INSERT JSON command, Representing other database models in CQL
• Instaclustr, Cassandra Kubernetes Operators
• installing Cassandra, Installing Cassandra-Additional Build Targets
• instrumentation, Monitoring Cassandra with JMX
• int data type, Numeric Data Types
• integrated development environments (see IDEs)
• integrations for Cassandra, Common Integrations-The spark-cassandra-connector
  • Apache Kafka, Schema, Managing Data Flow with Apache Kafka-Managing Data Flow with Apache Kafka
  • Apache Lucene, Searching with Apache Lucene, SOLR, and Elasticsearch
  • Apache SOLR, Searching with Apache Lucene, SOLR, and Elasticsearch
  • Apache Spark, Analyzing Data with Apache Spark-The spark-cassandra-connector
  • application design, Deployment and Integration Considerations-Interactions Between Microservices
  • Elasticsearch, Searching with Apache Lucene, SOLR, and Elasticsearch
• intercloud, Cluster Topology and Replication Strategies
• internal MBeans, Internal MBeans
• IP addresses, Seed Nodes
• IPartitioner interface, Partitioners
• IPv4 or IPv6 internet addresses, Other Simple Data Types
• ISO 8601 date formats, Time and Identity Data Types
• isolation of transactions, Transactions, ACID-ity, and Two-Phase Commit

J

• Java, DataStax Java Driver
• Java Development Kit (see JDK)
• Java drivers (see DataStax Java Driver)
• Java JDK, Building from Source, Shenandoah Garbage Collector (JDK12)
• Java Keystore (see JKS)
• Java Management Extensions (see JMX)
• Java Map, Storage Service MBean
• Java Message Service (see JMS)
• Java microservice, Design Choices for a Java Microservice
• Java New I/O (NIO), Memtables
• Java Runtime Environment (see JRE)
• Java Specification Request (see JSR)
• Java Virtual Machine (see JVM)
• java.util.logging, Logging
• Javadoc tool, What’s in There?, Development Environment Configuration
• JavaScript Object Notation (see JSON)
• JavaScript, functions defined in, User-defined functions
• JAVA_HOME environment variable, Setting the Environment
• JBOD (just a bunch of disks) deployment, Storage
• JConsole, Monitoring Cassandra with JMX
• JDBC (Java Database Connectivity), Other Cassandra Drivers
• JDK (Java Development Kit), Building from Source, Shenandoah Garbage Collector (JDK12)
• JIRA issues, Getting Involved
• JMeter, Additional load testing tools
• JMS (Java Message Service), Hinted Handoff
• JMX (Java Management Extensions), Driver metrics, Monitoring Cassandra with JMX-Monitoring Cassandra with JMX, Securing JMX Access-Securing JMX Access
• JMXConfigurableThreadPoolExecutorMBean, Thread Pool MBeans
• JMXConfiguratorMBean, ring
• JMXEnabledScheduledThreadPoolExecutor, Thread Pool MBeans
• JMXEnabledThreadPoolExecutorMBean, Thread Pool MBeans
• jmxremote.access file, Securing JMX Access
• jmxremote.password file, Securing JMX Access
• Jmxterm, Monitoring Cassandra with JMX
• joins, What’s Wrong with Relational Databases?, No joins
• JRE (Java Runtime Environment), Building from Source, Securing JMX Access
• JSON (JavaScript Object Notation), Representing other database models in CQL
• JSR (Java Specification Request), Monitoring Cassandra with JMX
• Just a Bunch of Disks (see JBOD)
• JVM (Java Virtual Machine)
  • setting the environment, What’s in There?
  • settings, Starting the Server, Startup and JVM Settings, JVM Settings-Shenandoah Garbage Collector (JDK12)
  • stopping the server, Stopping Cassandra
• jvm.options file, Garbage-First garbage collector (JDK 8 or JDK 11)

K

• K8s (Kubernetes), Cassandra Kubernetes Operators-Cassandra Kubernetes Operators
• Kashlev Data Modeler, Cassandra Data Modeling Tools
• Keppman, Martin
  • Designing Data-Intensive Applications (O’Reilly), Transactions, ACID-ity, and Two-Phase Commit
• Kerberos authenticator, Additional authentication providers
• key cache, Caching, Key Cache
• key-based sharding, Sharding and Shared-Nothing Architecture
• key-value models, Representing other database models in CQL
• key-value pairs, Collections
• key-value stores, The Rise of NoSQL
• keys attribute, Key Cache
• keyspaces
  • Cassandra’s data model, Keyspaces
  • cluster sizing, Sizing Your Cluster
  • CqlSession, Connecting to a Cluster
  • creating, Creating a Keyspace and Table in cqlsh
  • defined, Keyspaces
  • repairing, Repair
  • replication strategies, Read Repair, Cluster Topology and Replication Strategies
  • services and, Services, Keyspaces, and Clusters
  • snapshots, Taking a Snapshot
  • statistics on, Getting Statistics
  • system, System Keyspaces-System Keyspaces
  • user-defined data types, User-Defined Types
  • virtual tables, Virtual Tables
• keystore, Node-to-Node Encryption-Node-to-Node Encryption
• key_cache_size_in_mb, Key Cache
• KillrVideo, Interactions Between Microservices
• Kubernetes (see K8s)

L

• Lakshman, Avinash, Where Did Cassandra Come From?
• Lamport, Leslie, Lightweight Transactions and Paxos
• $LANG environment variable, Textual Data Types
• LANGUAGE clause, User-defined functions
• Language Integrated Query (see LINQ)
• large deployments, using Cassandra for, Large Deployments
• last write wins approach, Timestamps
• LCS (LeveledCompactionStrategy), Compaction, Compaction
• lib directory, What’s in There?
• Lightweight Directory Access Prototol (see LDAP)
• lightweight transaction (see LWT)
• LIKE keyword, Secondary Indexes
• LIMIT keyword, Paging
• linearizable consistency, Lightweight Transactions and Paxos
• LINQ (Language Integrated Query), Other Cassandra Drivers
• Linux, Extracting the Download, Shenandoah Garbage Collector (JDK12)
• list data type, Collections-Collections
• LIST USERS command, Adding users
• load balancers, avoiding, Network
• load balancing
  • application design considerations, Data Centers and Load Balancing
  • DataStax Java Driver policy for, Load balancing
  • token-aware, The Cassandra Write Path
• LoadBalancingPolicy interface, Load balancing
• local coordinator node, The Cassandra Write Path
• locale, setting in cqlsh, Textual Data Types
• LOCAL_JMX setting, Securing JMX Access
• LOCAL_ONE consistency level, Write Consistency Levels, Read Consistency Levels
• LOCAL_QUORUM consistency level, Consistency Levels, Write Consistency Levels, Read Consistency Levels, Adding a Data Center to a Cluster
• LOCAL_SERIAL consistency level, Lightweight Transactions
• locking the database, disadvantage of, What’s Wrong with Relational Databases?
• Log4j, Startup and JVM Settings
• Logback, Driver logging, Startup and JVM Settings, Logging
• logback.xml file, What’s in There?, Logging
• logged batches, Batches
• logging
  • batchlog, Batches, Networking and Timeouts
  • commit logs, Memtables, SSTables, and Commit Logs-Memtables, SSTables, and Commit Logs, Writing, The Cassandra Write Path, Commit log files, Data Storage, Commit Logs
  • driver, Driver logging
  • monitoring Cassandra, Logging-Full Query Logging
  • security audit, Audit Logging
• logical data modeling, Logical Data Modeling-Reservation Logical Data Model
• login, Password Authenticator-Authenticating via the DataStax Java Driver
• LOGIN command, Adding users
• logs directory, Setting the Environment
• lookup tables, use in sharding, Sharding and Shared-Nothing Architecture
• LSM-Tree databases, Compaction
• LWT (lightweight transactions), Lightweight Transactions and Paxos, Lightweight Transactions-Lightweight Transactions, Maintaining Consistency
• LZ4 compression, Compression

M

• macOS
  • extracting the download, Extracting the Download
  • running ccm, Creating a Cluster
• mailing lists, Cassandra community, Getting Involved
• maintenance tasks, Maintenance-Cassandra Kubernetes Operators
  • adding nodes, Adding a Data Center to a Cluster
  • backup and recovery, Backup and Recovery-Restoring from Snapshot
  • common tasks, Common Maintenance Tasks-Best practices for repair
  • handling node failure, Handling Node Failure-Removing a data center
  • health check, Health Check
  • SSTable utilities, SSTable Utilities
  • tools for, Maintenance Tools-Cassandra Kubernetes Operators
  • upgrading Cassandra, Upgrading Cassandra-Upgrading Cassandra
• major compaction, Compaction
• Malik, Prashant, Where Did Cassandra Come From?
• managed beans (see MBeans)
• managed service, Cassandra as, Other Cassandra Distributions
• managers, Managers and Services
• manifest.json file, Taking a Snapshot
• manual repair, Anti-Entropy, Repair, and Merkle Trees
• map data type, Collections
• mapper, object, Object Mapper-Object Mapper
• master database (SQL Server), System Keyspaces
• materialized views
  • application design, Materialized Views-Materialized Views
  • restrictions included in, Translating Entities
  • server-side denormalization with, Denormalization
  • storage engine and, Storage Engine
  • system keyspaces, System Keyspaces
  • write path, The Cassandra Write Path
• Maven, Building from Source, Object Mapper
• max_hints_file_size_in_mb property, Hinted Handoff
• max_hint_window_in_ms property, Repairing Failed Nodes, Hinted Handoff
• MBeans, Cassandra’s MBeans-Metrics MBeans
  • cluster-related, Cluster-Related MBeans
  • database, Database MBeans-Cache Service MBean
  • internal, Internal MBeans
  • security, Security MBeans
• McCall, Nate, Where Did Cassandra Come From?
• MD5 cryptographic hash, Partitioners
• meetups, Cassandra community, Getting Involved
• memory, Health Check, Repair, Adding Nodes to an Existing Data Center, Key Cache, Memory
  • (see also caching)
• Memtable class, Memtables, SSTables, and Commit Logs
• MemtablePool, Memtables
• memtables
  • in Cassandra architecture, Memtables, SSTables, and Commit Logs-Memtables, SSTables, and Commit Logs
  • flushing, Flush, Memtables
  • LSM-Tree databases, Compaction
  • performance tuning, Memtables
  • reading data, The Cassandra Read Path
• memtable_allocation_type property, Memtables
• memtable_flush_period_in_ms, Memtables
• memtable_flush_writers, Memtables
• memtable_heap_space_in_mb, Memtables
• memtable_offheap_space_in_mb, Memtables
• Merkle trees, Anti-Entropy, Repair, and Merkle Trees, Repair
• Merkle, Ralph, Anti-Entropy, Repair, and Merkle Trees
• MessagingService class, Messaging Service, Messaging Service MBean
• metadata, System Keyspaces, Metadata, Full repair, incremental repair, and anti-compaction
• metrics, Driver metrics, Metrics MBeans, Metrics-Metrics, Commit Logs
• microservice architecture, Designing Applications with Cassandra-Interactions Between Microservices
  • bounded contexts, Identifying Bounded Contexts
  • characteristics, Cassandra and Microservice Architecture
  • deployment and integration, Deployment and Integration Considerations-Interactions Between Microservices
  • extending designs, Extending Designs-Materialized Views
  • Java microservice design example, Design Choices for a Java Microservice
  • persistence, designing, Designing Microservice Persistence-Representing other database models in CQL
  • services, Identifying Services
• Microsoft Azure, Microsoft Azure
• Microsoft SQL Server, meta-databases, System Keyspaces
• migrating Cassandra, Migrating and Integrating-Bulk Loading
• MIN and MAX functions, Built-in functions and aggregates
• Mission Control, Monitoring Cassandra with JMX
• monitoring Cassandra, Monitoring-Full Query Logging
  • DataStax Java Driver, Debugging and Monitoring
  • with JMX, Monitoring Cassandra with JMX-Monitoring Cassandra with JMX
  • logging, Logging-Full Query Logging
  • MBeans, Cassandra’s MBeans-Metrics MBeans
  • metrics, Metrics-Metrics
  • with nodetool, Monitoring with nodetool-Using tablestats
  • performance tuning, Monitoring Performance
  • virtual tables, Virtual Tables-System Views
• multicloud, Hybrid Cloud and Multicloud Deployment, Cluster Topology and Replication Strategies
• multimodel databases, The Rise of NoSQL
• Murmur3Partitioner, Partitioners, Partitioners
• MX4J (Management Extensions for Java), Monitoring Cassandra with JMX

N

• native transport, Network, Networking and Timeouts
• Neo4j, Brewer’s CAP Theorem
• nesting collections, User-Defined Types
• Netflix Priam, Netflix Priam
• network and networking
  • cloud deployment setups, Amazon Web Services, Microsoft Azure
  • creating for cluster deployment, Network
  • network interfaces, Network Interfaces
  • performance tuning, Networking and Timeouts
• Network Time Protocol (see NTP)
• network-attached storage (see NAS)
• NetworkTopologyStrategy class, Replication Strategies, Data Centers and Load Balancing, Read Repair, Snitches, Adding a Data Center to a Cluster
• Newman, Sam
  • Building Microservices (O’Reilly), Cassandra and Microservice Architecture
• NewSQL, The Rise of NoSQL
• node-to-node encryption, Node-to-Node Encryption-Node-to-Node Encryption
• Node.js, Application Development with Drivers, Other Cassandra Drivers
• NodeProbe class, Monitoring with nodetool
• nodes
  • adding, Running Cassandra in Docker-Running Cassandra in Docker, Adding Nodes to a Cluster, Adding a Data Center to a Cluster
  • batchlog, Batches
  • in Cassandra’s decentralized architecture, Distributed and Decentralized
  • configuring, Node Configuration-Startup and JVM Settings
  • coordinator nodes, Queries and Coordinator Nodes
  • data distribution, Rings and Tokens
  • deleting data and, Deleting
  • handling node failure, Handling Node Failure-Removing a data center
  • metadata discovery, Node discovery
  • reading data, Reading-The Cassandra Read Path
  • writing data, Write Consistency Levels-The Cassandra Write Path, Lightweight Transactions
• NodeStateListener interface, Node discovery
• nodetool assassinate command, Assassinating a node
• nodetool bootstrap command, Adding Nodes to an Existing Data Center
• nodetool bootstrap resume command, Adding Nodes to an Existing Data Center
• nodetool cleanup command, Cleanup
• nodetool clear snapshot command, Clearing a Snapshot
• nodetool compact command, Compaction
• nodetool compactionhistory command, Compaction
• nodetool compactionstats command, Compaction
• nodetool decommission command, Decommissioning a node
• nodetool describecluster command, describecluster
• nodetool disablebackup command, Enabling Incremental Backup
• nodetool drain command, Flush, Upgrading Cassandra
• nodetool enablebackup command, Enabling Incremental Backup
• nodetool flush command, SSTable files, Flush
• nodetool getcompactionthreshold command, Compaction
• nodetool getcompactionthroughput command, Compaction
• nodetool info command, info
• nodetool join command, Compaction
• nodetool listsnapshots command, Taking a Snapshot
• nodetool move command, Moving Tokens
• nodetool netstats command, Replacing Nodes
• nodetool proxyhistograms command, Monitoring Performance
• nodetool rebuild_index command, Rebuilding Indexes
• nodetool refresh command, Restoring from Snapshot
• nodetool reloadssl command, Client-to-Node Encryption
• nodetool removenode command, Assassinating a node
• nodetool repair command, Anti-Entropy, Repair, and Merkle Trees, Repair, Repair, Repairing Failed Nodes
• nodetool ring command, Adding Nodes to a Cluster, Storage Service MBean, ring, Subrange repair
• nodetool setcompactionthreshold command, Compaction
• nodetool setcompactionthroughput command, Compaction
• nodetool sethintedhandoff throttlekb command, Hinted Handoff
• nodetool settraceprobability command, Tracing
• nodetool snapshot command, Taking a Snapshot
• nodetool status command, Creating a Cluster, Storage Service MBean, status, Health Check, Decommissioning a node
• nodetool statusbackup command, Enabling Incremental Backup
• nodetool stop command, Compaction
• nodetool tablehistograms command, Monitoring Performance
• nodetool tablestats command, Using tablestats, Compaction
• nodetool tpstats command, Using tpstats, Health Check
• nodetool truncatehints command, Hinted Handoff
• nodetool upgradesstables command, Upgrading Cassandra
• nodetool, monitoring with, Monitoring with nodetool-Using tablestats, Metrics
• NoHostAvailableException, Connecting to a Cluster
• NoSpeculativeExecutionPolicy, Speculative execution
• NoSQL, The Rise of NoSQL-The Rise of NoSQL, Security
• NoSQLBench, Additional load testing tools
• now() function, Time and Identity Data Types
• NTP (Network Time Protocol), Network, Health Check
• numeric data types, Numeric Data Types
• num_tokens property, Virtual Nodes, Startup and JVM Settings

O

• object databases, The Rise of NoSQL
• object mappers, Object Mapper-Object Mapper
• object-relational mapping (ORM) frameworks (see ORM)
• objects, Schema, Schema, Default configuration (JDK 8 or JDK 11)
• ODBC (Open Database Connectivity), Other Cassandra Drivers
• OHCProvider class, Row Cache
• OldNetworkTopologyStrategy class, Replication Strategies
• ONE consistency level, Consistency Levels, Write Consistency Levels, Read Consistency Levels
• Open Database Connectivity (see ODBC)
• OpenJDK, Running Cassandra
• operating systems, Installing the Apache Distribution
  • (see also Windows systems)
  • extraction utilities, Extracting the Download
  • JVM settings, JVM Settings
  • running ccm, Creating a Cluster
  • setting the environment, Setting the Environment
  • storage file locations, Data Storage
  • updating configuration files, Upgrading Cassandra
  • ZGC, Z Garbage Collector (JDK 11 and later)
• OPP (order-preserving partitioning), Partitioners
• OpsCenter, DataStax OpsCenter
• Oracle Java Mission Control and Visual VM, Monitoring Cassandra with JMX
• Oracle JDK, Running Cassandra
• orchestration, Interactions Between Microservices
• ORDER BY clause, Sorting is a design decision, Range Queries, Ordering and Filtering
• ordering data, Range Queries, Ordering and Filtering
• OrderPreservingPartitioner, Partitioners
• org.apache.cassandra.concurrent package, Thread Pool MBeans
• org.apache.cassandra.db package, Storage Engine
• org.apache.cassandra.dht package, Partitioners
• org.apache.cassandra.internal domain, Thread Pool MBeans
• org.apache.cassandra.locator package, Snitches
• org.apache.cassandra.service.paxos package, Lightweight Transactions and Paxos
• org.apache.cassandra.transport package, CQL Native Transport Server
• ORM (object-relational mapping) frameworks, Schema
• overstreaming, Subrange repair

P

• PaaS (Platform-as-a-Service), What’s Wrong with Relational Databases?
• PAGING command, Paging
• paging, reading data, Paging-Paging
• parallel repair, Sequential and parallel repair
• parallel ssh tool, Taking a Snapshot
• partition index, The Cassandra Read Path
• partition keys, Cassandra’s Data Model, Breaking Up Large Partitions, Defining Database Schema, The Cassandra Read Path, Range Queries, Ordering and Filtering, Key Cache
• partition recovery, Brewer’s CAP Theorem
• partition summary, The Cassandra Read Path
• partition tolerance, Brewer’s CAP Theorem-Brewer’s CAP Theorem, Gossip and Failure Detection
• partitioner range repair, Partitioner range repair
• partitioners, Partitioners, Partitioners-Partitioners
• partitions
  • Cassandra’s data model, Row-Oriented, Cassandra’s Data Model
  • optimal storage design, Designing for optimal storage
  • Paxos state, Lightweight Transactions and Paxos
  • performance tuning, Analyzing Performance Issues
  • size calculation, Calculating Partition Size-Calculating Partition Size
  • splitting, Breaking Up Large Partitions
  • system keyspaces, System Keyspaces
• Partner Interconnect, Google Cloud Platform
• PasswordAuthenticator, Password Authenticator-Authenticating via the DataStax Java Driver
• passwords, Adding users
• patterns and anti-patterns, data modeling, Hotel Logical Data Model, Reservation Logical Data Model
• Paxos consensus algorithm, Lightweight Transactions and Paxos, System Keyspaces
• “Paxos Made Simple” (Lamport), Lightweight Transactions and Paxos
• performance tuning, Performance Tuning-Shenandoah Garbage Collector (JDK12)
  • caching, Caching-Saved Cache Settings
  • commit logs, Commit Logs
  • compaction, Compaction-Compaction
  • concurrency, Concurrency and Threading
  • hinted handoff, Hinted Handoff
  • JVM settings, JVM Settings-Shenandoah Garbage Collector (JDK12)
  • managing performance, Managing Performance-Tuning Methodology
  • memtables, Memtables
  • networking, Networking and Timeouts
  • SSTables, SSTables
  • threading, Concurrency and Threading
  • timeouts, Networking and Timeouts
• permissions, Using CassandraAuthorizer
• persistence, designing with microservice architecture, Designing Microservice Persistence
• Pfeil, Matt, Where Did Cassandra Come From?
• pgrep tool, Stopping Cassandra
• Phi Accrual Failure Detection, Gossip and Failure Detection, Snitches
• PHP, DataStax Ruby and, Other Cassandra Drivers
• physical data modeling, Physical Data Modeling-Reservation Physical Data Model
• pip (Python installer), Cassandra Cluster Manager
• PKCS12, Generating Certificates for Development Clusters
• PlainTextAuthProvider, Driver security
• Platform-as-a-Service (see PaaS)
• polyglot persistence, The Rise of NoSQL, Polyglot persistence
• PreparedStatement, DataStax Java Driver, Prepared Statements-Bound statement, Query Builder
• PreparedStatement.getId(), Prepared Statements
• Priam, Netflix Priam
• PRIMARY KEY clause, Materialized Views
• primary keys
  • Cassandra’s data model, Cassandra’s Data Model, Cassandra’s Data Model, Tables
  • collections as, User-Defined Types
  • creating a table, Creating a Keyspace and Table in cqlsh
  • importance of, Logical Data Modeling
  • inability to modify, Time and Identity Data Types
  • lightweight transactions, Lightweight Transactions, Maintaining Consistency
  • making unique, Hotel Logical Data Model
  • relational data model, The Relational Data Model
  • secondary index consideration, Translating Entities
• primary/secondary replication, Distributed and Decentralized
• production clusters, Generating Certificates for Production Clusters
• PropertyFileSnitch, Snitches, Replacing Nodes
• protocols
  • anti-entropy, Anti-Entropy, Repair, and Merkle Trees
  • Calvin transaction, The Rise of NoSQL
  • CQL Native Protocol, CQL Native Transport Server, Connection pooling, System Views
  • finding version, Starting the Server, Describing the Environment in cqlsh
  • gossip, Gossip and Failure Detection, System Keyspaces, Adding Nodes to a Cluster, Snitches, Handling Node Failure
  • NTP, Network, Health Check
  • Paxos, Lightweight Transactions and Paxos
  • SNMP, Monitoring Cassandra with JMX
• public key, SSL, TLS, and Certificates
• pylib directory, What’s in There?
• Python, Other Cassandra Drivers, Cassandra Cluster Manager, The spark-cassandra-connector

Q

• queries
  • building, Query Builder-Query Builder
  • coordinator nodes and, Queries and Coordinator Nodes
  • defining application queries, Defining Application Queries
  • full query logging, Full Query Logging
  • logical data model for, Hotel Logical Data Model-Reservation Logical Data Model
  • numbering for reference, Defining Application Queries
  • range queries, Range Queries, Ordering and Filtering-Range Queries, Ordering and Filtering
  • reconnection policies, Retrying failed queries
• query language shell (see CQL)
• query-first design, Query-first design
• QueryBuilder class, Query Builder-Query Builder, Deleting
• queue anti-pattern in data modeling, Reservation Logical Data Model
• QUORUM consistency level, Consistency Levels, Write Consistency Levels, Read Consistency Levels

R

• rack-aware snitches, Snitches
• RackInferringSnitch, Snitches
• racks, Data Centers and Racks, Snitches
• RandomPartitioner, Partitioners, Partitioners
• Ranganathan, Karthik, Where Did Cassandra Come From?
• Range class, Rings and Tokens
• ranges
  • partitioner, Partitioner range repair
  • queries, Range Queries, Ordering and Filtering-Range Queries, Ordering and Filtering
  • repairing, Partitioner range repair
  • searching over a range, Hotel Logical Data Model
  • token, Rings and Tokens, System Keyspaces, Subrange repair, Moving Tokens
• RBAC (role-based access control), Role-Based Access Control-Role-Based Access Control
• RDBMS (relational database management system)
  • differences from Cassandra, The Relational Data Model, Design Differences Between RDBMS and Cassandra-Sorting is a design decision
  • historical perspective, What’s Wrong with Relational Databases?
  • review of, A Quick Review of Relational Databases-Sharding and Shared-Nothing Architecture
  • scaling challenge for, Web Scale-The Rise of NoSQL
• reactive style programming, Asynchronous Execution
• read repair, Anti-Entropy, Repair, and Merkle Trees, Read Consistency Levels
• read-before-write semantics, Lightweight Transactions and Paxos
• reading data, Reading-Paging
  • Bloom filters, Memtables, SSTables, and Commit Logs, The Cassandra Read Path
  • caching for, Caching
  • Cassandra read path, The Cassandra Read Path-The Cassandra Read Path
  • consistency levels, Consistency Levels, Read Consistency Levels
  • coordinator nodes and queries, Queries and Coordinator Nodes
  • in cqlsh, Writing and Reading Data in cqlsh-Writing and Reading Data in cqlsh
  • paging, Paging-Paging
  • range queries, ordering and filtering, Range Queries, Ordering and Filtering-Range Queries, Ordering and Filtering
  • read repair, Read Repair-Read Repair
• reconnection policies, Retrying failed queries
• recovery, Backup and Recovery-Restoring from Snapshot
• refactoring data access, Refactoring Data Access
• referential integrity, Cassandra and, No referential integrity
• relational database management system (see RDBMS)
• relational databases, What’s Wrong with Relational Databases?-The Rise of NoSQL
  • differences from Cassandra, The Relational Data Model, Design Differences Between RDBMS and Cassandra-Sorting is a design decision
  • review of, A Quick Review of Relational Databases-Web Scale
  • shortcomings of, What’s Wrong with Relational Databases?-What’s Wrong with Relational Databases?
• “A Relational Model of Data for Large Shared Data Banks” (Codd), What’s Wrong with Relational Databases?
• relationships, translating for migration, Translating Relationships
• remote coordinator node, The Cassandra Write Path
• removing nodes, Removing Nodes, Removing a node
• repairs
  • anti-entropy protocol, Anti-Entropy, Repair, and Merkle Trees
  • common maintenance tasks, Repair-Best practices for repair
  • failed nodes, Repairing Failed Nodes
  • reading data, Read Repair-Read Repair
• replacing nodes, Replacing Nodes
• replica placement strategy (see replication strategies)
• replica synchronization, Anti-Entropy, Repair, and Merkle Trees
• replicas, Replication Strategies, Lightweight Transactions and Paxos, Read Consistency Levels, The Cassandra Read Path, Read Repair
• replication, Distributed and Decentralized, Tuneable Consistency-Tuneable Consistency, Read Repair
• replication factor
  • consistency levels and, Tuneable Consistency, Consistency Levels, Tracing, Role-Based Access Control
  • creating keyspaces, Creating a Keyspace and Table in cqlsh
  • defined, Replication Strategies
• replication strategies
  • in Cassandra architecture, Replication Strategies
  • cluster topology, Cluster Topology and Replication Strategies, Planning the Deployment
  • LocalStrategy, System Keyspaces
  • network authorization, Role-Based Access Control
  • setting up, Creating a Keyspace and Table in cqlsh
  • transient, Read Repair
• ReplicationAwareTokenAllocator class, Virtual Nodes
• request tracking, clients, Shenandoah Garbage Collector (JDK12)
• Reservation Service microservice example, Design Choices for a Java Microservice
• reservations (hotel example), Reservation Logical Data Model, Reservation Physical Data Model
• Resilient Distributed Dataset (see RDD)
• result sets, Simple Statements
• ResultSet data type, Simple Statements
• ResultSet.iterator() option, Simple Statements
• RetryDecision, Retrying failed queries
• RetryPolicy interface, Retrying failed queries
• rings, Rings and Tokens-Rings and Tokens, Dynamic Ring Participation
  • (see also clusters)
• role-based access control (see RBAC)
• rolling upgrade, Upgrading Cassandra
• RoundRobinPolicy, Load balancing
• row cache, Caching, Row Cache
• row-oriented databases, Row-Oriented
• rows
  • Cassandra’s data model, Row-Oriented, Cassandra’s Data Model-Cassandra’s Data Model, Tables-Tables
  • partition size calculation, Calculating Partition Size-Calculating Partition Size
  • TTL rules, Time to live (TTL)
• rows_per_partition, Row Cache
• row_cache_class_name property, Row Cache
• Ruby, DataStax Ruby driver, Other Cassandra Drivers
• running Cassandra, Running Cassandra-Stopping Cassandra

S

• S3 (Simple Storage Service), The Rise of NoSQL
• SASI (SSTable Attached Secondary Index), Secondary Indexes
• saved_caches property, Saved Cache Settings
• Scala, The spark-cassandra-connector
• scalability
  • challenge for RDBMS design, What’s Wrong with Relational Databases?, Web Scale-The Rise of NoSQL
  • elastic, Elastic Scalability, Where Did Cassandra Come From?
  • microservice architecture, Cassandra and Microservice Architecture
• Scalar DB, Interactions Between Microservices
• SchemaBuilder, Schema access
• SchemaChangeListener, Schema access
• schemas
  • Cassandra’s data model and, Row-Oriented
  • cluster information and, describecluster
  • defining database, Defining Database Schema-Cassandra Data Modeling Tools
  • lightweight transactions, Lightweight Transactions
  • Metadata class, DataStax Java Driver, Schema access
  • migration of, Migrating Data
  • relational database systems and, Schema
  • restoring after snapshots and backups, Restoring from Snapshot
  • system virtual schema, System Virtual Schema
• secondary indexes, application design, Secondary Indexes-Secondary Indexes, Rebuilding Indexes
• Secure Socket Layer (see SSL)
• security, Security-Audit Logging
  • audit logging, Audit Logging
  • authentication and authorization, Authentication and Authorization-Using CassandraAuthorizer
  • DataStax Java Driver, Driver security
  • encryption, Encryption-Client-to-Node Encryption
  • JMX security, Securing JMX Access-Securing JMX Access
  • MBeans, Security MBeans
• Security MBeans, Security MBeans
• seed nodes, Seed Nodes, Seed Nodes, Adding Nodes to an Existing Data Center, Adding a Data Center to a Cluster, Replacing Nodes
• SeedProvider interface, Seed Nodes
• SELECT command, Writing and Reading Data in cqlsh
  • options for, Range Queries, Ordering and Filtering-Range Queries, Ordering and Filtering
  • QueryBuilder, Query Builder
  • reading data, Tables
  • time to live (TTL), Time to live (TTL)
  • timestamps, Timestamps
• SELECT COUNT command, Writing and Reading Data in cqlsh
• SELECT JSON command, Representing other database models in CQL
• Select statement, QueryBuilder, Query Builder
• sequential consistency, Tuneable Consistency
• sequential repair, Sequential and parallel repair
• SERIAL consistency level, Lightweight Transactions
• SerializingCacheProvider, Row Cache
• server version, determining in cqlsh, Describing the Environment in cqlsh
• server-side denormalization, Denormalization
• servers, starting and stopping Cassandra, Starting the Server
• server_encryption_options, Node-to-Node Encryption
• services
  • ActiveRepairService, Repair
  • AWS, The Rise of NoSQL, Amazon Web Services-Amazon Web Services
  • CRUD services, Interactions Between Microservices
  • EmbeddedCassandraService, Cassandra Daemon
  • keyspaces and, Services, Keyspaces, and Clusters
  • messaging, Messaging Service, Messaging Service MBean
  • microservice architecture, Designing Applications with Cassandra-Interactions Between Microservices
  • S3, The Rise of NoSQL
  • storage, Lightweight Transactions and Paxos, Storage Service, Decommissioning a node
• session key, SSL, TLS, and Certificates
• sessions, Connecting to a Cluster-Statements
• set data type, Collections
• SGC (Shenandoah Garbage Collector), Shenandoah Garbage Collector (JDK12)
• sharding, Sharding and Shared-Nothing Architecture-Sharding and Shared-Nothing Architecture
• shared storage, Services, Keyspaces, and Clusters, Storage
• shared-nothing architecture, Sharding and Shared-Nothing Architecture-Sharding and Shared-Nothing Architecture
• Shenandoah Garbage Collector (see SGC)
• SHOW VERSION command, Describing the Environment in cqlsh
• Simple Logging Facade for Java (see SLF4J)
• Simple Network Monitoring Protocol (see SNMP)
• Simple Storage Service (see S3)
• SimpleSeedProvider class, Seed Nodes
• SimpleSnitch class, Snitches, Snitches
• SimpleStatement, DataStax Java Driver, Simple Statements, Prepared Statements
• SimpleStatement.newInstance() method, Simple Statements
• SimpleStrategy class, Replication Strategies, Cluster Topology and Replication Strategies
• single point of failure, avoiding, Distributed and Decentralized
• sizeOf() function, Calculating Size on Disk
• SizeTieredCompactionStrategy (see STCS)
• Slack chat, Cassandra community, Getting Involved
• SLF4J (Simple Logging Facade for Java), Driver logging, Logging
• slices, Range Queries, Ordering and Filtering
• smallint data type, Numeric Data Types
• snake case, Creating a Keyspace and Table in cqlsh
• SNAPPY compression, Compression
• snapshots, Column Family Store MBean, Taking a Snapshot-Restoring from Snapshot
• snapshot_before_compaction property, Taking a Snapshot
• snitches
  • adding a data center, Adding a Data Center to a Cluster
  • in Cassandra architecture, Snitches
  • configuring, Snitches-Snitches
  • creating a cluster, Creating a Cluster
  • MBean, Snitch MBeans
  • networking, Amazon Web Services, Google Cloud Platform
  • repair role of, Sequential and parallel repair
• SNMP (Simple Network Monitoring Protocol), Monitoring Cassandra with JMX
• soft deletes, Deletion and Tombstones
• Sorted String Table (see SSTables)
• sorting data, Range Queries, Ordering and Filtering
  • designing ahead, Logical Data Modeling
  • in RDBMS vs. Cassandra, Sorting is a design decision
• Spark, Bulk Loading, Analyzing Data with Apache Spark-The spark-cassandra-connector
• Spark DataFrame, The spark-cassandra-connector
• Spark RDD (Resilient Distributed Dataset), Analyzing Data with Apache Spark
• SpeculativeExecutionPolicy, Speculative execution
• SQL (Structured Query Language)
  • compared to CQL, Row-Oriented, The Relational Data Model
  • meta-database maintenance, System Keyspaces
  • support for and adoption of, A Quick Review of Relational Databases
• SSL (Secure Sockets Layer), SSL, TLS, and Certificates
• SSL certificates, Generating Certificates for Production Clusters
• SSLContext object, Node-to-Node Encryption
• SSLFactory class, Node-to-Node Encryption
• SSTable Attached Secondary Index (see SASI)
• sstableloader, Restoring from Snapshot
• sstablemetadata tool, Full repair, incremental repair, and anti-compaction
• SSTables
  • in Cassandra architecture, Memtables, SSTables, and Commit Logs
  • compaction of, Compaction
  • datafile and, Data Storage
  • deleting data, Deleting
  • flush and restore for backup, Restoring from Snapshot
  • MBean information, Column Family Store MBean
  • partition size and, Calculating Size on Disk
  • performance tuning, SSTables
  • reading data, The Cassandra Read Path
  • repairs, Full repair, incremental repair, and anti-compaction
  • streaming, Stream Manager
  • upgrading, Upgrading Cassandra
  • utilities, SSTable Utilities
  • writing files to disk, SSTable files-SSTable files
• sstableupgrade script, Upgrading Cassandra
• SSTableWriter interface, SSTable files
• “Starbucks Does Not Use Two-Phase Commit” (Hohpe), Transactions, ACID-ity, and Two-Phase Commit
• starting the server, Starting the Server-Starting the Server
• startup scripts, Startup and JVM Settings
• state function, User-defined aggregates
• stateful sets, Cassandra Kubernetes Operators
• statements, DataStax Java Driver, Statements-Bound statement
• static columns, Cassandra’s Data Model, Calculating Partition Size
• statistics, nodetool monitoring, Getting Statistics
• Statistics.db, SSTable component, SSTable files
• STCS (SizeTieredCompactionStrategy), Compaction, Sizing Your Cluster, Compaction, Compaction
• Stonebreaker, Michael
  • “The Case for Shared Nothing”, Sharding and Shared-Nothing Architecture
• stop-server command, Stopping Cassandra
• stopping Cassandra, Stopping Cassandra
• storage
  • Amazon EC2, Amazon Web Services
  • append-only storage model, Compaction
  • cluster deployment, Storage
  • commit log as, Commit Logs
  • data directory, Setting the Environment
  • designing for optimal, Designing for optimal storage
  • Kafka, Managing Data Flow with Apache Kafka
  • Kubernetes, Cassandra Kubernetes Operators
  • node configuration, Data Storage
  • shared vs. dedicated, Services, Keyspaces, and Clusters, Storage
• storage engine, Storage Engine
• StorageProxy class, Storage Proxy, CQL Native Transport Server
• StorageProxyMBean, Storage Proxy MBean
• StorageService class, Lightweight Transactions and Paxos, Storage Service, Decommissioning a node
• StorageServiceMBean, Storage Service MBean, Stream Manager MBean
• stored procedures, migrating, Migrating Stored Procedures-Built-in functions and aggregates
• stream processing system, Schema
• streaming, Stream Manager, Subrange repair
• StreamManager class, Stream Manager
• StreamManagerMBean, Stream Manager MBean
• stress testing, performance tuning, Using cassandra-stress-Using cassandra-stress
• stress-build target, Additional Build Targets
• strict consistency, Tuneable Consistency
• strings
  • creating a table, Creating a Keyspace and Table in cqlsh
  • enumerated types and, Numeric Data Types
• strong consistency, Consistency Levels, Interactions Between Microservices, Read Consistency Levels
• subrange repair, Subrange repair
• sum function, Built-in functions and aggregates
• Summary.db, SSTable component, SSTable files
• superuser, Using CassandraAuthorizer
• survivor space, Default configuration (JDK 8 or JDK 11)
• suspicion level, Gossip and Failure Detection, Gossip and Failure Detection
• system keyspaces, Describing the Environment in cqlsh, System Keyspaces-System Keyspaces, Sizing Your Cluster, Analyzing Performance Issues
• system.log file, Adding Nodes to a Cluster, Logging

T

• tables, Cassandra’s Data Model
  • (see also SSTables)
  • Bigtable, Cassandra in 50 Words or Less, Brewer’s CAP Theorem
  • Cassandra’s data model, Cassandra’s Data Model-Tables
  • creating in keyspace, Creating a Keyspace and Table in cqlsh
  • defined, Cassandra’s Data Model, Tables
  • freezing, User-Defined Types
  • lookup tables, use in sharding, Sharding and Shared-Nothing Architecture
  • memtables, Memtables, SSTables, and Commit Logs-Memtables, SSTables, and Commit Logs, Compaction, The Cassandra Read Path, Flush, Memtables
  • nesting, User-Defined Types
  • system.hints table removal, System Keyspaces
  • virtual tables for monitoring, Virtual Tables-System Views
• Tablesnap, Backup and Recovery
• tempdb (SQL Server), System Keyspaces
• test (build target), Additional Build Targets
• text data type, Textual Data Types, Hotel Physical Data Model
• textAsBlob() function, Other Simple Data Types
• textual data types, Textual Data Types
• thread pools, Thread Pool MBeans, Using tpstats, Concurrency and Threading
• threading
  • MBeans, Thread Pool MBeans
  • performance tuning, Concurrency and Threading
• THREE consistency level, Consistency Levels, Write Consistency Levels, Read Consistency Levels
• throttling, Hinted Handoff, Networking and Timeouts, Shenandoah Garbage Collector (JDK12)
• time data type, Time and Identity Data Types
• time series pattern, data modeling, Reservation Logical Data Model
• time to live (see TTL)
• timeouts, performance tuning, Networking and Timeouts
• timestamp data type, Time and Identity Data Types
• timestamps, Timestamps, Calculating Size on Disk
• timeuuid data type, Time and Identity Data Types, Collections
• TimeWindowCompactionStrategy (see TWCS)
• tinyint data type, Numeric Data Types
• TLS (Transport Layer Security), SSL, TLS, and Certificates
• TOC.txt, SSTable component, SSTable files
• token ranges, Rings and Tokens, System Keyspaces, Tokens and Virtual Nodes, Subrange repair
• token() function, Rings and Tokens
• token-generator tool, Partitioners
• TokenAwarePolicy, Load balancing
• tokens, Rings and Tokens-Rings and Tokens
  • adding nodes, Adding Nodes to an Existing Data Center
  • moving, Moving Tokens
  • node configuration, Tokens and Virtual Nodes
  • transient replication and, Read Repair
• tombstones, Deletion and Tombstones, Deleting
• tools directory, What’s in There?
• tracing, Tracing, Shenandoah Garbage Collector (JDK12)
• training and conferences, Getting Involved
• “The Transaction Concept: Virtues and Limitations” (Gray), Transactions, ACID-ity, and Two-Phase Commit
• transactions
  • lightweight, Lightweight Transactions and Paxos, Lightweight Transactions-Lightweight Transactions
  • RDBMS and SQL support for, Transactions, ACID-ity, and Two-Phase Commit-Transactions, ACID-ity, and Two-Phase Commit
  • system keyspaces, System Keyspaces
• transient replication, Read Repair
• Transport Layer Security (see TLS)
• transport server, CQL Native Transport Server
• triggers, system keyspaces, System Keyspaces
• TRUNCATE command, Writing and Reading Data in cqlsh
• truststore, Generating Certificates for Development Clusters, Client-to-Node Encryption
• TTL (time to live), Time to live (TTL)-Time to live (TTL), Deleting
• TTL() function, Time to live (TTL)
• tuneable consistency, Tuneable Consistency-Tuneable Consistency, Consistency Levels
• tuples, Tuples
• TWCS (TimeWindowCompactionStrategy), Compaction, Deleting, Compaction
• TWO consistency level, Consistency Levels, Write Consistency Levels, Read Consistency Levels
• two-phase commit (see 2PC)

U

• UDAs (user-defined aggregates), System Keyspaces, User-defined aggregates
• UDFs (user-defined functions), User-defined functions-User-defined functions
• UDTs (user-defined data types), User-Defined Types-User-Defined Types, Hotel Physical Data Model, Object Mapper
• universally unique identifiers (see UUIDs)
• Unix-based operating systems (Linux, macOS), Setting the Environment, Upgrading Cassandra, JVM Settings
• unixTimestampOf() function, Time and Identity Data Types
• unlogged batches, Batches
• UnreachableNodes attribute, Storage Service MBean
• UPDATE command, Tables, Timestamps, Lightweight Transactions
• upgrading Cassandra, Upgrading Cassandra-Upgrading Cassandra
• upsert, Tables
• users, Adding users
• USING TIMESTAMP option, Timestamps
• USING TTL option, Time to live (TTL)
• UTF-8 text standard, Textual Data Types
• uuid data type, Time and Identity Data Types, Hotel Physical Data Model, Reservation Physical Data Model
• uuid() function, Time and Identity Data Types
• UUIDs (universally unique identifiers), Time and Identity Data Types

V

• validating data migration, Bulk Loading
• validation compaction, Anti-Entropy, Repair, and Merkle Trees, Repair
• values (or cells), number in a partition, Calculating Partition Size
• varchar data type, Textual Data Types
• varint data type, Numeric Data Types
• versions
  • adding nodes, Adding Nodes to an Existing Data Center
  • adding users, Adding users
  • clearing out data directories when installing, Starting the Server
  • commit logs, Commit log files
  • finding those in use, Describing the Environment in cqlsh
  • Java 8 JVM, Running Cassandra
  • schemas, SSTable files, describecluster
  • SSL storage port, Node-to-Node Encryption
  • updating configuration files, Upgrading Cassandra
• vertical scaling, What’s Wrong with Relational Databases?, Elastic Scalability
• virtual machine images, Cassandra distributions, Other Cassandra Distributions
• virtual nodes (vnodes), Virtual Nodes, Tokens and Virtual Nodes
• virtual tables, monitoring Cassandra, Virtual Tables-System Views
• Visual VM, Monitoring Cassandra with JMX
• Vogels, Werner, Tuneable Consistency
• VPC (Virtual Private Cloud), Amazon Web Services

W

• WARN logging level, Logging, Shenandoah Garbage Collector (JDK12)
• weak (eventual) consistency, Tuneable Consistency-Tuneable Consistency
• web scale data solutions, Web Scale-The Rise of NoSQL
• WHERE clause, Materialized Views, Query Builder, Range Queries, Ordering and Filtering, Range Queries, Ordering and Filtering
• wide partition (row) pattern, data modeling, Hotel Logical Data Model
• wide-column store, The Rise of NoSQL, Cassandra’s Data Model
• Windows systems
  • extraction utility, Extracting the Download
  • JMX connection, Monitoring Cassandra with JMX
  • JVM settings, JVM Settings
  • setting the environment, Setting the Environment
  • stopping Cassandra on, Stopping Cassandra
  • storage file locations, Data Storage
• wrapping range, Rings and Tokens
• write survey mode, Compaction
• writetime() function, Timestamps
• writing data, Writing-Batches
  • in batches, Batches-Batches
  • Cassandra write path, The Cassandra Write Path-The Cassandra Write Path
  • Cassandra’s advantage in, Lots of Writes, Statistics, and Analysis, Memtables, SSTables, and Commit Logs
  • consistency levels, Consistency Levels, Write Consistency Levels-Write Consistency Levels
  • coordinator nodes and queries, Queries and Coordinator Nodes
  • in cqlsh, Writing and Reading Data in cqlsh-Writing and Reading Data in cqlsh
  • lightweight transactions, Lightweight Transactions-Lightweight Transactions

X

• XML databases, The Rise of NoSQL

Z

• zero-copy streaming, Stream Manager
• zero-downtime migration, Zero-Downtime Migration
• ZGC (Z Garbage Collector), Z Garbage Collector (JDK 11 and later)