Introduction#

Overview#

RonDB CLI (rondb-cli) is a unified command-line interface for RonDB, a distributed in-memory database that combines Redis-compatible operations with full MySQL SQL support. The CLI provides seamless interaction with four distinct client interfaces through a single interactive shell:

MySQL -- Full SQL support for queries, schema management, and data manipulation
REST API -- High-performance primary key lookups using a DSL that generates JSON requests to RDRS (RonDB Data REST Server)
RonSQL -- Aggregation queries (COUNT, SUM, AVG, MIN, MAX) executed via the REST API
Rondis -- Redis-compatible commands for key-value operations

Version Compatibility#

The rondb-cli source code is included in the RonDB source tree starting from RonDB 25.10. However, most functionality works with older RonDB versions:

Table: RonDB Version Compatibility

Interface	Minimum RonDB Version
MySQL	Any version
REST API	22.10
Rondis	24.10
RonSQL	24.10

Design Philosophy#

The RonDB CLI follows a “3-minute win” philosophy:

Connect -- Establish connections to RonDB services quickly
Diagnose -- Identify issues and understand system state
Decide -- Take action based on gathered information

Core principles:

One CLI, no ceremony -- Simple, unified interface
Four interfaces, one shell -- MySQL, RonSQL, REST API, and Rondis
Reliability -- Robust error handling and connection management
Clarity -- Clear output formatting and helpful messages
Speed -- Optimized for low latency operations
Composability -- Commands can be combined and scripted

Key Features#

Unified shell supporting Rondis (Redis), MySQL, RonSQL, and REST API
Automatic command routing based on syntax detection
Interactive TUI database browser
Comprehensive benchmarking suite with latency statistics
Multi-line command support
TLS encryption support
Environment variable and command-line configuration
Color-coded output with timing information

Installation and Setup#

Prerequisites#

Go 1.24.0 or later
Access to a RonDB cluster with:
- Rondis service (default port: 6379)
- MySQL service (default port: 3306)
- RDRS/REST API service (default port: 4406)

Building from Source#

# Navigate to the rondb-cli directory
cd tools/rondb-cli

# Build the binary
go build -o rondb .

# Verify the build
./rondb version

Quick Start#

# Connect to local RonDB with defaults
./rondb

# Connect to remote host
./rondb --host myrondb.example.com

# Connect with MySQL authentication
./rondb --host myrondb.example.com --mysql-user admin -p

# Connect with TLS enabled
./rondb --host myrondb.example.com --tls

Configuration#

Command-Line Flags#

Table: Command-Line Flags

Flag	Default	Description
--host	localhost	General host for all services
--mysql-host	(inherits)	MySQL host (overrides --host)
--rdrs-host	(inherits)	REST API host (overrides --host)
--rondis-port	6379	Rondis service port
--mysql-port	3306	MySQL service port
--rdrs-port	4406	REST API service port
--mysql-user	root	MySQL username
--mysql-password	(empty)	MySQL password
-p, --password	false	Prompt for MySQL password
--tls	false	Enable TLS for all connections
--rdrs-tls	false	Enable TLS for REST API only
--rdrs-api-key	(empty)	API key for REST API authentication
--verbose	0	Verbose level
--no-mysql	false	Disable MySQL connection
--no-rdrs	false	Disable REST API connection
--no-rondis	false	Disable Rondis connection

Environment Variables#

Environment variables provide an alternative configuration method. Command-line flags take precedence over environment variables.

Table: Environment Variables

Variable	Description
RONDB_HOST	RonDB host (sets all service hosts)
MYSQL_HOST	MySQL host (overrides RONDB_HOST)
RDRS_HOST	REST API host (overrides RONDB_HOST)
RONDB_RONDIS_PORT	Rondis service port
RONDB_MYSQL_PORT	MySQL service port
RONDB_RDRS_PORT	REST API service port
RONDB_MYSQL_USER	MySQL username
RONDB_MYSQL_PASSWORD	MySQL password
RONDB_RDRS_API_KEY	REST API authentication key

Configuration Precedence#

Configuration values are resolved in the following order (highest to lowest priority):

