16bad90eee
### Problem When using the `io_uring` backend, WAL file writes were corrupted: the submitted buffer data (e.g., WAL header magic `37 7f 06 82`) was correct in logs, but the file on disk showed incorrect data (e.g., `00 18 27 xx`). This occurred because the `Arc<RefCell<Buffer>>` was dropped before the asynchronous `io_uring` write completed, allowing the kernel to write stale or freed memory. ### Root Cause In `UringFile::pwrite`, the `buffer` was passed to `io_uring` via an `iovec`, but the `Arc<RefCell<Buffer>>` wasn’t guaranteed to live until the write finished. Unlike synchronous `UnixIO`, where the buffer persists during the `pwrite` call, `io_uring`’s async nature exposed this lifetime issue. ### Fix Modified `UringFile::pwrite` to hold a reference to the `buffer` in the completion callback by calling `buffer.borrow()`. This ensures the `Buffer` remains alive until `io_uring` completes the write, preventing memory corruption. ### Changes - Updated `core/io/io_uring.rs`: - Added `WriteCompletion` import. - Wrapped the original `Completion` in a new `WriteCompletion` closure that references the `buffer`, extending its lifetime until the write completes. ### Validation - Tested with `limbo -v io_uring`: - `.open limbo.db` - `CREATE TABLE users (id INT PRIMARY KEY, username TEXT);` - `INSERT INTO users VALUES (1, 'alice');` - `INSERT INTO users VALUES (2, 'bob');` - `SELECT * FROM users;` - Verified WAL file with `xxd -l 16 limbo.db-wal`: - Before: `0018 2734 ...` - After: `377f 0682 ...` (correct WAL magic). - `wal-browser limbo.db-wal` confirms the header is written correctly, **though frame checksums still need separate fixing** (tracked in a follow-up issue). ### Follow-Up - Frame checksum mismatches persist in `wal-browser` output (e.g., `00000000-00000000 != 14d64367-7b77a5a0`). This is a separate issue in `begin_write_wal_frame` or WAL frame initialization, to be addressed in a subsequent PR. Closes: #1137 Closes #1143
Project Limbo
Limbo is a project to build the modern evolution of SQLite.
Features and Roadmap
Limbo is a work-in-progress, in-process OLTP database engine library written in Rust that has:
- Asynchronous I/O support on Linux with
io_uring - SQLite compatibility [doc] for SQL dialect, file formats, and the C API
- Language bindings for JavaScript/WebAssembly, Rust, Go, Python, and Java
- OS support for Linux, macOS, and Windows
In the future, we will be also working on:
- Integrated vector search for embeddings and vector similarity.
BEGIN CONCURRENTfor improved write throughput.- Improved schema management including better
ALTERsupport and strict column types by default.
Getting Started
💻 Command Line
You can install the latest `limbo` release with:
curl --proto '=https' --tlsv1.2 -LsSf \
https://github.com/tursodatabase/limbo/releases/latest/download/limbo_cli-installer.sh | sh
Then launch the shell to execute SQL statements:
Limbo
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database
limbo> CREATE TABLE users (id INT PRIMARY KEY, username TEXT);
limbo> INSERT INTO users VALUES (1, 'alice');
limbo> INSERT INTO users VALUES (2, 'bob');
limbo> SELECT * FROM users;
1|alice
2|bob
You can also build and run the latest development version with:
cargo run
✨ JavaScript
npm i limbo-wasm
Example usage:
import { Database } from 'limbo-wasm';
const db = new Database('sqlite.db');
const stmt = db.prepare('SELECT * FROM users');
const users = stmt.all();
console.log(users);
🐍 Python
pip install pylimbo
Example usage:
import limbo
con = limbo.connect("sqlite.db")
cur = con.cursor()
res = cur.execute("SELECT * FROM users")
print(res.fetchone())
🐹 Go
- Clone the repository
- Build the library and set your LD_LIBRARY_PATH to include limbo's target directory
cargo build --package limbo-go
export LD_LIBRARY_PATH=/path/to/limbo/target/debug:$LD_LIBRARY_PATH
- Use the driver
go get github.com/tursodatabase/limbo
go install github.com/tursodatabase/limbo
Example usage:
import (
"database/sql"
_"github.com/tursodatabase/limbo"
)
conn, _ = sql.Open("sqlite3", "sqlite.db")
defer conn.Close()
stmt, _ := conn.Prepare("select * from users")
defer stmt.Close()
rows, _ = stmt.Query()
for rows.Next() {
var id int
var username string
_ := rows.Scan(&id, &username)
fmt.Printf("User: ID: %d, Username: %s\n", id, username)
}
☕️ Java
We integrated Limbo into JDBC. For detailed instructions on how to use Limbo with java, please refer to the README.md under bindings/java.
Contributing
We'd love to have you contribute to Limbo! Please check out the contribution guide to get started.
FAQ
How is Limbo different from Turso's libSQL?
Limbo is a project to build the modern evolution of SQLite in Rust, with a strong open contribution focus and features like native async support, vector search, and more. The libSQL project is also an attempt to evolve SQLite in a similar direction, but through a fork rather than a rewrite.
Rewriting SQLite in Rust started as an unassuming experiment, and due to its incredible success, replaces libSQL as our intended direction. At this point, libSQL is production ready, Limbo is not - although it is evolving rapidly. As the project start to near production readiness, we plan to rename it to just "Turso". More details here.
Publications
- Pekka Enberg, Sasu Tarkoma, Jon Crowcroft Ashwin Rao (2024). Serverless Runtime / Database Co-Design With Asynchronous I/O. In EdgeSys ‘24. [PDF]
- Pekka Enberg, Sasu Tarkoma, and Ashwin Rao (2023). Towards Database and Serverless Runtime Co-Design. In CoNEXT-SW ’23. [PDF] [Slides]
License
This project is licensed under the MIT license.
Contribution
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Limbo by you, shall be licensed as MIT, without any additional terms or conditions.