async_rocksdb/

lib.rs

// src/lib.rs

//! # async-rocksdb
//!
//! An ergonomic, async wrapper for RocksDB in Rust.
//!
//! Provides non-blocking operations suitable for Tokio-based applications.
//!
//! ## Important Note on Column Families
//!
//! When you use `AsyncRocksBuilder::add_column_family`, the database is opened in "explicit column family mode".
//! In this mode, the **default column family is not created automatically**.
//!
//! If you want to use `cf: None` (which maps to "default"), you **must** explicitly add it:
//!
//! ```rust
//! use async_rocksdb::AsyncRocksBuilder;
//!
//! #[tokio::main]
//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
//!     let path = "/tmp/async-rocksdb-doctest-cf";
//!     let _ = std::fs::remove_dir_all(path); // cleanup
//!
//!     let db = AsyncRocksBuilder::new()
//!         .add_column_family("default")  // required for cf: None
//!         .add_column_family("users")
//!         .open(path)
//!         .await?;
//!
//!     db.put(b"key", b"value", None).await?;  // works
//!     Ok(())
//! }
//! ```
//!
//! If you don't add any column families, the default one is created automatically and `cf: None` works.
//!
//! ## Features
//!
//! - Async reads/writes
//! - Column families
//! - Snapshots
//! - Prefix scans
//! - Batch operations
//! - Manual flush/compaction

use rocksdb::{
    DB, Options, BlockBasedOptions, Cache,
    ColumnFamilyDescriptor, DBCompressionType, IteratorMode, ReadOptions,
};
use std::path::Path;
use std::sync::Arc;
use thiserror::Error;
use tokio::task;

/// Error type for async-rocksdb operations.
#[derive(Error, Debug)]
pub enum AsyncRocksError {
    #[error("RocksDB error: {0}")]
    Rocks(#[from] rocksdb::Error),
    #[error("Task failed: {0}")]
    Join(#[from] task::JoinError),
    #[error("Column family not found: {0}")]
    ColumnFamilyNotFound(String),
}

/// Configuration for a single column family.
pub struct ColumnFamilyConfig {
    name: String,
    options: Options,
}

impl ColumnFamilyConfig {
    pub fn new(name: &str) -> Self {
        let mut options = Options::default();
        options.create_if_missing(true);
        Self {
            name: name.to_string(),
            options,
        }
    }

    pub fn compression(mut self, compression: DBCompressionType) -> Self {
        self.options.set_compression_type(compression);
        self
    }

    pub fn block_cache_size(mut self, size_bytes: usize) -> Self {
        let cache = Cache::new_lru_cache(size_bytes);
        let mut block_opts = BlockBasedOptions::default();
        block_opts.set_block_cache(&cache);
        self.options.set_block_based_table_factory(&block_opts);
        self
    }
}

/// Builder for configuring and opening an [`AsyncRocksDB`] instance.
pub struct AsyncRocksBuilder {
    db_options: Options,
    column_families: Vec<ColumnFamilyConfig>,
}

impl Default for AsyncRocksBuilder {
    fn default() -> Self {
        let mut db_options = Options::default();
        db_options.create_if_missing(true);
        Self {
            db_options,
            column_families: vec![],
        }
    }
}

impl AsyncRocksBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn add_column_family(mut self, name: &str) -> Self {
        self.column_families.push(ColumnFamilyConfig::new(name));
        self
    }

    pub async fn open<P: AsRef<Path>>(mut self, path: P) -> Result<AsyncRocksDB, AsyncRocksError> {
        let path = path.as_ref().to_path_buf();

        self.db_options.create_if_missing(true);

        if !self.column_families.is_empty() {
            self.db_options.create_missing_column_families(true);
        }

        let db = if self.column_families.is_empty() {
            task::spawn_blocking(move || DB::open(&self.db_options, &path)).await??
        } else {
            let cf_descriptors: Vec<_> = self.column_families
                .into_iter()
                .map(|cf| ColumnFamilyDescriptor::new(cf.name, cf.options))
                .collect();

            task::spawn_blocking(move || {
                DB::open_cf_descriptors(&self.db_options, &path, cf_descriptors)
            })
            .await??
        };

        Ok(AsyncRocksDB {
            inner: Arc::new(db),
        })
    }
}

/// A point-in-time snapshot of the database.
#[derive(Clone)]
pub struct Snapshot {
    db: Arc<DB>,
}

impl Snapshot {
    fn new(db: Arc<DB>) -> Self {
        Self { db }
    }
}

/// Async RocksDB wrapper.
pub struct AsyncRocksDB {
    inner: Arc<DB>,
}

impl AsyncRocksDB {
    pub async fn open_default<P: AsRef<Path>>(path: P) -> Result<Self, AsyncRocksError> {
        AsyncRocksBuilder::new().open(path).await
    }

