KalamDB Benchmark Report

CREATE TABLE with 3 columns

DROP TABLE on a previously created table

INSERT a single row into a table

One INSERT statement with 50 rows (statement-scoped transaction)

Explicit BEGIN/COMMIT with 50 single-row INSERT statements

SELECT * from a 200-row table

SELECT with WHERE clause on a 200-row table

SELECT COUNT(*) on a 200-row table

SELECT with ORDER BY + LIMIT 10 on a 200-row table

UPDATE a single row by filter condition

DELETE a single row by filter condition

N concurrent INSERT operations in parallel (N = concurrency setting)

N concurrent SELECT operations in parallel (N = concurrency setting)

SELECT by primary key from a 10K-row table (single row lookup)

GROUP BY + SUM/AVG/COUNT on a 10K-row table (analytical query performance)

SELECT with subquery across two tables (200 customers, 1000 orders)

INSERT rows with ~4KB TEXT payloads (serialization + storage throughput)

INSERT into a 20-column table (wide schema overhead)

DELETE 100 rows at once with a range filter (bulk deletion)

INSERT → UPDATE → SELECT → DELETE full DML lifecycle per iteration

ALTER TABLE ADD COLUMN + DROP COLUMN (schema evolution latency)

N concurrent UPDATE operations on the same table (write contention test)

Concurrent INSERT + UPDATE + DELETE on the same table (multi-op contention)

Concurrent queries across 5 different namespaces (isolation test)

Subscribe to a 1000-row user table and receive the full initial data batch

Latency from INSERT to subscriber receiving the change notification

Disconnect and re-subscribe to a user table (reconnection overhead)

SELECT from a shared table with 20 flushed Parquet files (200K rows)

N WebSocket live-query subscribers receiving changes from concurrent writes

N concurrent INSERTs into a topic-sourced table (measures publish overhead)

N concurrent topic CONSUME calls pulling messages in parallel

1000 concurrent SQL SELECT queries at once (RPS degradation test)

CREATE USER (auth subsystem stress test)

DROP USER (auth subsystem teardown stress test)

N simultaneous login + SQL + cycles (connection setup overhead)

50/50 concurrent reads + writes on same table (contention test)

N concurrent large-result-set SELECTs (serialization + memory pressure)

Progressive live-query subscriber scale and insert fanout verification up to 100.0K