ScyllaDB

https://docs.scylladb.com/stable/
Admin
ScyllaDB is a high-performance NoSQL database optimized for speed and scalability, designed for...
Tokens:6,415
Snippets:46
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Go Driver: ScyllaDB Setup and Connection

Source: https://context7.com/context7/scylladb-stable/llms.txt

Explains how to set up the ScyllaDB Go driver by modifying `go.mod` and tidying dependencies. It includes a code example demonstrating how to establish a connection with authentication.

```bash
# Add to go.mod
replace github.com/gocql/gocql => github.com/scylladb/gocql latest

# Install dependencies
go mod tidy
```

```go
import (
    "github.com/gocql/gocql"
    "github.com/scylladb/gocqlx/v2"
)

func main() {
    cluster := gocql.NewCluster("localhost")

    cluster.Authenticator = gocql.PasswordAuthenticator{
        Username: "scylla",
        Password: "your-awesome-password",
    }

    session, err := gocqlx.WrapSession(cluster.CreateSession())

    if err != nil {
        panic("Connection fail")
    }

    // Execute queries using the session
}
```

--------------------------------

### Install ScyllaDB on Linux

Source: https://context7.com/context7/scylladb-stable/llms.txt

Command to install ScyllaDB on Linux using the official web installer. This method installs the latest version of ScyllaDB Open Source and requires subsequent configuration.

```bash
# Install ScyllaDB using the web installer
curl -sSf get.scylladb.com/server | sudo bash

# This installs the latest official version of ScyllaDB Open Source
# Follow the post-installation instructions to configure and start the service
```

--------------------------------

### Run ScyllaDB in Docker

Source: https://context7.com/context7/scylladb-stable/llms.txt

Commands to start a ScyllaDB node using Docker, view logs, check cluster status with nodetool, and connect using cqlsh. Assumes Docker is installed and configured.

```bash
# Start a single ScyllaDB node in Docker
docker run --name scylla -d scylladb/scylla

# View node logs to monitor startup
docker logs -f scylla

# Check cluster status (UN = Up and Normal)
docker exec -it scylla nodetool status
# Output:
# Datacenter: datacenter1
# =======================
# Status=Up/Down
# |/ State=Normal/Leaving/Joining/Moving
# --  Address     Load       Tokens       Owns    Host ID                               Rack
# UN  172.17.0.2  632 KB     256          ?       8075882e-3b49-42a4-a742-4caf072844ff  rack1

# Connect to ScyllaDB using cqlsh
docker exec -it scylla cqlsh
# Output:
# Connected to  at 172.17.0.2:9042.
# [cqlsh 5.0.1 | Cassandra 3.0.8 | CQL spec 3.3.1 | Native protocol v4]
# Use HELP for help.
# cqlsh>
```

--------------------------------

### Install Go ScyllaDB Driver

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/install-drivers

Installs the ScyllaDB GoCQL client driver, serving as a drop-in replacement for `github.com/gocql/gocql`. It requires updating the `go.mod` file with a `replace` directive and then running `go mod tidy`.

```go
replace github.com/gocql/gocql => github.com/scylladb/gocql latest
```

```bash
go mod tidy
```

--------------------------------

### Install ScyllaDB using Web Installer Script

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/run-scylladb

Run this command to download and execute the ScyllaDB Web Installer script for Linux. It installs the latest official version of ScyllaDB Open Source by default. Ensure you have curl and sudo privileges.

```bash
curl -sSf get.scylladb.com/server | sudo bash

```

--------------------------------

### Java Driver: ScyllaDB Dependencies and Connection

Source: https://context7.com/context7/scylladb-stable/llms.txt

Outlines the Maven dependencies required for the ScyllaDB Java driver and provides a basic example of establishing a connection. It includes configuration for contact points and authentication.

```xml
<!-- Add to Maven pom.xml -->
<dependency>
  <groupId>com.scylladb</groupId>
  <artifactId>java-driver-core</artifactId>
  <version>${driver.version}</version>
</dependency>

<dependency>
  <groupId>com.scylladb</groupId>
  <artifactId>java-driver-query-builder</artifactId>
  <version>${driver.version}</version>
</dependency>

<dependency>
  <groupId>com.scylladb</groupId>
  <artifactId>java-driver-mapper-runtime</artifactId>
  <version>${driver.version}</version>
</dependency>
```