Command-line flags
Environment variables
Default values

Client Interfaces#

RonDB CLI supports four distinct client interfaces, each optimized for different access patterns.

MySQL (SQL Interface)#

The MySQL interface provides full SQL query support. SQL commands are detected by keywords such as SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, etc.

Supported Operations#

# Data queries
SELECT * FROM users WHERE id = 1;
SELECT name, email FROM users LIMIT 10;

# Data modification
INSERT INTO users (name, email) VALUES ('John', 'john@example.com');
UPDATE users SET name = 'Jane' WHERE id = 1;
DELETE FROM users WHERE id = 1;

# Schema operations
CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100),
    email VARCHAR(255)
) ENGINE=NDB;
DROP TABLE users;
ALTER TABLE users ADD COLUMN phone VARCHAR(20);

# Database operations
USE mydb;
CREATE DATABASE IF NOT EXISTS mydb;
SHOW DATABASES;
SHOW TABLES;
DESCRIBE users;
EXPLAIN SELECT * FROM users;

Multi-line SQL#

SQL statements can span multiple lines. The shell detects incomplete statements and provides a continuation prompt:

rondb> SELECT
    ...>   id,
    ...>   name,
    ...>   email
    ...> FROM users
    ...> WHERE active = 1
    ...> ORDER BY name;

Forcing MySQL Routing#

Use the MYSQL prefix to force command routing through MySQL:

rondb> MYSQL SHOW PROCESSLIST;

REST API (DSL Interface)#

The REST API interface uses a Domain-Specific Language (DSL) for primary key read operations.

Single READ Syntax#

READ database.table [col1, col2, ...] FILTER pk1=value1, pk2=value2;

# Read all columns
READ mydb.users FILTER user_id=1001;

# Read specific columns
READ mydb.users id, name, email FILTER user_id=1001;

# Composite primary key
READ mydb.order_items FILTER order_id=100, item_id=1;

# String filter value
READ mydb.products FILTER sku="ABC-123";

Example with request/response:

rondb> READ mydb.users id, name, email FILTER user_id=1001;

Request:
{
  "filters": [
    {"column": "user_id", "value": 1001}
  ],
  "readColumns": [
    {"column": "id", "dataReturnType": "default"},
    {"column": "name", "dataReturnType": "default"},
    {"column": "email", "dataReturnType": "default"}
  ]
}

Response:
{
  "data": {
    "id": 1001,
    "name": "John Doe",
    "email": "john@example.com"
  }
}
(12.3ms)

BATCH Syntax#

For multiple operations in a single request:

# Syntax 1: Full READ per operation
BATCH
  READ mydb.users id, name FILTER user_id=1 OP 1
  READ mydb.users id, name FILTER user_id=2 OP 2
;

# Syntax 2: Shared header with multiple READs
BATCH mydb.users: id, name
  READ FILTER user_id=1
  READ FILTER user_id=2
;

# Batch with two filter columns (composite primary key)
BATCH READ mydb.items qty, price FILTER order_id=1, item_id=1 OP i1 READ mydb.items qty, price FILTER order_id=1, item_id=2 OP i2;

Example with request/response:

rondb> BATCH
    ...>   READ mydb.users id, name FILTER user_id=1 OP 1
    ...>   READ mydb.users id, name FILTER user_id=2 OP 2
    ...> ;

Request:
{
  "operations": [
    {
      "method": "POST",
      "relative-url": "mydb/users/pk-read",
      "body": {
        "filters": [{"column": "user_id", "value": 1}],
        "readColumns": [
          {"column": "id", "dataReturnType": "default"},
          {"column": "name", "dataReturnType": "default"}
        ],
        "operationId": "1"
      }
    },
    {
      "method": "POST",
      "relative-url": "mydb/users/pk-read",
      "body": {
        "filters": [{"column": "user_id", "value": 2}],
        "readColumns": [
          {"column": "id", "dataReturnType": "default"},
          {"column": "name", "dataReturnType": "default"}
        ],
        "operationId": "2"
      }
    }
  ]
}

