Struct DBBuilder 

pub struct DBBuilder { /* private fields */ }

Builder for creating database instances with custom configuration.

The DBBuilder provides a flexible way to configure databases with options for:

• Custom AOF (Append-Only File) paths separate from the logical database path
• In-memory databases
• Full configuration control
• Automatic startup replay

Examples

Basic usage with custom AOF path

use spatio::DBBuilder;

let temp_path = std::env::temp_dir().join("test_db.aof");
let db = DBBuilder::new()
    .aof_path(&temp_path)
    .build()?;

db.insert("key", b"value", None)?;

In-memory database

use spatio::DBBuilder;

let db = DBBuilder::new()
    .in_memory()
    .build()?;

Full configuration

use spatio::{DBBuilder, Config, SyncPolicy};
use std::time::Duration;

let config = Config::with_geohash_precision(10)
    .with_sync_policy(SyncPolicy::Always)
    .with_default_ttl(Duration::from_secs(3600));

let temp_path = std::env::temp_dir().join("high_precision.aof");
let db = DBBuilder::new()
    .aof_path(&temp_path)
    .config(config)
    .build()?;

Implementations

impl DBBuilder

pub fn new() -> Self

Create a new database builder with default configuration.

By default, creates an in-memory database. Use aof_path() to enable persistence.

Examples

use spatio::DBBuilder;

let builder = DBBuilder::new();

Examples found in repository

examples/persistence_lifecycle.rs (line 96)

fn demo_custom_aof_path() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 2: Custom AOF Path ---");

    let aof_path = "/tmp/spatio_custom.aof";

    // First session: Create database with custom AOF path
    {
        println!("Session 1: Creating database with custom AOF path...");
        let db = DBBuilder::new().aof_path(aof_path).build()?;

        db.insert("config:version", b"1.0.0", None)?;
        db.insert("config:environment", b"production", None)?;

        println!("  ✓ AOF file: {}", aof_path);
        println!("  ✓ Inserted configuration data");

        // Force sync to ensure data is on disk
        db.sync()?;
        println!("  ✓ Manually synced to disk");
    }

    // Second session: Reopen with same AOF path
    {
        println!("Session 2: Reopening database...");
        let db = DBBuilder::new().aof_path(aof_path).build()?;

        let version = db.get("config:version")?.unwrap();
        let environment = db.get("config:environment")?.unwrap();

        println!("  ✓ Version: {}", String::from_utf8_lossy(&version));
        println!("  ✓ Environment: {}", String::from_utf8_lossy(&environment));
    }

    println!();
    Ok(())
}

/// Demo 3: Spatial data persistence and index reconstruction
fn demo_spatial_persistence() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 3: Spatial Data Persistence ---");

    let db_path = "/tmp/spatio_demo_spatial.db";

    // First session: Insert spatial data
    {
        println!("Session 1: Inserting spatial data...");
        let db = Spatio::open(db_path)?;

        // Insert major cities
        let cities = vec![
            ("New York", Point::new(40.7128, -74.0060)),
            ("Los Angeles", Point::new(34.0522, -118.2437)),
            ("Chicago", Point::new(41.8781, -87.6298)),
            ("Houston", Point::new(29.7604, -95.3698)),
            ("Phoenix", Point::new(33.4484, -112.0740)),
        ];

        for (name, point) in cities {
            db.insert_point("cities", &point, name.as_bytes(), None)?;
            println!("  ✓ Inserted city: {}", name);
        }

        let stats = db.stats()?;
        println!("  ✓ Total keys: {}", stats.key_count);
    }

    // Second session: Query spatial data (indexes automatically rebuilt)
    {
        println!("Session 2: Querying spatial data (indexes rebuilt)...");
        let db = Spatio::open(db_path)?;

        // Find cities near New York
        let nyc = Point::new(40.7128, -74.0060);
        let nearby = db.query_within_radius("cities", &nyc, 500_000.0, 10)?; // 500km radius

        println!(
            "  ✓ Found {} cities within 500km of New York:",
            nearby.len()
        );
        for (point, data) in nearby {
            let name = String::from_utf8_lossy(&data);
            println!("    - {} at ({:.4}, {:.4})", name, point.lat, point.lon);
        }

        // Count cities in a bounding box
        let count = db.count_within_radius("cities", &nyc, 500_000.0)?;
        println!("  ✓ Count verification: {} cities", count);
    }

    println!();
    Ok(())
}

