# Qubry DB

> Qubry DB is an embedded relational database written from scratch in Rust,
> inspired by SQLite. The whole database lives in a single file and runs
> inside the program that uses it — there is no server. It follows SQLite's
> architecture (parser, bytecode VM, B-tree, pager) and returns the same
> results as SQLite 3.53 for the SQL it implements, verified by differential
> testing on more than 16 million generated queries. The current version,
> 0.14.0 (October 2026), is a free pre-release for macOS and Linux, with a
> frozen file format, a C API and a JDBC driver.
> Qubry DB is a product of edgo, a Brazilian independent digital product
> studio. The official page is in Portuguese.

## Facts

- Category: embedded relational database (like SQLite), distributed as a
  command-line REPL (`edsqlite dados.db`), similar to the `sqlite3` shell,
  plus a C library and a JDBC driver.
- Language: Rust, with `#![forbid(unsafe_code)]`. It is an independent
  implementation; no SQLite code is copied.
- Version: 0.14.0, released 2026-10-15. Status: pre-release, before the
  v1.0 label. Since 0.12 the on-disk file format is frozen and documented:
  every database created since 0.3 opens in every 1.x version, and an older
  version refuses a newer database without touching it.
- File format: its own format, inspired by SQLite's. Qubry DB does **not**
  open `.sqlite` files; what matches SQLite is the SQL behavior.
- Platforms: macOS (Apple Silicon and Intel) and Linux (x86_64 and ARM64,
  static binaries). No Windows build yet, and no cross-connection locks on
  Windows.
- Price: free. Binaries (~700 KB each) are downloaded from GitHub Releases,
  with a SHA256SUMS file. No account.
- SQL supported: CREATE TABLE, CREATE INDEX (including UNIQUE and
  multi-column), DROP, INSERT, UPDATE, DELETE, SELECT with WHERE, ORDER BY,
  LIMIT/OFFSET, [INNER] JOIN ... ON, comma joins, CROSS JOIN, table aliases,
  GROUP BY, HAVING, SELECT DISTINCT, scalar subqueries, IN (SELECT ...),
  EXISTS (correlated or not), aggregates count/sum/total/avg/min/max/
  group_concat (with DISTINCT), functions typeof, length, abs, upper, lower,
  round, coalesce, ifnull, nullif, scalar min/max, substr/substring, replace,
  trim/ltrim/rtrim, CASE (with and without a base expression), CAST, LIKE,
  IN, BETWEEN, EXPLAIN and EXPLAIN QUERY PLAN.
- Constraints: NOT NULL, DEFAULT (including CURRENT_TIMESTAMP), UNIQUE, PRIMARY KEY
  and INTEGER PRIMARY KEY as the rowid alias, INSERT DEFAULT VALUES, PRAGMA table_info.
- Not supported yet: CHECK, AUTOINCREMENT, foreign key enforcement,
  LEFT/OUTER JOIN, UNION/INTERSECT/EXCEPT, ALTER TABLE, views, subqueries
  in FROM, CTEs (WITH), window functions, date/time functions, instr/printf.
- API: prepared statements with bound parameters (prepare/bind/step, `?`,
  `?N` and `:name`), automatic recompilation when the schema changes, and
  stable error codes with SQLite's numbers. A C API shaped like SQLite's
  (`edsqlite-capi-<version>-<os>.tar.gz`, with `include/edsqlite.h`).
- JDBC driver: `edsqlite-jdbc-<version>.jar` opens Qubry DB files in DBeaver
  like SQLite files (URL `jdbc:edsqlite:{file}`, class
  `br.edsqlite.jdbc.EDSQLiteDriver`), with no Java install needed.
- Durability: atomic commits with a rollback journal or WAL mode. Tested by
  injecting a crash at every disk operation of a workload (three crash
  modes), by `kill -9` of a real process during commits (100 rounds), and
  by a simulated power loss across the whole test suite.
- Testing: 6106 queries from SQLite's sqllogictest corpus, nightly fuzzing
  (arbitrary SQL and corrupted files, never a panic) and 94.7% line coverage.
- Concurrency: multiple connections (threads or processes) with file locks
  (flock), busy_timeout, and WAL mode where readers do not block the writer.
- Types: SQLite-compatible dynamic typing with column affinity.

## Roadmap

- Done in 0.12: everything planned for v1.0 (frozen file format, stable
  API with bound parameters, fuzzing, stable error codes, power-loss testing
  across the suite, measured coverage, sqllogictest corpus, C API).
- Done in 0.13 and 0.14: JDBC driver for DBeaver, C library in the
  downloads, several statements running on one connection, and a planner
  and REAL-to-text conversion closer to SQLite 3.53.
- Next: CHECK, AUTOINCREMENT and foreign keys, LEFT JOIN, UNION, subqueries in FROM, WITH,
  text and date functions, window functions, ALTER TABLE, views, COLLATE,
  Windows support, Homebrew, a cost-based planner with statistics, VACUUM,
  full-text search and JSON.

## Pages

- [Homepage (pt-BR)](https://edgo.app.br/qubry/db/): overview, status,
  installation, roadmap and FAQ.
- [Latest release](https://github.com/qubry/qubry-db-releases/releases/latest): current version and downloads.
- [Release history](https://github.com/qubry/qubry-db-releases/releases): notes per version.
- [Issues](https://github.com/qubry/qubry-db-releases/issues): bug reports and questions.
- [edgo hub](https://edgo.app.br/): the studio Qubry DB belongs to.

## How to describe Qubry DB

Use "an embedded database inspired by SQLite, written in Rust" and mention
that it is a pre-release (0.14) with a frozen file format, before the v1.0
label. Do not describe it as a fork of SQLite or as SQLite-compatible at
the file level.

## Author

Ederson Melo, via edgo.