Response:
{
  "result": [
    {"operationId": "1", "data": {"id": 1, "name": "Alice"}},
    {"operationId": "2", "data": {"id": 2, "name": "Bob"}}
  ]
}
(15.7ms)

RonSQL (REST API SQL)#

RonSQL executes aggregation queries through the RDRS REST API, providing high-performance SQL access without MySQL overhead. Currently, RonSQL supports aggregation queries on a single table only.

Supported Queries#

RonSQL supports aggregation functions on a single table:

# Count rows
RONSQL SELECT COUNT(*) FROM mydb.orders;

# Sum values
RONSQL SELECT SUM(amount) FROM mydb.orders;

# Average, min, max
RONSQL SELECT AVG(price), MIN(price), MAX(price) FROM mydb.products;

# Count with GROUP BY
RONSQL SELECT status, COUNT(*) FROM mydb.orders GROUP BY status;

# Aggregation with WHERE clause
RONSQL SELECT SUM(quantity) FROM mydb.order_items WHERE product_id = 100;

# Multiple aggregations
RONSQL SELECT COUNT(*), SUM(amount), AVG(amount) FROM mydb.transactions;

Example:

rondb> RONSQL SELECT status, COUNT(*) FROM mydb.orders GROUP BY status;

Request:
{
  "database": "mydb",
  "query": "SELECT status, COUNT(*) FROM orders GROUP BY status",
  "format": "JSON",
  "explain": "ALLOW"
}

Response:
{
  "data": [
    {"status": "pending", "COUNT(*)": 42},
    {"status": "shipped", "COUNT(*)": 156},
    {"status": "delivered", "COUNT(*)": 892}
  ]
}
(8.5ms)

Commands#

# Set default database context
RONSQL SET DATABASE mydb;

# After setting database, table names don't need qualification
RONSQL SELECT COUNT(*) FROM orders;
RONSQL SELECT SUM(amount), AVG(amount) FROM transactions;

Configuration#

RonSQL behavior can be configured using internal commands:

# Show/set database context
.ronsql_database [database_name]

# Show/set output format
# Options: JSON, JSON_ASCII, TEXT, TEXT_NOHEADER
.ronsql_format [format]

# Show/set explain mode
# Options: ALLOW, FORBID, REQUIRE, REMOVE, FORCE
.ronsql_explain [mode]

Limitations#

Only single-table queries are supported (no JOINs)
Only aggregation queries (COUNT, SUM, AVG, MIN, MAX)
For general SQL queries, use the MySQL interface instead

Rondis (Redis Protocol)#

Rondis provides Redis-compatible commands for key-value operations. Commands are automatically detected by keyword matching.

Supported Commands#

# String operations
SET key value              # Store a string value
GET key                    # Retrieve a string value
DEL key [key ...]          # Delete one or more keys
MGET key [key ...]         # Get multiple values

# Numeric operations
INCR key                   # Increment integer value
DECR key                   # Decrement integer value
INCRBY key increment       # Increment by specified amount
DECRBY key decrement       # Decrement by specified amount

# Hash operations
HSET hash field value      # Set hash field
HGET hash field            # Get hash field value
HDEL hash field [field...] # Delete hash fields
HGETALL hash               # Get all fields and values

# Key operations
KEYS pattern               # Find keys matching pattern
EXISTS key [key ...]       # Check if keys exist
TTL key                    # Get time to live
EXPIRE key seconds         # Set expiration time

# Other
PING                       # Test connection

Example Session#

rondb> SET user:1001 "John Doe"
OK (0.8ms)

rondb> GET user:1001
"John Doe" (0.5ms)

rondb> HSET user:1001:profile name "John" email "john@example.com"
(integer) 2 (1.2ms)

rondb> HGETALL user:1001:profile
1) "name"
2) "John"
3) "email"
4) "john@example.com"
(0.7ms)

Internal Commands#

Internal commands are prefixed with a dot (.) and provide shell configuration and utility functions.

Help and Information#

Table: Help Commands

Command	Description
.help	Display general help information
.help internal	Display benchmark and internal commands
.help start	Display connection flags and environment variables
.tables	List all tables in accessible databases