    pub fn snapshot(&self) -> Snapshot {
        Snapshot::new(self.inner.clone())
    }

    pub async fn put<K, V>(
        &self,
        key: K,
        value: V,
        cf: Option<&str>,
    ) -> Result<(), AsyncRocksError>
    where
        K: AsRef<[u8]> + Send + 'static,
        V: AsRef<[u8]> + Send + 'static,
    {
        let db = self.inner.clone();
        let key = key.as_ref().to_vec();
        let value = value.as_ref().to_vec();
        let cf_name = cf.map(|s| s.to_string());

        task::spawn_blocking(move || {
            let cf_name = cf_name.as_deref().unwrap_or("default");
            let cf = db.cf_handle(cf_name)
                .ok_or(AsyncRocksError::ColumnFamilyNotFound(cf_name.to_string()))?;
            db.put_cf(cf, key, value)?;
            Ok(())
        })
        .await?
    }

    pub async fn get<K>(
        &self,
        key: K,
        cf: Option<&str>,
        snapshot: Option<Snapshot>,
    ) -> Result<Option<Vec<u8>>, AsyncRocksError>
    where
        K: AsRef<[u8]> + Send + 'static,
    {
        let db = self.inner.clone();
        let key = key.as_ref().to_vec();
        let cf_name = cf.map(|s| s.to_string());

        task::spawn_blocking(move || {
            let cf_name = cf_name.as_deref().unwrap_or("default");
            let cf = db.cf_handle(cf_name)
                .ok_or(AsyncRocksError::ColumnFamilyNotFound(cf_name.to_string()))?;

            if let Some(snap) = snapshot {
                let raw_snap = snap.db.snapshot();
                let mut opts = ReadOptions::default();
                opts.set_snapshot(&raw_snap);
                db.get_cf_opt(cf, &key, &opts)
            } else {
                db.get_cf(cf, &key)
            }
            .map_err(Into::into)
        })
        .await?
    }

    pub async fn delete<K>(
        &self,
        key: K,
        cf: Option<&str>,
    ) -> Result<(), AsyncRocksError>
    where
        K: AsRef<[u8]> + Send + 'static,
    {
        let db = self.inner.clone();
        let key = key.as_ref().to_vec();
        let cf_name = cf.map(|s| s.to_string());

        task::spawn_blocking(move || {
            let cf_name = cf_name.as_deref().unwrap_or("default");
            let cf = db.cf_handle(cf_name)
                .ok_or(AsyncRocksError::ColumnFamilyNotFound(cf_name.to_string()))?;
            db.delete_cf(cf, key)?;
            Ok(())
        })
        .await?
    }

    pub async fn multi_get<K>(
        &self,
        keys: Vec<K>,
        cf: Option<&str>,
        snapshot: Option<Snapshot>,
    ) -> Result<Vec<Option<Vec<u8>>>, AsyncRocksError>
    where
        K: AsRef<[u8]> + Send + 'static,
    {
        let db = self.inner.clone();
        let keys: Vec<Vec<u8>> = keys.into_iter().map(|k| k.as_ref().to_vec()).collect();
        let cf_name = cf.map(|s| s.to_string());

        task::spawn_blocking(move || {
            let cf_name = cf_name.as_deref().unwrap_or("default");
            let cf = db.cf_handle(cf_name)
                .ok_or(AsyncRocksError::ColumnFamilyNotFound(cf_name.to_string()))?;

            if let Some(snap) = snapshot {
                let raw_snap = snap.db.snapshot();
                let mut opts = ReadOptions::default();
                opts.set_snapshot(&raw_snap);
                db.multi_get_cf_opt(keys.iter().map(|k| (&cf, k)), &opts)
            } else {
                db.multi_get_cf(keys.iter().map(|k| (&cf, k)))
            }
            .into_iter()
            .map(|r| r.map_err(Into::into))
            .collect()
        })
        .await?
    }