```java
import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.PlainTextAuthProvider;
import com.datastax.driver.core.Session;

class Main {
    public static void main(String[] args) {
        Cluster cluster = Cluster.builder()
            .addContactPoints("localhost")
            .withAuthProvider(new PlainTextAuthProvider("scylla", "your-awesome-password"))
            .build();

        Session session = cluster.connect();

        // Execute queries using the session
    }
}
```

--------------------------------

### Install Python ScyllaDB Driver

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/install-drivers

Installs the ScyllaDB Python client driver for CQL, which includes enhanced capabilities for ScyllaDB's architecture. `pip` is the recommended tool for installation, ensuring all Python dependencies are met.

```bash
pip install scylla-driver
```

--------------------------------

### ScyllaDB: Query-First Design for Scalable Data Partitioning

Source: https://context7.com/context7/scylladb-stable/llms.txt

Illustrates query-first data modeling in ScyllaDB to prevent unbounded partition growth. The 'BAD' example uses a `user_id` and `activity_date` that can lead to large partitions, while the 'GOOD' example uses a composite partition key `(user_id, activity_date)` for daily bucketing.

```cql
-- BAD: Unbounded partition growth over time
CREATE TABLE my_keyspace.user_activities_bad (
  user_id uuid,
  activity_date date,
  log_time timestamp,
  activity_details text,
  PRIMARY KEY (user_id, activity_date, log_time)
);
-- Problem: Active users accumulate unlimited data in single partition

-- GOOD: Bucketing by date to prevent unbounded growth
CREATE TABLE my_keyspace.user_activities_good (
  user_id uuid,
  activity_date date,
  log_time timestamp,
  log_message text,
  PRIMARY KEY ((user_id, activity_date), log_time)
);
-- Solution: Composite partition key bounds partitions to daily buckets
-- Efficient for queries like: "Get user X's activities on date Y"

```

--------------------------------

### Python Driver: ScyllaDB Connection

Source: https://context7.com/context7/scylladb-stable/llms.txt

Details how to install the ScyllaDB Python driver using pip and demonstrates establishing a connection to ScyllaDB. It includes configuration for contact points and authentication using PlainTextAuthProvider.

```bash
# Install Python driver with pip
pip install scylla-driver
```

```python
from cassandra.cluster import Cluster
from cassandra.auth import PlainTextAuthProvider

# Create cluster connection
cluster = Cluster(
    contact_points=["localhost"],
    auth_provider=PlainTextAuthProvider(
        username='scylla',
        password='your-awesome-password'
    )
)

# Establish session
session = cluster.connect()

# Execute queries
session.execute("SELECT * FROM my_keyspace.users")
```

--------------------------------

### Install Rust ScyllaDB Driver

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/install-drivers

Installs the ScyllaDB driver for Rust applications. This driver provides asynchronous, non-blocking access, leveraging Rust's performance and safety features. It's added as a dependency in the `Cargo.toml` file.

```rust
cargo add scylla
```

--------------------------------

### Install JavaScript ScyllaDB Driver

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/install-drivers

Installs the Cassandra driver for JavaScript applications to interact with ScyllaDB. `yarn` is the suggested package manager, though `npm` can also be used.

```bash
yarn install cassandra-driver
```

--------------------------------

### JavaScript/Node.js Driver: ScyllaDB Connection

Source: https://context7.com/context7/scylladb-stable/llms.txt

Details the installation of the ScyllaDB JavaScript/Node.js driver using npm or yarn. It provides a code snippet for establishing a connection to ScyllaDB, including configuration for contact points, data center, and credentials.

```bash
# Install using yarn
yarn install cassandra-driver

# Or using npm
npm install cassandra-driver
```

```javascript
const cassandra = require('cassandra-driver');

const cluster = new cassandra.Client({
    contactPoints: ["localhost"],
    localDataCenter: 'your-data-center',
    credentials: {
        username: 'scylla',
        password: 'your-awesome-password'
    },
    // keyspace: 'your_keyspace' // optional
});

// Connect and execute queries
cluster.connect()
    .then(() => console.log('Connected to ScyllaDB'))
    .catch(err => console.error('Connection error', err));
```

