Database

pub fn open(path: &str) -> Result<Database>

use jasonisnthappy::Database;

let db = Database::open("my.db")?;

pub fn open_with_options(path: &str, opts: DatabaseOptions) -> Result<Database>

use jasonisnthappy::{Database, DatabaseOptions};

let opts = DatabaseOptions {
    cache_size: 50_000,
    auto_checkpoint_threshold: 2000,
    read_only: false,
    max_bulk_operations: 100_000,
    max_document_size: 67_108_864,
    ..Default::default()
};

let db = Database::open_with_options("my.db", opts)?;

pub fn collection(&self, name: &str) -> Collection

let users = db.collection("users");
users.insert(json!({"name": "Alice", "age": 30}))?;

pub fn list_collections(&self) -> Result<Vec<String>>

let collections = db.list_collections()?;
for name in collections {
    println!("Collection: {}", name);
}

pub fn collection_stats(&self, name: &str) -> Result<CollectionInfo>

let stats = db.collection_stats("users")?;
println!("Documents: {}", stats.document_count);
println!("Indexes: {}", stats.indexes.len());

pub fn begin(&self) -> Result<Transaction>

let mut tx = db.begin()?;
let mut users = tx.collection("users")?;
// Perform operations...
tx.commit()?;

pub fn run_transaction<F, R>(&self, f: F) -> Result<R>
where
    F: Fn(&mut Transaction) -> Result<R>

let result = db.run_transaction(|tx| {
    let mut users = tx.collection("users")?;
    users.insert(json!({"name": "Bob", "age": 25}))?;
    Ok(())
})?;

pub fn create_index(
    &self,
    collection_name: &str,
    index_name: &str,
    field: &str,
    unique: bool
) -> Result<()>

db.create_index("users", "email_idx", "email", true)?;

pub fn create_compound_index(
    &self,
    collection_name: &str,
    index_name: &str,
    fields: &[&str],
    unique: bool
) -> Result<()>

db.create_compound_index("users", "city_age_idx", &["city", "age"], false)?;

pub fn create_text_index(
    &self,
    collection_name: &str,
    index_name: &str,
    fields: &[&str]
) -> Result<()>

db.create_text_index("posts", "search_idx", &["title", "body"])?;

pub fn drop_index(&self, collection_name: &str, index_name: &str) -> Result<()>

db.drop_index("users", "email_idx")?;

pub fn list_indexes(&self, collection_name: &str) -> Result<Vec<IndexInfo>>

pub fn set_schema(&self, collection_name: &str, schema: Schema) -> Result<()>

use jasonisnthappy::{Schema, ValueType};
use std::collections::HashMap;

let mut schema = Schema::new();
schema.value_type = Some(ValueType::Object);
schema.required = Some(vec!["name".to_string(), "email".to_string()]);

let mut properties = HashMap::new();
let mut name_schema = Schema::new();
name_schema.value_type = Some(ValueType::String);
name_schema.min_length = Some(1);
properties.insert("name".to_string(), name_schema);

schema.properties = Some(properties);
db.set_schema("users", schema)?;

pub fn get_schema(&self, collection_name: &str) -> Option<Schema>

pub fn remove_schema(&self, collection_name: &str) -> Result<()>

pub fn checkpoint(&self) -> Result<()>

db.checkpoint()?;

pub fn garbage_collect(&self) -> Result<GarbageCollectionStats>

let stats = db.garbage_collect()?;
println!("Freed {} pages", stats.pages_freed);

pub fn backup(&self, dest_path: &str) -> Result<()>

db.backup("./backups/mydb-2024-01-15.db")?;

pub fn verify_backup(backup_path: &str) -> Result<BackupInfo>

let info = Database::verify_backup("./backups/mydb.db")?;
println!("Backup has {} collections", info.num_collections);

pub fn close(&self) -> Result<()>

db.close()?;

pub fn info(&self) -> Result<DatabaseInfo>

let info = db.info()?;
println!("Database: {}", info.path);
println!("Collections: {}", info.collections.len());
println!("Total documents: {}", info.total_documents);

pub fn metrics(&self) -> MetricsSnapshot

let metrics = db.metrics();
println!("Page reads: {}", metrics.page_reads);
println!("Page writes: {}", metrics.page_writes);

pub fn path(&self) -> &str

pub fn is_read_only(&self) -> bool

pub fn set_transaction_config(&self, config: TransactionConfig)

use jasonisnthappy::database::TransactionConfig;

let config = TransactionConfig {
    max_retries: 5,
    retry_backoff_base_ms: 2,
    max_retry_backoff_ms: 200,
};
db.set_transaction_config(config);

pub fn set_auto_checkpoint_threshold(&self, threshold: u64)

db.set_auto_checkpoint_threshold(2000);