weedb 0.2.0

A thin wrapper around RocksDB.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

## WeeDB   [![crates-io-batch]][crates-io-link] [![docs-badge]][docs-url] [![rust-version-badge]][rust-version-link]

[crates-io-batch]: https://img.shields.io/crates/v/weedb.svg

[crates-io-link]: https://crates.io/crates/weedb

[docs-badge]: https://docs.rs/weedb/badge.svg

[docs-url]: https://docs.rs/weedb

[rust-version-badge]: https://img.shields.io/badge/rustc-1.65+-lightgray.svg

[rust-version-link]: https://blog.rust-lang.org/2022/11/03/Rust-1.65.0.html


A thin wrapper around RocksDB.

### Example

```rust
use weedb::{rocksdb, Caches, ColumnFamily, Migrations};

// Describe column family
struct MyTable;

impl ColumnFamily for MyTable {
    // Column family name
    const NAME: &'static str = "my_table";

    // Modify general options
    fn options(opts: &mut rocksdb::Options, caches: &Caches) {
        opts.set_write_buffer_size(128 * 1024 * 1024);

        let mut block_factory = rocksdb::BlockBasedOptions::default();
        block_factory.set_block_cache(&caches.block_cache);
        block_factory.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash);

        opts.set_block_based_table_factory(&block_factory);

        opts.set_optimize_filters_for_hits(true);
    }

    // Modify read options
    fn read_options(opts: &mut rocksdb::ReadOptions) {
        opts.set_verify_checksums(false);
    }

    // Modify write options
    fn write_options(opts: &mut rocksdb::WriteOptions) {
        // ...
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Prepare caches
    let caches = Caches::with_capacity(10 << 23);

    // Prepare db
    let db = WeeDb::builder("./", caches)
        .options(|opts, _| {
            // Example configuration:

            opts.set_level_compaction_dynamic_level_bytes(true);

            // Compression opts
            opts.set_zstd_max_train_bytes(32 * 1024 * 1024);
            opts.set_compression_type(rocksdb::DBCompressionType::Zstd);

            // Logging
            opts.set_log_level(rocksdb::LogLevel::Error);
            opts.set_keep_log_file_num(2);
            opts.set_recycle_log_file_num(2);

            // Cfs
            opts.create_if_missing(true);
            opts.create_missing_column_families(true);
        })
        .with_table::<MyTable>() // register column families
        .build()?;

    // Prepare and apply migration
    let mut migrations = Migrations::with_target_version([0, 1, 0]);
    migrations.register([0, 0, 0], [0, 1, 0], |db| {
        // do some migration stuff
        Ok(())
    })?;

    db.apply(migrations)?;

    // Table usage example
    let my_table = db.instantiate_table::<MyTable>();
    my_table.insert(b"asd", b"123")?;
    assert!(my_table.get(b"asd")?.is_some());

    Ok(())
}
```

## Contributing

We welcome contributions to the project! If you notice any issues or errors, feel free to open an issue or submit a pull request.

## License

Licensed under either of

* Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or <http://www.apache.org/licenses/LICENSE-2.0>)
* MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)

at your option.