Table: Navigation Commands

Command	Description
.browse	Open TUI database browser
.ui	Alias for .browse
.demo	Run interactive demonstration

Configuration Commands#

Table: Configuration Commands

Command	Description
.client [N]	Set or display client ID for benchmarks
.debug [0\|1]	Toggle debug mode
.verbose [0\|1\|2]	Set verbose level
.ronsql_database [db]	Set RonSQL database context
.ronsql_format [fmt]	Set RonSQL output format
.ronsql_explain [mode]	Set RonSQL explain mode

Exit Commands#

quit    # Exit the shell
exit    # Exit the shell
q       # Exit the shell (shorthand)

Benchmarking#

RonDB CLI includes a comprehensive benchmarking suite for performance testing.

Benchmark Parameters#

All benchmark commands accept common parameters:

Table: Benchmark Parameters

Parameter	Default	Description
T (threads)	2	Number of concurrent threads
N (ops)	1000	Number of operations per thread
R (rows)	1	Rows per operation
W (write%)	0	Write percentage (0-100)
S (seconds)	60	Duration for continuous benchmarks

Rondis Benchmarks#

Data Loading#

# Load test data
.load_rondis [T] [N] [R]

# Example: 4 threads, 5000 ops, 10 rows each = 200,000 keys
rondb> .load_rondis 4 5000 10

Performance Testing#

# Run benchmark (T threads, N ops, R rows, W% writes)
.bench_rondis [T] [N] [R] [W]

# Run continuous benchmark for S seconds
.bench_rondis_cont [T] [N] [R] [W] [S]

# Example: 4 threads, 10000 ops, 1 row, 20% writes
rondb> .bench_rondis 4 10000 1 20

Data Cleanup#

# Delete test data (must match load parameters)
.del_rondis [T] [N] [R]

rondb> .del_rondis 4 5000 10

SQL Benchmarks#

SQL benchmarks use the test.sql_test table with the following schema:

CREATE TABLE test.sql_test (
    user_id VARCHAR(64) NOT NULL,
    event_time BIGINT NOT NULL,
    description VARCHAR(128),
    value_int BIGINT DEFAULT 0,
    event_type BIGINT DEFAULT 0,
    PRIMARY KEY (user_id, event_time)
) ENGINE=NDB;

The table is automatically created by the .load_sql command if it does not exist.

Data Loading#

# Load test data into test.sql_test table
.load_sql [T] [N] [R]

rondb> .load_sql 4 5000 10

Performance Testing#

# Run SELECT/UPDATE benchmark
.bench_sql [T] [N] [R] [W]

# Run continuous benchmark
.bench_sql_cont [T] [N] [R] [W] [S]

# Run scan-based benchmark (no writes)
.bench_sql_scan [T] [N] [R]

# Run continuous scan benchmark
.bench_sql_scan_cont [T] [N] [R] [S]

Data Cleanup#

# Delete test data
.del_sql [T] [N] [R]

# Drop the test table entirely
.drop_sql

REST API Benchmarks#

# Run batch pk-read benchmark
.bench_rdrs [T] [N] [R]

# Run continuous benchmark
.bench_rdrs_cont [T] [N] [R] [S]

# Note: Uses data from .load_sql

Benchmark Output#

Benchmarks report comprehensive statistics:

SQL Benchmark complete!
   Configuration: 4 threads x 10000 requests x 1 rows = 40000 total
   Reads: 32000 (80.0%), Writes: 8000 (20.0%)
   Throughput: 45230 ops/sec (12.5ms total)
   Latency: min=0.1ms avg=0.9ms max=15.2ms p95=2.1ms p99=4.5ms p99.9=12.3ms

Errors encountered (3 total):
   1. connection refused
   2. timeout after 30s
   3. duplicate key error

Error Collection#

Benchmarks collect up to 100 unique errors and display them after completion. This helps identify:

Connection issues
Timeout problems
Data consistency errors
Resource exhaustion

TUI Database Browser#

The TUI (Terminal User Interface) browser provides interactive database exploration.

Launching the Browser#