/// Demo 4: Explicit graceful shutdown with error handling
fn demo_graceful_shutdown() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 4: Graceful Shutdown ---");

    let db_path = "/tmp/spatio_demo_shutdown.db";

    println!("Creating database and inserting critical data...");
    let mut db = Spatio::open(db_path)?;

    // Insert critical data
    db.insert("transaction:001", b"payment_processed", None)?;
    db.insert("transaction:002", b"refund_pending", None)?;

    println!("  ✓ Critical data inserted");

    // Force sync before critical operations
    db.sync()?;
    println!("  ✓ Forced sync to disk");

    // Add TTL data
    let opts = SetOptions::with_ttl(Duration::from_secs(300));
    db.insert("session:xyz", b"temporary_session", Some(opts))?;
    println!("  ✓ Added temporary session with 5-minute TTL");

    // Explicit close with error handling
    println!("Performing explicit graceful shutdown...");
    match db.close() {
        Ok(_) => println!("  ✓ Database closed successfully"),
        Err(e) => {
            eprintln!("  ✗ Error during close: {}", e);
            return Err(e.into());
        }
    }

    // Verify we can't use closed database
    match db.insert("should_fail", b"data", None) {
        Err(e) => println!("  ✓ Correctly rejected operation on closed database: {}", e),
        Ok(_) => println!("  ✗ Unexpectedly accepted operation on closed database"),
    }

    println!();
    Ok(())
}

/// Demo 5: Configuration-based persistence with different sync policies
fn demo_config_based_persistence() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 5: Configuration-Based Persistence ---");

    // High-durability configuration (sync always)
    {
        println!("Config 1: Always sync (maximum durability)");
        let config = Config::default().with_sync_policy(SyncPolicy::Always);

        let db = DBBuilder::new()
            .aof_path("/tmp/spatio_always_sync.aof")
            .config(config)
            .build()?;

        db.insert("critical:data", b"financial_transaction", None)?;
        println!("  ✓ Every write immediately synced to disk");
    }

    // Balanced configuration (sync every second)
    {
        println!("Config 2: Sync every second (recommended)");
        let config = Config::with_geohash_precision(10)
            .with_sync_policy(SyncPolicy::EverySecond)
            .with_default_ttl(Duration::from_secs(3600));

        let db = DBBuilder::new()
            .aof_path("/tmp/spatio_balanced.aof")
            .config(config)
            .build()?;

        db.insert("balanced:data", b"application_data", None)?;
        println!("  ✓ High precision (10) with periodic sync");
        println!("  ✓ Default TTL: 1 hour");
    }

    // In-memory configuration (no persistence)
    {
        println!("Config 3: In-memory (no persistence)");
        let db = DBBuilder::new().in_memory().build()?;

        db.insert("cache:key", b"temporary_value", None)?;
        println!("  ✓ Fast in-memory storage, no disk I/O");
    }

    println!();
    Ok(())
}

pub fn aof_path<P: Into<PathBuf>>(self, path: P) -> Self

Set the AOF (Append-Only File) path for persistence.

When an AOF path is set:

• The database will persist all writes to this file
• On startup, the AOF will be replayed to restore state
• The database is durable across restarts

If the file doesn’t exist, it will be created. If it exists, it will be opened and replayed to restore previous state.

Arguments

• path - File system path for the AOF file

Examples

use spatio::DBBuilder;

let temp_path = std::env::temp_dir().join("myapp_data.aof");
let db = DBBuilder::new()
    .aof_path(&temp_path)
    .build()?;

Examples found in repository

examples/persistence_lifecycle.rs (line 96)