--------------------------------

### ScyllaDB: Avoid Hot Partitions with Proper Key Design

Source: https://context7.com/context7/scylladb-stable/llms.txt

Demonstrates how to avoid hot partitions in ScyllaDB by choosing appropriate partition keys. The 'BAD' example shows a single `user_id` leading to hot partitions, while the 'GOOD' example uses `message_id` for even data distribution.

```cql
-- BAD: Using only user_id as partition key leads to hot partitions
CREATE TABLE my_keyspace.messages_bad (
  user_id uuid,
  message_id uuid,
  message_text text,
  created_at timestamp,
  PRIMARY KEY (user_id, message_id)
);
-- Problem: Popular users create large, imbalanced partitions

-- GOOD: Using message_id distributes data evenly
CREATE TABLE my_keyspace.messages_good (
  message_id uuid PRIMARY KEY,
  user_id uuid,
  message_text text,
  created_at timestamp
);
-- Solution: Each message gets its own partition, ensuring even distribution

```

--------------------------------

### Insert Data into ScyllaDB

Source: https://context7.com/context7/scylladb-stable/llms.txt

CQL statements for inserting data into ScyllaDB tables. Includes a standard INSERT statement and an example using 'IF NOT EXISTS' for conditional insertion to prevent overwrites.

```cql
-- Insert a new user record
INSERT INTO my_keyspace.users (user_id, first_name, last_name, age)
  VALUES (123e4567-e89b-12d3-a456-426655440000, 'Polly', 'Partition', 77);

-- Note: INSERT creates the row if it doesn't exist, updates if it does
-- Use IF NOT EXISTS for conditional insertion to prevent overwrites
INSERT INTO my_keyspace.users (user_id, first_name, last_name, age)
  VALUES (123e4567-e89b-12d3-a456-426655440000, 'Polly', 'Partition', 77)
  IF NOT EXISTS;
```

--------------------------------

### ScyllaDB CREATE TABLE: Good Partition Key Example

Source: https://docs.scylladb.com/stable/get-started/data-modeling/best-practices

This SQL snippet illustrates an improved partition key selection for ScyllaDB. By choosing 'message_id' as the primary key, data is distributed more evenly across partitions, preventing hot spots even for users with many messages. This ensures better cluster utilization and performance.

```sql
CREATE TABLE my_keyspace.messages_good (
  message_id uuid PRIMARY KEY,
  user_id uuid,
  message_text text,
  created_at timestamp
);

```

--------------------------------

### Run Single Node ScyllaDB in Docker

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/run-scylladb

Execute this command to start a single ScyllaDB node in a Docker container. It pulls the ScyllaDB image and runs it in detached mode with the name 'scylla'. This is the simplest method for experimentation.

```bash
docker run --name scylla -d scylladb/scylla

```

--------------------------------

### Add Java ScyllaDB Driver Dependencies

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/install-drivers

Adds the necessary ScyllaDB driver core, query builder, and mapper runtime dependencies for Java applications. Maven is the suggested tool for managing these dependencies, with artifacts published in Maven Central.

```xml
<dependency>
  <groupId>com.scylladb</groupId>
  <artifactId>java-driver-core</artifactId>
  <version>${driver.version}</version>
</dependency>

<dependency>
  <groupId>com.scylladb</groupId>
  <artifactId>java-driver-query-builder</artifactId>
  <version>${driver.version}</version>
</dependency>

<dependency>
  <groupId>com.scylladb</groupId>
  <artifactId>java-driver-mapper-runtime</artifactId>
  <version>${driver.version}</version>
</dependency>
```

--------------------------------

### ScyllaDB CREATE INDEX

Source: https://docs.scylladb.com/stable/get-started/data-modeling/query-design

Example of creating a secondary index on the 'activity_date' column in a ScyllaDB table. This allows querying activities by date irrespective of the user, but it's important to consider the potential performance overhead.