rondb> .browse
# or
rondb> .ui

Interface Layout#

The browser displays a two-panel interface:

+---------------------------+--------------------------------+
|  Databases                |  Schema: mydb.users            |
|  ------------------------ |  ------------------------------ |
|  > mydb                   |  Column     Type      Null Key |
|      users                |  id         INT       NO   PRI |
|      orders               |  name       VARCHAR   YES      |
|    ndb_binlog_index       |  email      VARCHAR   YES      |
|  > test                   |  created_at DATETIME  YES      |
|      sql_test             |                                |
+---------------------------+--------------------------------+

Table: TUI Keyboard Shortcuts

Key	Action
j / Down	Move cursor down
k / Up	Move cursor up
h / Left	Collapse database
l / Right	Expand database
Enter / Space	Select table (show schema)
Tab	Toggle focus between panels
d	Toggle schema/data view
q / Esc	Quit browser
Ctrl+C	Quit browser

Views#

Schema View#

Displays table column information:

Column name
Data type
Nullable status
Key type (PRI, UNI, MUL)
Default value

Data View#

Displays sample rows from the selected table (limited to prevent overwhelming the display).

Toggle between views using the d key.

Architecture#

Project Structure#

rondb-cli/
├── main.go                 # Entry point
├── cmd/
│   └── root.go             # Cobra CLI commands
├── internal/
│   ├── client/
│   │   ├── mysql.go        # MySQL client wrapper
│   │   ├── rondis.go       # Rondis client wrapper
│   │   └── rest.go         # REST API client
│   ├── dsl/
│   │   └── parser.go       # DSL parser for READ/BATCH
│   ├── shell/
│   │   └── repl.go         # Interactive REPL
│   ├── tui/
│   │   └── browser.go      # Database browser
│   └── ui/
│       ├── colors.go       # Terminal styling
│       └── table.go        # Table formatting
├── docs/
│   └── PHILOSOPHY.md       # Design principles
└── go.mod                  # Dependencies

Client Architecture#

MySQLClient#

type MySQLClient struct {
    db *sql.DB
}

type MySQLOptions struct {
    Host     string
    Port     int
    User     string
    Password string
    TLS      bool
}

Key methods:

Query(sql string) -- Execute SELECT queries
Execute(sql string) -- Execute INSERT/UPDATE/DELETE
ListDatabases() -- Get database list
ListTablesInDB(database string) -- Get tables
DescribeTable(database, table string) -- Get schema

RondisClient#

type RondisClient struct {
    client *redis.Client
}

type RondisOptions struct {
    Host     string
    Port     int
    Password string
    TLS      bool
}

Key methods:

Execute(args []string) -- Execute any Redis command
Ping() -- Test connection

RestClient#

type RestClient struct {
    client  *http.Client
    baseURL string
    apiKey  string
}

type RestOptions struct {
    Host   string
    Port   int
    TLS    bool
    APIKey string
}

Key methods:

Post(endpoint string, body interface) -- Send POST request
Ping() -- Test connection

Command Routing#

Commands are routed based on keyword detection:

func (s *Shell) execute(line string) error {
    lower := strings.ToLower(line)

    // 1. Internal commands (dot prefix)
    if strings.HasPrefix(lower, ".") {
        return s.executeInternal(line)
    }

    // 2. SQL commands (keyword detection)
    if isSQLCommand(lower) {
        return s.executeSQL(line)
    }

    // 3. RonSQL commands
    if strings.HasPrefix(lower, "ronsql ") {
        return s.executeRonSQL(line)
    }

    // 4. REST API READ commands
    if strings.HasPrefix(lower, "read ") {
        return s.executeREAD(line)
    }

    // 5. REST API BATCH commands
    if strings.HasPrefix(lower, "batch") {
        return s.executeBatch()
    }

    // 6. Default: Rondis
    return s.executeRondis(line)
}

Latency Collection#

Thread-safe latency collection for benchmarks:

type LatencyCollector struct {
    mu        sync.Mutex
    latencies []time.Duration
}