fn demo_custom_aof_path() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 2: Custom AOF Path ---");

    let aof_path = "/tmp/spatio_custom.aof";

    // First session: Create database with custom AOF path
    {
        println!("Session 1: Creating database with custom AOF path...");
        let db = DBBuilder::new().aof_path(aof_path).build()?;

        db.insert("config:version", b"1.0.0", None)?;
        db.insert("config:environment", b"production", None)?;

        println!("  ✓ AOF file: {}", aof_path);
        println!("  ✓ Inserted configuration data");

        // Force sync to ensure data is on disk
        db.sync()?;
        println!("  ✓ Manually synced to disk");
    }

    // Second session: Reopen with same AOF path
    {
        println!("Session 2: Reopening database...");
        let db = DBBuilder::new().aof_path(aof_path).build()?;

        let version = db.get("config:version")?.unwrap();
        let environment = db.get("config:environment")?.unwrap();

        println!("  ✓ Version: {}", String::from_utf8_lossy(&version));
        println!("  ✓ Environment: {}", String::from_utf8_lossy(&environment));
    }

    println!();
    Ok(())
}

/// Demo 3: Spatial data persistence and index reconstruction
fn demo_spatial_persistence() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 3: Spatial Data Persistence ---");

    let db_path = "/tmp/spatio_demo_spatial.db";

    // First session: Insert spatial data
    {
        println!("Session 1: Inserting spatial data...");
        let db = Spatio::open(db_path)?;

        // Insert major cities
        let cities = vec![
            ("New York", Point::new(40.7128, -74.0060)),
            ("Los Angeles", Point::new(34.0522, -118.2437)),
            ("Chicago", Point::new(41.8781, -87.6298)),
            ("Houston", Point::new(29.7604, -95.3698)),
            ("Phoenix", Point::new(33.4484, -112.0740)),
        ];

        for (name, point) in cities {
            db.insert_point("cities", &point, name.as_bytes(), None)?;
            println!("  ✓ Inserted city: {}", name);
        }

        let stats = db.stats()?;
        println!("  ✓ Total keys: {}", stats.key_count);
    }

    // Second session: Query spatial data (indexes automatically rebuilt)
    {
        println!("Session 2: Querying spatial data (indexes rebuilt)...");
        let db = Spatio::open(db_path)?;

        // Find cities near New York
        let nyc = Point::new(40.7128, -74.0060);
        let nearby = db.query_within_radius("cities", &nyc, 500_000.0, 10)?; // 500km radius

        println!(
            "  ✓ Found {} cities within 500km of New York:",
            nearby.len()
        );
        for (point, data) in nearby {
            let name = String::from_utf8_lossy(&data);
            println!("    - {} at ({:.4}, {:.4})", name, point.lat, point.lon);
        }

        // Count cities in a bounding box
        let count = db.count_within_radius("cities", &nyc, 500_000.0)?;
        println!("  ✓ Count verification: {} cities", count);
    }

    println!();
    Ok(())
}

/// Demo 4: Explicit graceful shutdown with error handling
fn demo_graceful_shutdown() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 4: Graceful Shutdown ---");

    let db_path = "/tmp/spatio_demo_shutdown.db";

    println!("Creating database and inserting critical data...");
    let mut db = Spatio::open(db_path)?;

    // Insert critical data
    db.insert("transaction:001", b"payment_processed", None)?;
    db.insert("transaction:002", b"refund_pending", None)?;

    println!("  ✓ Critical data inserted");

    // Force sync before critical operations
    db.sync()?;
    println!("  ✓ Forced sync to disk");

    // Add TTL data
    let opts = SetOptions::with_ttl(Duration::from_secs(300));
    db.insert("session:xyz", b"temporary_session", Some(opts))?;
    println!("  ✓ Added temporary session with 5-minute TTL");

    // Explicit close with error handling
    println!("Performing explicit graceful shutdown...");
    match db.close() {
        Ok(_) => println!("  ✓ Database closed successfully"),
        Err(e) => {
            eprintln!("  ✗ Error during close: {}", e);
            return Err(e.into());
        }
    }

    // Verify we can't use closed database
    match db.insert("should_fail", b"data", None) {
        Err(e) => println!("  ✓ Correctly rejected operation on closed database: {}", e),
        Ok(_) => println!("  ✗ Unexpectedly accepted operation on closed database"),
    }

    println!();
    Ok(())
}

