#storage #json #cbor #lmdb #btree

ledb

Lightweight embedded database built over LMDB

1 unstable release

0.1.0 Sep 28, 2018

#11 in #lmdb

Download history 8/week @ 2018-09-29

2 downloads per month
Used in 1 crate

MIT license

179KB
4K SLoC

Lightweight embedded database

License: MIT Travis-CI Build Status Appveyor Build status Crates.io Package Docs.rs API Documentation

The LEDB is an attempt to implement simple but efficient, lightweight but powerful document storage.

The abbreviation LEDB may be treated as an Lightweight Embedded DB, also Low End DB, also Literium Engine DB, also LitE DB, and so on.

Links

Key features

  • Processing documents which implements Serialize and Deserialize traits from serde.
  • Identifying documents using auto-incrementing integer primary keys.
  • Indexing any fields of documents using unique or duplicated keys.
  • Searching and ordering documents using indexed fields or primary key.
  • Selecting documents using complex filters with fields comparing and logical operations.
  • Updating documents using rich set of modifiers.
  • Storing documents into independent storages so called collections.
  • Flexible query! macro which helps write clear and readable queries.
  • Using LMDB as backend for document storage and indexing engine.

Usage example

extern crate serde;
#[macro_use] extern crate serde_derive;
// This allows inserting JSON documents
#[macro_use] extern crate serde_json;
#[macro_use] extern crate ledb;

use ledb::{Options, Storage, IndexKind, KeyType, Filter, Comp, Order, OrderKind};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct MyDoc {
    title: String,
    tag: Vec<String>,
    timestamp: u32,
}

fn main() {
    let db_path = ".test_dbs/my_temp_db";
    let _ = std::fs::remove_dir_all(&db_path);

    // Open storage
    let storage = Storage::new(&db_path, Options::default()).unwrap();
    
    // Get collection
    let collection = storage.collection("my-docs").unwrap();
    
    // Ensure indexes
    query!(index for collection
        title str unique,
        tag str,
        timestamp int unique,
    ).unwrap();
    
    // Insert JSON document
    let first_id = query!(insert into collection {
        "title": "First title",
        "tag": ["some tag", "other tag"],
        "timestamp": 1234567890,
    }).unwrap();
    
    // Insert typed document
    let second_id = collection.insert(&MyDoc {
        title: "Second title".into(),
        tag: vec![],
        timestamp: 1234567657,
    }).unwrap();

    // Find documents
    let found_docs = query!(
        find MyDoc in collection
        where title == "First title"
    ).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
    
    // Update documents
    let n_affected = query!(
        update in collection modify title = "Other title"
        where title == "First title"
    ).unwrap();

    // Find documents with descending ordering
    let found_docs = query!(
        find MyDoc in collection order desc
    ).unwrap().collect::<Result<Vec<_>, _>>().unwrap();

    // Remove documents
    let n_affected = query!(
        remove from collection where title == "Other title"
    ).unwrap();
}

Dependencies

~5MB
~95K SLoC