```cql
CREATE INDEX ON my_keyspace.user_activities (activity_date);
```

--------------------------------

### ScyllaDB CREATE TABLE: Bad Partition Key Example

Source: https://docs.scylladb.com/stable/get-started/data-modeling/best-practices

This SQL snippet demonstrates a suboptimal partition key selection in ScyllaDB. Using 'user_id' as the partition key can lead to imbalanced data distribution and hot partitions, especially with users who have a large number of messages. This impacts overall cluster performance.

```sql
CREATE TABLE my_keyspace.messages_bad (
  user_id uuid,
  message_id uuid,
  message_text text,
  created_at timestamp,
  PRIMARY KEY (user_id, message_id)
);

```

--------------------------------

### ScyllaDB CQL: Updating and Deleting Data

Source: https://context7.com/context7/scylladb-stable/llms.txt

Demonstrates how to update existing records and delete specific records in ScyllaDB using CQL. It includes examples for simple updates/deletes and conditional operations using `IF EXISTS`. Caution is advised to always use a WHERE clause to prevent accidental mass deletions.

```cql
-- Update a specific column for an existing user
UPDATE my_keyspace.users SET age = 78
  WHERE user_id = 123e4567-e89b-12d3-a456-426655440000;

-- Conditional update using lightweight transactions
UPDATE my_keyspace.users SET age = 78
  WHERE user_id = 123e4567-e89b-12d3-a456-426655440000
  IF EXISTS;

-- Note: UPDATE creates the row if it doesn't exist unless IF EXISTS is used

-- Delete a specific user by partition key
DELETE FROM my_keyspace.users
  WHERE user_id = 123e4567-e89b-12d3-a456-426655440000;

-- Conditional deletion
DELETE FROM my_keyspace.users
  WHERE user_id = 123e4567-e89b-12d3-a456-426655440000
  IF EXISTS;

-- Always use WHERE clause to prevent accidental mass deletions
```

--------------------------------

### ScyllaDB CREATE TABLE (Bad Partitioning)

Source: https://docs.scylladb.com/stable/get-started/data-modeling/query-design

Example of a ScyllaDB table schema with potential for large partition sizes. 'user_id' as the partition key groups activities by user, and 'activity_date' as a clustering column orders them. This can lead to imbalanced clusters if a user has high activity.

```cql
CREATE TABLE my_keyspace.user_activities_bad (
  user_id uuid,
  activity_date date,
  log_time timestamp,
  activity_details text,
  PRIMARY KEY (user_id, activity_date, log_time)
);
```

--------------------------------

### Delete Specific Data with ScyllaDB DELETE Statement

Source: https://docs.scylladb.com/stable/get-started/query-data/delete-data

Demonstrates how to delete specific rows from a ScyllaDB table using the DELETE statement. It highlights the importance of the WHERE clause to target rows accurately and prevent unintended data loss. The example uses a UUID for identification.

```sql
DELETE FROM my_keyspace.users
  WHERE user_id = 123e4567-e89b-12d3-a456-426655440000;
```

--------------------------------

### Connect to ScyllaDB with Go

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/connect-apps

This Go code snippet shows how to connect to ScyllaDB using the `gocql` library. It sets up the cluster configuration with contact points and password authentication.

```go
func main() {
    cluster := gocql.NewCluster("localhost")

    cluster.Authenticator = gocql.PasswordAuthenticator{Username: "scylla", Password: "your-awesome-password"}

          session, err := gocqlx.WrapSession(cluster.CreateSession())

          if err != nil {
                    panic("Connection fail")
          }
 }
```

--------------------------------

### Create ScyllaDB Keyspace with NetworkTopologyStrategy

Source: https://docs.scylladb.com/stable/get-started/query-data/schema

Demonstrates how to create a keyspace in ScyllaDB using the NetworkTopologyStrategy for replication. This strategy allows for fine-grained control over data distribution in multi-datacenter environments.

```sql
CREATE KEYSPACE my_keyspace
  WITH replication = {
    'class': 'NetworkTopologyStrategy',
    'replication_factor': 3
  };
```

--------------------------------

### Rust Driver: ScyllaDB Connection

Source: https://context7.com/context7/scylladb-stable/llms.txt