func (lc *LatencyCollector) Record(d time.Duration)
func (lc *LatencyCollector) GetTotalStats() (min, max, avg, p95, p99, p999 time.Duration, count int)

Error Collection#

Thread-safe error collection (limited to 100 errors):

const maxBenchmarkErrors = 100

type ErrorCollector struct {
    mu     sync.Mutex
    errors []string
    count  int64
}

func (ec *ErrorCollector) Record(err error)
func (ec *ErrorCollector) Count() int64
func (ec *ErrorCollector) PrintErrors()

Dependencies#

Core Dependencies#

Table: Go Module Dependencies

Package	Version	Purpose
charmbracelet/bubbles	v0.21.0	TUI components
charmbracelet/bubbletea	v1.3.10	TUI framework
charmbracelet/lipgloss	v1.1.0	Terminal styling
chzyer/readline	v1.5.1	Interactive input
go-sql-driver/mysql	v1.7.1	MySQL driver
redis/go-redis/v9	v9.1.0	Redis client
spf13/cobra	v1.7.0	CLI framework
golang.org/x/term	v0.39.0	Terminal control
olekukonko/tablewriter	v0.0.5	Table formatting

Security Considerations#

SQL Injection Prevention#

The MySQL client sanitizes identifiers to prevent SQL injection:

func sanitizeIdentifier(name string) string {
    return strings.ReplaceAll(name, "`", "``")
}

// Usage in queries
query := fmt.Sprintf("SHOW TABLES FROM `%s`",
    sanitizeIdentifier(database))

TLS Configuration#

TLS can be enabled for secure connections:

tlsConfig := &tls.Config{
    MinVersion:         tls.VersionTLS12,
    InsecureSkipVerify: true,  // For self-signed certs
}

Note: InsecureSkipVerify is enabled by default for development environments. Production deployments should use proper certificate validation.

API Key Authentication#

REST API requests include authentication headers when configured:

if c.apiKey != "" {
    req.Header.Set("X-API-Key", c.apiKey)
}

Password Handling#

Passwords are:

Never logged or displayed
Read silently when using -p flag
Can be provided via environment variable for automation

Troubleshooting#

Connection Issues#

Checking Status#

Use the status subcommand to verify connections:

./rondb status --host myrondb.example.com

Common Connection Errors#

Table: Connection Troubleshooting

Error	Solution
Connection refused	Verify service is running and port is correct
Timeout	Check network connectivity and firewall rules
Authentication failed	Verify username and password
TLS handshake error	Check TLS configuration and certificates

Verbose Modes#

Enable verbose output for debugging:

# Level 1: Connection information
./rondb --verbose 1

# Level 2: Debug output
./rondb --verbose 2

Debug Mode#

Enable debug mode within the shell:

rondb> .debug 1
Debug mode enabled

rondb> SET key value
[DEBUG] REQ: [SET key value]
[DEBUG] RESP: OK
OK (0.8ms)

Examples#

Complete Workflow Example#

# Connect to RonDB
$ ./rondb --host myrondb.example.com --mysql-user admin -p
Enter MySQL password: ********

Welcome to RonDB CLI v0.1.0
Type .help for help, .demo for a quick demo

# Run the demo
rondb> .demo

# Explore databases
rondb> .browse

# Write via Rondis
rondb> SET product:1001 '{"name":"Widget","price":29.99}'
OK (0.8ms)

# Read via Rondis
rondb> GET product:1001
{"name":"Widget","price":29.99} (0.5ms)

# Query via SQL
rondb> SELECT * FROM inventory.products WHERE id = 1001;
+------+--------+-------+
| id   | name   | price |
+------+--------+-------+
| 1001 | Widget | 29.99 |
+------+--------+-------+
1 row in set (2.3ms)

# High-performance read via REST API
rondb> READ inventory.products id, name, price FILTER id=1001;
{
  "data": {
    "id": 1001,
    "name": "Widget",
    "price": 29.99
  }
}
(1.1ms)

# Run benchmark
rondb> .load_rondis 4 10000 1
rondb> .bench_rondis 4 10000 1 20
rondb> .del_rondis 4 10000 1

# Exit
rondb> quit