    pub async fn multi_delete<K>(
        &self,
        keys: Vec<K>,
        cf: Option<&str>,
    ) -> Result<(), AsyncRocksError>
    where
        K: AsRef<[u8]> + Send + 'static,
    {
        let db = self.inner.clone();
        let keys: Vec<Vec<u8>> = keys.into_iter().map(|k| k.as_ref().to_vec()).collect();
        let cf_name = cf.map(|s| s.to_string());

        task::spawn_blocking(move || {
            let mut batch = rocksdb::WriteBatch::default();
            let cf_name = cf_name.as_deref().unwrap_or("default");
            let cf = db.cf_handle(cf_name)
                .ok_or(AsyncRocksError::ColumnFamilyNotFound(cf_name.to_string()))?;

            for key in keys {
                batch.delete_cf(&cf, &key);
            }
            db.write(batch)?;
            Ok(())
        })
        .await?
    }

    pub async fn flush(&self) -> Result<(), AsyncRocksError> {
        let db = self.inner.clone();
        task::spawn_blocking(move || db.flush()).await??;
        Ok(())
    }

    pub async fn compact_range<K: AsRef<[u8]>>(
        &self,
        start: Option<K>,
        end: Option<K>,
        cf: Option<&str>,
    ) -> Result<(), AsyncRocksError> {
        let db = self.inner.clone();
        let start = start.map(|k| k.as_ref().to_vec());
        let end = end.map(|k| k.as_ref().to_vec());
        let cf_name = cf.map(|s| s.to_string());

        task::spawn_blocking(move || {
            let cf_name = cf_name.as_deref().unwrap_or("default");
            let cf = db.cf_handle(cf_name)
                .ok_or(AsyncRocksError::ColumnFamilyNotFound(cf_name.to_string()))?;
            db.compact_range_cf(&cf, start.as_deref(), end.as_deref());
            Ok(())
        })
        .await?
    }

    pub async fn all(
        &self,
        cf: Option<&str>,
        snapshot: Option<Snapshot>,
    ) -> Result<Vec<(Vec<u8>, Vec<u8>)>, AsyncRocksError> {
        let db = self.inner.clone();
        let cf_name = cf.map(|s| s.to_string());

        task::spawn_blocking(move || {
            let cf_name = cf_name.as_deref().unwrap_or("default");
            let cf = db.cf_handle(cf_name)
                .ok_or(AsyncRocksError::ColumnFamilyNotFound(cf_name.to_string()))?;

            let iter = if let Some(snap) = snapshot {
                let raw_snap = snap.db.snapshot();
                let mut opts = ReadOptions::default();
                opts.set_snapshot(&raw_snap);
                db.iterator_cf_opt(cf, opts, IteratorMode::Start)
            } else {
                db.iterator_cf(cf, IteratorMode::Start)
            };

            iter.map(|r| r.map(|(k, v)| (k.to_vec(), v.to_vec())))
                .collect::<Result<Vec<_>, _>>()
                .map_err(Into::into)
        })
        .await?
    }

    pub async fn prefix_all<P>(
        &self,
        prefix: P,
        cf: Option<&str>,
        snapshot: Option<Snapshot>,
    ) -> Result<Vec<(Vec<u8>, Vec<u8>)>, AsyncRocksError>
    where
        P: AsRef<[u8]> + Send + 'static,
    {
        let db = self.inner.clone();
        let prefix = prefix.as_ref().to_vec();
        let cf_name = cf.map(|s| s.to_string());

        task::spawn_blocking(move || {
            let cf_name = cf_name.as_deref().unwrap_or("default");
            let cf = db.cf_handle(cf_name)
                .ok_or(AsyncRocksError::ColumnFamilyNotFound(cf_name.to_string()))?;

            let mut opts = ReadOptions::default();
            opts.set_prefix_same_as_start(true);

            if let Some(snap) = snapshot {
                let raw_snap = snap.db.snapshot();
                opts.set_snapshot(&raw_snap);
            }

            let iter = db.iterator_cf_opt(
                cf,
                opts,
                IteratorMode::From(&prefix, rocksdb::Direction::Forward),
            );

            iter.take_while(|r| {
                r.as_ref()
                    .map(|(k, _)| k.starts_with(&prefix))
                    .unwrap_or(false)
            })
            .map(|r| r.map(|(k, v)| (k.to_vec(), v.to_vec())))
            .collect::<Result<Vec<_>, _>>()
            .map_err(Into::into)
        })
        .await?
    }
}