Provides instructions for adding the ScyllaDB Rust driver to a project and demonstrates how to establish a connection to ScyllaDB. It includes configuration options such as specifying known nodes, connection timeouts, and authentication.

```bash
# Add ScyllaDB driver to Cargo.toml
cargo add scylla
```

```rust
use anyhow::Result;
use scylla::{Session, SessionBuilder};
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<()> {
    let session: Session = SessionBuilder::new()
        .known_nodes(&["localhost"])
        .connection_timeout(Duration::from_secs(30))
        .user("scylla", "your-awesome-password")
        .build()
        .await
        .unwrap();

    // Execute queries using the session
    Ok(())
}
```

--------------------------------

### Create ScyllaDB Table with Bucketing

Source: https://context7.com/context7/scylladb-stable/llms.txt

CQL statement for creating a ScyllaDB table ('user_activities_good') designed with bucketing to manage unbounded partition growth. It uses a composite partition key including a date.

```cql
-- Table design using bucketing to prevent unbounded partition growth
CREATE TABLE my_keyspace.user_activities_good (
  user_id uuid,
  activity_date date,
  log_time timestamp,
  log_message text,
  PRIMARY KEY ((user_id, activity_date), log_time)
);
-- Composite partition key (user_id, activity_date) ensures partitions
-- are bounded by date, preventing hot partitions from high-activity users
-- log_time is the clustering column for ordering within each partition
```

--------------------------------

### Connect to ScyllaDB with JavaScript

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/connect-apps

This JavaScript code snippet shows how to connect to ScyllaDB using a Node.js driver. It sets up the client with contact points, local data center, and credentials for authentication.

```javascript
const cluster = new cassandra.Client({
    contactPoints: ["localhost", ...],
    localDataCenter: 'your-data-center',
    credentials: {username: 'scylla', password: 'your-awesome-password'},
    // keyspace: 'your_keyspace' // optional
})
```

--------------------------------

### Create ScyllaDB Table with Proper Data Types

Source: https://context7.com/context7/scylladb-stable/llms.txt

CQL statement for creating an e-commerce products table in ScyllaDB, emphasizing the use of appropriate data types like 'decimal' for price and structuring the primary key for efficient querying.

```cql
-- E-commerce products table with appropriate data types
CREATE TABLE my_keyspace.products (
  seller_id uuid,
  product_id uuid,
  product_name text,
  price decimal,
  description text,
  PRIMARY KEY (seller_id, price, product_id)
);
-- Uses decimal for price to maintain precision for financial data
-- Partition by seller_id, cluster by price and product_id for efficient queries
```

--------------------------------

### Create ScyllaDB Tables with Primary Keys

Source: https://context7.com/context7/scylladb-stable/llms.txt

CQL statements to create tables in ScyllaDB. Demonstrates creating a table with a single-column primary key and another with a composite primary key (partition and clustering keys).

```cql
-- Simple table with single-column primary key
CREATE TABLE my_keyspace.users (
  user_id uuid PRIMARY KEY,
  first_name text,
  last_name text,
  age int
);

-- Table with composite primary key (partition key + clustering key)
CREATE TABLE my_keyspace.orders (
  order_id uuid,
  product_id uuid,
  quantity int,
  PRIMARY KEY (order_id, product_id)
);
-- order_id is the partition key (determines data distribution)
-- product_id is the clustering key (determines sorting within partition)
```

--------------------------------

### Connect to ScyllaDB with Python

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/connect-apps

This Python code snippet demonstrates connecting to ScyllaDB using the `cassandra-driver` library. It configures the cluster with contact points and plain text authentication.

```python
from cassandra.cluster import Cluster
from cassandra.auth import PlainTextAuthProvider
cluster = Cluster(
    contact_points=[
        "localhost",
    ],
    auth_provider=PlainTextAuthProvider(username='scylla', password='your-awesome-password')
)
```

--------------------------------

### Connect to ScyllaDB with Rust

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/connect-apps

This Rust code snippet demonstrates how to establish a connection to a ScyllaDB cluster using the `scylla` driver. It configures connection settings like known nodes, timeout, and authentication.

