VibeSQL

SQL:1999 compliant database in Rust, 100% AI-generated

Live Demo | CLI Guide | Python Bindings | Conformance Report

Highlights

• 100% SQL:1999 Core compliance - 739/739 sqltest tests passing
• 100% SQLLogicTest conformance - 623 files (~5.9M tests)
• 4,800+ unit tests - comprehensive test coverage
• Real-time subscriptions - Convex-like reactivity with delta updates
• HTTP REST & GraphQL API - Full CRUD and query endpoints
• Vector search - AI/ML embeddings with similarity search
• File storage - Blob storage with SQL integration
• Full-featured CLI with PostgreSQL-compatible commands
• TypeScript SDK with React hooks and Drizzle ORM adapter
• Python bindings with DB-API 2.0 interface
• WebAssembly - runs in the browser
• 327,000+ lines of Rust across 11 crates

Built entirely by AI agents using Claude Code and Loom.

Quick Start

# Clone and build
git clone --recurse-submodules https://github.com/rjwalters/vibesql.git
cd vibesql
cargo build --release

# Run the CLI
cargo run --release --bin vibesql

# Or try the web demo
cd web-demo && npm install && npm run dev

CLI Example

$ cargo run --release --bin vibesql
vibesql> CREATE TABLE users (id INTEGER, name VARCHAR(50));
vibesql> INSERT INTO users VALUES (1, 'Alice'), (2, 'Bob');
vibesql> SELECT * FROM users;
+----+-------+
| id | name  |
+----+-------+
| 1  | Alice |
| 2  | Bob   |
+----+-------+
vibesql> \q

See CLI Guide for meta-commands, output formats, and import/export.

Python

pip install maturin
maturin develop

import vibesql

db = vibesql.connect()
cursor = db.cursor()
cursor.execute("CREATE TABLE t (id INTEGER, name VARCHAR(50))")
cursor.execute("INSERT INTO t VALUES (1, 'Hello')")
cursor.execute("SELECT * FROM t")
print(cursor.fetchall())  # [(1, 'Hello')]

See Python Bindings Guide for full API reference.

Features

Real-Time Subscriptions

Subscribe to SQL queries and receive automatic updates when data changes—Convex-like reactivity with full SQL power.

import { VibeSqlClient } from '@vibesql/client';

const db = new VibeSqlClient({ host: 'localhost', port: 5432 });
await db.connect();

// Subscribe to a query - get updates when data changes
const subscription = db.subscribe(
  'SELECT * FROM messages WHERE channel_id = $1 ORDER BY created_at DESC LIMIT 50',
  [channelId],
  {
    onData: (messages) => setMessages(messages),
    onDelta: (delta) => {
      // Efficient incremental updates
      if (delta.type === 'insert') addMessage(delta.row);
      if (delta.type === 'delete') removeMessage(delta.row);
    },
  }
);

// React hook for easy integration
function ChatRoom({ channelId }) {
  const { data, isLoading } = useSubscription(db,
    'SELECT * FROM messages WHERE channel_id = $1',
    [channelId]
  );
  return <MessageList messages={data} />;
}

Features:

• Delta updates (only changed rows sent)
• Automatic reconnection with subscription restoration
• Configurable limits, quotas, and backpressure handling
• HTTP SSE endpoint for REST API consumers
• React hooks (useSubscription, useQuery)

SQL Support

• Queries: SELECT, JOINs (INNER/LEFT/RIGHT/FULL/CROSS), subqueries, CTEs, UNION/INTERSECT/EXCEPT
• DML: INSERT, UPDATE, DELETE, TRUNCATE
• DDL: CREATE/ALTER/DROP TABLE, views, indexes, schemas
• Aggregates: COUNT, SUM, AVG, MIN, MAX with GROUP BY/HAVING
• Window functions: ROW_NUMBER, RANK, DENSE_RANK, LAG, LEAD
• Transactions: BEGIN, COMMIT, ROLLBACK, savepoints
• Security: GRANT/REVOKE with full privilege enforcement

Advanced Features

• Views with OR REPLACE and column lists
• Stored procedures and functions (IN/OUT/INOUT parameters)
• Full-text search (MATCH AGAINST)
• Spatial functions (ST_* library)
• Triggers (BEFORE/AFTER)
• Scheduled functions (SCHEDULE AFTER/AT, CREATE CRON)
• Vector types for AI embeddings (VECTOR(n), distance functions)
• Blob storage with STORAGE_URL/STORAGE_SIZE functions

Performance

• Columnar execution with SIMD acceleration
• Cost-based join reordering
• Hash joins for equi-joins
• Predicate pushdown
• Expression caching

Benchmarks

VibeSQL achieves 75,404 TPS on TPC-C (38x faster than SQLite) and passes 100% of TPC-H and TPC-DS queries.

Test Coverage

TPC-C (OLTP Transactions)

Scale Factor 1, 10-second duration. Stock-Level transaction latency: 173µs (36x under 1ms target).

TPC-DS (Complex Analytics)

99/99 queries passing (100%) at SF 0.001. All queries complete within timeout.

Peak memory: ~141 MB. See full results.

TPC-H (Decision Support)

22/22 queries passing (100%). All queries optimized with columnar execution and cost-based join reordering.

Running Benchmarks

# Build release binaries first
cargo build --release

# Run all benchmarks
make benchmark          # TPC-H, TPC-C, TPC-DS, Sysbench

# Individual benchmarks
make benchmark-tpch     # TPC-H (22 queries, SF 0.01)
make benchmark-tpcc     # TPC-C (OLTP, SF 1)
make benchmark-tpcds    # TPC-DS (99 queries, SF 0.001)
make benchmark-sysbench # Sysbench (point lookups, range scans)

# With custom parameters
SCALE_FACTOR=0.01 PROFILING_ITERATIONS=3 cargo bench --bench tpch_profiling
TPCC_SCALE_FACTOR=1 TPCC_DURATION_SECS=10 cargo bench --bench tpcc_benchmark

See Benchmarking Guide for details on parameters and profiling.

Development

# Full build, test, and benchmark (runs in background)
make all            # Starts in background, shows monitoring instructions
make status         # Check progress
make logs           # Follow full output

# Individual targets
make build          # Build all crates
make test           # Run all tests (unit + integration + sqllogictest)
make benchmark      # Run TPC-H/TPC-C/TPC-DS/Sysbench benchmarks
make all-fg         # Run everything in foreground (blocking)
make help           # Show all targets

Documentation

Project Background

This project originated from a challenge about AI capabilities: implement a NIST-compatible SQL database from scratch. Core SQL:1999 compliance was achieved in under 2 weeks (Oct 25 - Nov 1, 2025).

Inspired by posix4e/nistmemsql.

License

MIT OR Apache-2.0. See LICENSE-MIT and LICENSE-APACHE.

Contributing

See CLAUDE.md for development workflow with Loom AI orchestration.

Try the Live Demo →