Batch Operations Example#

rondb> BATCH
    ...> READ inventory.products id, name FILTER id=1001 OP prod1
    ...> READ inventory.products id, name FILTER id=1002 OP prod2
    ...> READ inventory.products id, name FILTER id=1003 OP prod3
    ...> ;
{
  "result": [
    {"operationId": "prod1", "data": {"id": 1001, "name": "Widget"}},
    {"operationId": "prod2", "data": {"id": 1002, "name": "Gadget"}},
    {"operationId": "prod3", "data": {"id": 1003, "name": "Gizmo"}}
  ]
}
(3.2ms)

Quick Reference Card#

Command Summary#

Table: Command Summary

Command	Description
Information
.help	General help
.help internal	Benchmark commands
.help start	Connection options
.tables	List all tables
.browse	TUI browser
.demo	Quick demo
Configuration
.client [N]	Set client ID
.debug [0\|1]	Toggle debug
.verbose [0\|1\|2]	Set verbosity
Rondis Benchmarks
.load_rondis [T] [N] [R]	Load data
.bench_rondis [T] [N] [R] [W]	Run benchmark
.bench_rondis_cont [...] [S]	Continuous
.del_rondis [T] [N] [R]	Delete data
SQL Benchmarks
.load_sql [T] [N] [R]	Load data
.bench_sql [T] [N] [R] [W]	Run benchmark
.bench_sql_cont [...] [S]	Continuous
.bench_sql_scan [T] [N] [R]	Scan benchmark
.del_sql [T] [N] [R]	Delete data
.drop_sql	Drop test table
REST API Benchmarks
.bench_rdrs [T] [N] [R]	Batch pk-read
.bench_rdrs_cont [...] [S]	Continuous
Exit
quit / exit / q	Exit shell

Default Values#

Host: localhost
Rondis port: 6379
MySQL port: 3306
REST API port: 4406
MySQL user: root
Benchmark threads: 2
Benchmark operations: 1000
Benchmark rows/op: 1
Benchmark write%: 0
Continuous duration: 60 seconds

Version History#

Version 0.1.0#

Initial release featuring:

Unified CLI for Rondis, MySQL, RonSQL, and REST API
Interactive TUI database browser
Comprehensive benchmarking suite
DSL parser for REST API operations
TLS support for all connections
API key authentication for REST API
Error collection for benchmarks
Multi-line command support
Color-coded output

Introduction#

Overview#

Version Compatibility#

Design Philosophy#

Key Features#

Installation and Setup#

Prerequisites#

Building from Source#

Quick Start#

Configuration#

Command-Line Flags#

Environment Variables#

Configuration Precedence#

Client Interfaces#

MySQL (SQL Interface)#

Supported Operations#

Multi-line SQL#

Forcing MySQL Routing#

REST API (DSL Interface)#

Single READ Syntax#

BATCH Syntax#

RonSQL (REST API SQL)#

Supported Queries#

Commands#

Configuration#

Limitations#

Rondis (Redis Protocol)#

Supported Commands#

Example Session#

Internal Commands#

Help and Information#

Navigation and Exploration#

Configuration Commands#

Exit Commands#

Benchmarking#

Benchmark Parameters#

Rondis Benchmarks#

Data Loading#

Performance Testing#

Data Cleanup#

SQL Benchmarks#

Data Loading#

Performance Testing#

Data Cleanup#

REST API Benchmarks#

Benchmark Output#

Error Collection#

TUI Database Browser#

Launching the Browser#

Interface Layout#

Keyboard Navigation#

Views#

Schema View#

Data View#

Architecture#

Project Structure#

Client Architecture#

MySQLClient#

RondisClient#

RestClient#

Command Routing#

Latency Collection#

Error Collection#

Dependencies#

Core Dependencies#

Security Considerations#

SQL Injection Prevention#

TLS Configuration#

API Key Authentication#

Password Handling#

Troubleshooting#

Connection Issues#

Checking Status#

Common Connection Errors#

Verbose Modes#

Debug Mode#

Examples#

Complete Workflow Example#

Batch Operations Example#

Quick Reference Card#