```rust
use anyhow::Result;
use scylla::{Session, SessionBuilder};
use std::time::Duration;
#[tokio::main]
async fn main() -> Result<()> {
    let session: Session = SessionBuilder::new()
        .known_nodes(&[
            "localhost",
        ])
        .connection_timeout(Duration::from_secs(30))
        .user("scylla", "your-awesome-password")
        .build()
        .await
        .unwrap();

    Ok(())
}
```

--------------------------------

### ScyllaDB CREATE TABLE (Good Partitioning with Bucketing)

Source: https://docs.scylladb.com/stable/get-started/data-modeling/query-design

An improved ScyllaDB table schema using 'bucketing' by combining 'user_id' and 'activity_date' as a composite partition key. This prevents unbounded partition growth and allows efficient range queries on 'log_time' within each bucket.

```cql
CREATE TABLE my_keyspace.user_activities_good (
  user_id uuid,
  activity_date date,
  log_time timestamp,
  log_message text,
  PRIMARY KEY ((user_id, activity_date), log_time)
);
```

--------------------------------

### Connect to ScyllaDB using cqlsh

Source: https://docs.scylladb.com/stable/get-started/query-data/cql

This command connects to a running ScyllaDB instance using the cqlsh command-line shell. cqlsh is used to interact with ScyllaDB through CQL commands. Ensure Docker is running and a ScyllaDB container named 'scylla' is active.

```shell
docker exec -it scylla cqlsh
```

--------------------------------

### Read Data from ScyllaDB

Source: https://context7.com/context7/scylladb-stable/llms.txt

CQL statements for reading data from ScyllaDB tables. Shows how to select all columns for a specific user and how to select specific columns with a WHERE clause, emphasizing the need for the partition key.

```cql
-- Select all columns for a specific user
SELECT * FROM my_keyspace.users
  WHERE user_id = 123e4567-e89b-12d3-a456-426655440000;

-- Select specific columns with filtering
SELECT first_name, last_name FROM my_keyspace.users
  WHERE user_id = 123e4567-e89b-12d3-a456-426655440000;

-- The WHERE clause must include the partition key for efficient queries
```

--------------------------------

### Connect to ScyllaDB with Java

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/connect-apps

This Java code snippet illustrates connecting to ScyllaDB using the DataStax Java Driver. It configures the cluster with contact points and basic authentication.

```java
import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.PlainTextAuthProvider;
import com.datastax.driver.core.Session;

class Main {

    public static void main(String[] args) {
    Cluster cluster = Cluster.builder()
        .addContactPoints("localhost")
        .withAuthProvider(new PlainTextAuthProvider("scylla", "your-awesome-password"))
        .build();

    Session session = cluster.connect();

    }
}
```

--------------------------------

### Create ScyllaDB Keyspace

Source: https://context7.com/context7/scylladb-stable/llms.txt

CQL statement to create a new keyspace named 'my_keyspace' using NetworkTopologyStrategy with a replication factor of 3. This ensures data redundancy across nodes.

```cql
-- Create a keyspace with NetworkTopologyStrategy replication
CREATE KEYSPACE my_keyspace
  WITH replication = {
    'class': 'NetworkTopologyStrategy',
    'replication_factor': 3
  };

-- The replication factor of 3 means each piece of data
-- will be replicated to three different nodes for fault tolerance
```

--------------------------------

### Create ScyllaDB Table with UUID and Text Columns

Source: https://docs.scylladb.com/stable/get-started/query-data/schema

Shows the SQL syntax for creating a table named 'users' within a specified keyspace. The table includes a UUID primary key and text/integer columns for user information.

```sql
CREATE TABLE my_keyspace.users (
  user_id uuid PRIMARY KEY,
  first_name text,
  last_name text,
  age int
);
```

--------------------------------

### Connect to ScyllaDB Docker Node with cqlsh

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/run-scylladb

Access your ScyllaDB node running in Docker using the CQL shell (cqlsh). This command executes cqlsh within the 'scylla' container, allowing you to interact with ScyllaDB using CQL queries.

```bash
docker exec -it scylla cqlsh

```

--------------------------------