/// Demo 5: Configuration-based persistence with different sync policies
fn demo_config_based_persistence() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 5: Configuration-Based Persistence ---");

    // High-durability configuration (sync always)
    {
        println!("Config 1: Always sync (maximum durability)");
        let config = Config::default().with_sync_policy(SyncPolicy::Always);

        let db = DBBuilder::new()
            .aof_path("/tmp/spatio_always_sync.aof")
            .config(config)
            .build()?;

        db.insert("critical:data", b"financial_transaction", None)?;
        println!("  ✓ Every write immediately synced to disk");
    }

    // Balanced configuration (sync every second)
    {
        println!("Config 2: Sync every second (recommended)");
        let config = Config::with_geohash_precision(10)
            .with_sync_policy(SyncPolicy::EverySecond)
            .with_default_ttl(Duration::from_secs(3600));

        let db = DBBuilder::new()
            .aof_path("/tmp/spatio_balanced.aof")
            .config(config)
            .build()?;

        db.insert("balanced:data", b"application_data", None)?;
        println!("  ✓ High precision (10) with periodic sync");
        println!("  ✓ Default TTL: 1 hour");
    }

    // In-memory configuration (no persistence)
    {
        println!("Config 3: In-memory (no persistence)");
        let db = DBBuilder::new().in_memory().build()?;

        db.insert("cache:key", b"temporary_value", None)?;
        println!("  ✓ Fast in-memory storage, no disk I/O");
    }

    println!();
    Ok(())
}

pub fn in_memory(self) -> Self

Create an in-memory database with no persistence.

In-memory databases:

• Are extremely fast (no disk I/O)
• Do not persist data across restarts
• Are ideal for caching, testing, and ephemeral data

Examples

use spatio::DBBuilder;

let db = DBBuilder::new()
    .in_memory()
    .build()?;

Examples found in repository

examples/persistence_lifecycle.rs (line 263)

fn demo_config_based_persistence() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 5: Configuration-Based Persistence ---");

    // High-durability configuration (sync always)
    {
        println!("Config 1: Always sync (maximum durability)");
        let config = Config::default().with_sync_policy(SyncPolicy::Always);

        let db = DBBuilder::new()
            .aof_path("/tmp/spatio_always_sync.aof")
            .config(config)
            .build()?;

        db.insert("critical:data", b"financial_transaction", None)?;
        println!("  ✓ Every write immediately synced to disk");
    }

    // Balanced configuration (sync every second)
    {
        println!("Config 2: Sync every second (recommended)");
        let config = Config::with_geohash_precision(10)
            .with_sync_policy(SyncPolicy::EverySecond)
            .with_default_ttl(Duration::from_secs(3600));

        let db = DBBuilder::new()
            .aof_path("/tmp/spatio_balanced.aof")
            .config(config)
            .build()?;

        db.insert("balanced:data", b"application_data", None)?;
        println!("  ✓ High precision (10) with periodic sync");
        println!("  ✓ Default TTL: 1 hour");
    }

    // In-memory configuration (no persistence)
    {
        println!("Config 3: In-memory (no persistence)");
        let db = DBBuilder::new().in_memory().build()?;

        db.insert("cache:key", b"temporary_value", None)?;
        println!("  ✓ Fast in-memory storage, no disk I/O");
    }

    println!();
    Ok(())
}

pub fn config(self, config: Config) -> Self

Set the database configuration.

The configuration controls:

• Geohash precision for spatial indexing
• Sync policy (durability vs performance tradeoff)
• Default TTL for automatic expiration

Arguments

• config - Database configuration

Examples

use spatio::{DBBuilder, Config, SyncPolicy};
use std::time::Duration;

let config = Config::with_geohash_precision(10)
    .with_sync_policy(SyncPolicy::Always)
    .with_default_ttl(Duration::from_secs(3600));

let temp_path = std::env::temp_dir().join("high_precision.aof");
let db = DBBuilder::new()
    .aof_path(&temp_path)
    .config(config)
    .build()?;

Examples found in repository

examples/persistence_lifecycle.rs (line 236)

