Struct DB 🔧🔩

Goal: Embedded database that maintains coherence between Rust types and stored data with minimal boilerplate, enjoy 😌🍃.

Features

• Fast as the storage engine you choose (redb, IndexDB planned*).
• Embedded database (Linux, macOS, Windows, Android, iOS, WebBrowser WASM planned*).
• Support multiple indexes (unique secondary keys).
• Compatible with all Rust types (enum, struct, tuple etc.).
• Query data (get, watch, iter etc.) using explicit type or type inference.
• Real-time subscription with filters for insert, update and delete operations.
• Schema migration using native Rust coercion.
• Fully ACID-compliant transactions.
• Add your own serialization/deserialization logic planned* (e.g: zero-copy).
• Thread-safe.
• Plus, all features depending on the storage engine you choose:
  • redb support: Linux, macOS, Windows, Android, iOS.
  • IndexDB support: WebBrowser (WASM) planned*.
  • Open an issue if you want to add another storage engine.

Status

Early development. Not ready for production.

How to use?

See docs.rs.

Example

```rust use serde::{Deserialize, Serialize}; use struct_db::*;

[derive(Serialize, Deserialize, PartialEq, Debug)]

[struct_db(

fn_primary_key(p_key),
fn_secondary_key(s_key),

)] struct Data(u32, String);

impl Data { // p_key returns the primary key of the Data struct as a vector of bytes. // In this case, it is the big-endian byte representation of the i32 value. // Using big-endian representation for the primary key maintains a consistent // lexicographical ordering of the keys, which is useful for ordered key-value // stores and efficient range queries. pub fn pkey(&self) -> Vec { self.0.tobebytes().tovec() }

// `s_key` generates a secondary key for the `Data` struct as a vector of bytes.
// The secondary key consists of the big-endian byte representation of the `i32` value
// (the primary key) followed by the String field. This combined key allows for more
// versatile querying options.

pub fn skey(&self) -> Vec { let mut pkey = self.pkey(); pkey.extend(self.1.asbytes()); pkey } }

fn main() { let mut db = Db::inittmp("mydb").unwrap(); // Initialize the schema db.addschema(Data::structdb_schema());

let data = Data(1,"test".to_string());
// Insert data
let txn = db.transaction().unwrap();
{
  let mut tables = txn.tables();
  tables.insert(&txn, data).unwrap();
}
txn.commit().unwrap();

// Get data
let txn_read = db.read_transaction().unwrap();
let retrieve_data: Data = txn_read.tables().primary_get(&txn_read, &1_u32.to_be_bytes()).unwrap().unwrap();
assert_eq!(&retrieve_data, &Data(1,"test".to_string()));

// Remove data
let txn = db.transaction().unwrap();
{
  let mut tables = txn.tables();
  tables.remove(&txn, retrieve_data).unwrap();
}
txn.commit().unwrap();

} ```

Roadmap

The following features are planned before the 1.0 release

• Stabilize the wording, if you have any suggestion follow this issue 🙏.
• Add benchmarks tests.
• Add documentation.
• Stable release of redb or implement another stable storage engine(s) for Linux, macOS, Windows, Android, iOS.
• Add support for IndexDB (WebBrowser).
• Add support for custom serialization/deserialization logic.