### View ScyllaDB Docker Node Logs

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/run-scylladb

Use this command to view the real-time logs of your running ScyllaDB Docker container. This is essential for monitoring the node's status and troubleshooting any issues. The '-f' flag follows the log output.

```bash
docker logs -f scylla

```

--------------------------------

### ScyllaDB CQL: Creating Secondary Indexes

Source: https://context7.com/context7/scylladb-stable/llms.txt

Shows how to create a secondary index on a non-primary key column in ScyllaDB using CQL. This enables efficient querying on columns other than the primary key. It also highlights that secondary indexes add overhead and should be used judiciously.

```cql
-- Create a secondary index on a non-primary key column
CREATE INDEX ON my_keyspace.user_activities (activity_date);

-- This allows querying by activity_date regardless of user_id
-- However, secondary indexes add overhead and should be used judiciously
SELECT * FROM my_keyspace.user_activities
  WHERE activity_date = '2025-10-12';
```

--------------------------------

### Create ScyllaDB Table with Composite Primary Key

Source: https://docs.scylladb.com/stable/get-started/query-data/schema

Illustrates creating a ScyllaDB table with a composite primary key, consisting of a partition key ('order_id') and a clustering key ('product_id'). This defines data distribution and internal sorting within partitions.

```sql
CREATE TABLE my_keyspace.orders (
  order_id uuid,
  product_id uuid,
  quantity int,
  PRIMARY KEY (order_id, product_id)
);
```

--------------------------------

### ScyllaDB: Insert Data into a Table

Source: https://docs.scylladb.com/stable/get-started/query-data/insert-data

Demonstrates the basic `INSERT INTO` statement in ScyllaDB for adding a new row to a table. It specifies the keyspace, table, column names, and their corresponding values. The data types, such as `uuid`, `text`, and `int`, are handled appropriately.

```sql
INSERT INTO my_keyspace.users (user_id, first_name, last_name, age)
  VALUES (123e4567-e89b-12d3-a456-426655440000, 'Polly', 'Partition', 77);
```

--------------------------------

### Check ScyllaDB Docker Node Status

Source: https://docs.scylladb.com/stable/get-started/develop-with-scylladb/run-scylladb

Verify the operational status of your ScyllaDB node running in Docker. This command connects to the container and runs the 'nodetool status' command, showing if the node is up and its state.

```bash
docker exec -it scylla nodetool status

```

--------------------------------

### Create ScyllaDB Table with Decimal Price

Source: https://docs.scylladb.com/stable/get-started/data-modeling/schema-design

This snippet demonstrates how to create a ScyllaDB table named 'products' within 'my_keyspace'. It includes columns for seller ID, product ID, product name, price, and description. The `price` column is defined as a `decimal` data type, suitable for financial data requiring precise representation. The primary key is composite, including `seller_id`, `price`, and `product_id` for efficient querying and sorting.

```sql
CREATE TABLE my_keyspace.products (
  seller_id uuid,
  product_id uuid,
  product_name text,
  price decimal,
  description text,
  PRIMARY KEY (seller_id, price, product_id)
);
```

--------------------------------

### Read Data using SELECT Statement with WHERE Clause

Source: https://docs.scylladb.com/stable/get-started/query-data/read-data

This code snippet demonstrates how to read data from a ScyllaDB table using the SELECT statement. It includes specifying the keyspace and table, selecting all columns with the wildcard (*), and applying a restriction using the WHERE clause with a UUID. This is a fundamental operation for querying data in ScyllaDB.

```cql
SELECT * FROM my_keyspace.users
  WHERE user_id = 123e4567-e89b-12d3-a456-426655440000;
```

--------------------------------

### ScyllaDB UPDATE Statement for Data Modification

Source: https://docs.scylladb.com/stable/get-started/query-data/update-data

This snippet demonstrates the basic syntax for updating data in a ScyllaDB table using the UPDATE statement. It requires specifying the keyspace, table, columns to update with their new values, and a WHERE clause to identify the target row(s).

```cql
UPDATE my_keyspace.users SET age = 78
  WHERE user_id = 123e4567-e89b-12d3-a456-426655440000;
```
Tokens:
Raw