fn demo_config_based_persistence() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 5: Configuration-Based Persistence ---");

    // High-durability configuration (sync always)
    {
        println!("Config 1: Always sync (maximum durability)");
        let config = Config::default().with_sync_policy(SyncPolicy::Always);

        let db = DBBuilder::new()
            .aof_path("/tmp/spatio_always_sync.aof")
            .config(config)
            .build()?;

        db.insert("critical:data", b"financial_transaction", None)?;
        println!("  ✓ Every write immediately synced to disk");
    }

    // Balanced configuration (sync every second)
    {
        println!("Config 2: Sync every second (recommended)");
        let config = Config::with_geohash_precision(10)
            .with_sync_policy(SyncPolicy::EverySecond)
            .with_default_ttl(Duration::from_secs(3600));

        let db = DBBuilder::new()
            .aof_path("/tmp/spatio_balanced.aof")
            .config(config)
            .build()?;

        db.insert("balanced:data", b"application_data", None)?;
        println!("  ✓ High precision (10) with periodic sync");
        println!("  ✓ Default TTL: 1 hour");
    }

    // In-memory configuration (no persistence)
    {
        println!("Config 3: In-memory (no persistence)");
        let db = DBBuilder::new().in_memory().build()?;

        db.insert("cache:key", b"temporary_value", None)?;
        println!("  ✓ Fast in-memory storage, no disk I/O");
    }

    println!();
    Ok(())
}

pub fn history_capacity(self, capacity: usize) -> Self

Enable update history tracking with a fixed per-key capacity.

Each key retains at most capacity recent operations (set/delete).

pub fn build(self) -> Result<DB>

Build the database with the configured options.

This method:

1. Creates the database instance
2. Opens the AOF file (if persistence is enabled)
3. Replays the AOF to restore previous state (startup replay)
4. Rebuilds spatial indexes
5. Returns a ready-to-use database

Errors

Returns an error if:

• The AOF file cannot be opened or created
• The AOF file is corrupted and cannot be replayed
• File system permissions prevent access

Examples

use spatio::DBBuilder;

let temp_path = std::env::temp_dir().join("my_data.aof");
let db = DBBuilder::new()
    .aof_path(&temp_path)
    .build()?;

db.insert("key", b"value", None)?;

Examples found in repository

examples/persistence_lifecycle.rs (line 96)

fn demo_custom_aof_path() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 2: Custom AOF Path ---");

    let aof_path = "/tmp/spatio_custom.aof";

    // First session: Create database with custom AOF path
    {
        println!("Session 1: Creating database with custom AOF path...");
        let db = DBBuilder::new().aof_path(aof_path).build()?;

        db.insert("config:version", b"1.0.0", None)?;
        db.insert("config:environment", b"production", None)?;

        println!("  ✓ AOF file: {}", aof_path);
        println!("  ✓ Inserted configuration data");

        // Force sync to ensure data is on disk
        db.sync()?;
        println!("  ✓ Manually synced to disk");
    }

    // Second session: Reopen with same AOF path
    {
        println!("Session 2: Reopening database...");
        let db = DBBuilder::new().aof_path(aof_path).build()?;

        let version = db.get("config:version")?.unwrap();
        let environment = db.get("config:environment")?.unwrap();

        println!("  ✓ Version: {}", String::from_utf8_lossy(&version));
        println!("  ✓ Environment: {}", String::from_utf8_lossy(&environment));
    }

    println!();
    Ok(())
}

/// Demo 3: Spatial data persistence and index reconstruction
fn demo_spatial_persistence() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 3: Spatial Data Persistence ---");

    let db_path = "/tmp/spatio_demo_spatial.db";

    // First session: Insert spatial data
    {
        println!("Session 1: Inserting spatial data...");
        let db = Spatio::open(db_path)?;

        // Insert major cities
        let cities = vec![
            ("New York", Point::new(40.7128, -74.0060)),
            ("Los Angeles", Point::new(34.0522, -118.2437)),
            ("Chicago", Point::new(41.8781, -87.6298)),
            ("Houston", Point::new(29.7604, -95.3698)),
            ("Phoenix", Point::new(33.4484, -112.0740)),
        ];

        for (name, point) in cities {
            db.insert_point("cities", &point, name.as_bytes(), None)?;
            println!("  ✓ Inserted city: {}", name);
        }

        let stats = db.stats()?;
        println!("  ✓ Total keys: {}", stats.key_count);
    }

    // Second session: Query spatial data (indexes automatically rebuilt)
    {
        println!("Session 2: Querying spatial data (indexes rebuilt)...");
        let db = Spatio::open(db_path)?;

        // Find cities near New York
        let nyc = Point::new(40.7128, -74.0060);
        let nearby = db.query_within_radius("cities", &nyc, 500_000.0, 10)?; // 500km radius

        println!(
            "  ✓ Found {} cities within 500km of New York:",
            nearby.len()
        );
        for (point, data) in nearby {
            let name = String::from_utf8_lossy(&data);
            println!("    - {} at ({:.4}, {:.4})", name, point.lat, point.lon);
        }

        // Count cities in a bounding box
        let count = db.count_within_radius("cities", &nyc, 500_000.0)?;
        println!("  ✓ Count verification: {} cities", count);
    }

    println!();
    Ok(())
}

/// Demo 4: Explicit graceful shutdown with error handling
fn demo_graceful_shutdown() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 4: Graceful Shutdown ---");

    let db_path = "/tmp/spatio_demo_shutdown.db";

    println!("Creating database and inserting critical data...");
    let mut db = Spatio::open(db_path)?;

    // Insert critical data
    db.insert("transaction:001", b"payment_processed", None)?;
    db.insert("transaction:002", b"refund_pending", None)?;

    println!("  ✓ Critical data inserted");

    // Force sync before critical operations
    db.sync()?;
    println!("  ✓ Forced sync to disk");

    // Add TTL data
    let opts = SetOptions::with_ttl(Duration::from_secs(300));
    db.insert("session:xyz", b"temporary_session", Some(opts))?;
    println!("  ✓ Added temporary session with 5-minute TTL");

    // Explicit close with error handling
    println!("Performing explicit graceful shutdown...");
    match db.close() {
        Ok(_) => println!("  ✓ Database closed successfully"),
        Err(e) => {
            eprintln!("  ✗ Error during close: {}", e);
            return Err(e.into());
        }
    }

    // Verify we can't use closed database
    match db.insert("should_fail", b"data", None) {
        Err(e) => println!("  ✓ Correctly rejected operation on closed database: {}", e),
        Ok(_) => println!("  ✗ Unexpectedly accepted operation on closed database"),
    }

    println!();
    Ok(())
}

/// Demo 5: Configuration-based persistence with different sync policies
fn demo_config_based_persistence() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 5: Configuration-Based Persistence ---");

    // High-durability configuration (sync always)
    {
        println!("Config 1: Always sync (maximum durability)");
        let config = Config::default().with_sync_policy(SyncPolicy::Always);

        let db = DBBuilder::new()
            .aof_path("/tmp/spatio_always_sync.aof")
            .config(config)
            .build()?;

        db.insert("critical:data", b"financial_transaction", None)?;
        println!("  ✓ Every write immediately synced to disk");
    }

    // Balanced configuration (sync every second)
    {
        println!("Config 2: Sync every second (recommended)");
        let config = Config::with_geohash_precision(10)
            .with_sync_policy(SyncPolicy::EverySecond)
            .with_default_ttl(Duration::from_secs(3600));

        let db = DBBuilder::new()
            .aof_path("/tmp/spatio_balanced.aof")
            .config(config)
            .build()?;

        db.insert("balanced:data", b"application_data", None)?;
        println!("  ✓ High precision (10) with periodic sync");
        println!("  ✓ Default TTL: 1 hour");
    }

    // In-memory configuration (no persistence)
    {
        println!("Config 3: In-memory (no persistence)");
        let db = DBBuilder::new().in_memory().build()?;

        db.insert("cache:key", b"temporary_value", None)?;
        println!("  ✓ Fast in-memory storage, no disk I/O");
    }

    println!();
    Ok(())
}

Trait Implementations

impl Debug for DBBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DBBuilder

fn default() -> Self

Returns the “default value” for a type.