Crate aurora_db 

Aurora Database

Aurora is a high-performance, embedded document database designed for speed, durability, and developer ergonomics. It features a tiered storage architecture combining a blazing-fast in-memory cache with reliable, persistent cold storage.

Core Architecture

• Tiered Storage: Automatically manages data between a “hot” cache (DashMap/Moka) and “cold” storage (Sled/MMAP) for optimal performance.
• AQL (Aurora Query Language): A GraphQL-inspired query language for powerful data retrieval, manipulation, and real-time subscriptions.
• Roaring Bitmaps: Uses Roaring Bitmaps for high-performance secondary indexing and bitwise query optimization.
• Write-Ahead Logging (WAL): Ensures crash-consistency and data durability.

Quick Start

use aurora_db::{Aurora, doc, object, FieldType};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Open or create a database
    let db = Aurora::open("my_database.db").await?;

    // Define a collection with schema
    db.new_collection("users", vec![
        ("name", FieldType::SCALAR_STRING, false),
        ("email", FieldType::SCALAR_STRING, true), // Unique constraint
        ("age", FieldType::SCALAR_INT, false),
    ]).await?;

    // Insert a document using the object! macro
    let user_id = db.insert_map("users", object!({
        "name": "Jane Doe",
        "email": "jane@example.com",
        "age": 28
    }).as_object().unwrap().clone()).await?;

    // Run a parametrized AQL query using the doc! macro
    let result = db.execute(doc!(
        "query($minAge: Int) {
            users(where: { age: { gte: $minAge } }) {
                name
                email
            }
        }",
        { "minAge": 21 }
    )).await?;

    // Bind the results back to a Rust struct
    #[derive(serde::Deserialize, Debug)]
    struct User { name: String, email: String }
    let users: Vec<User> = result.bind()?;

    Ok(())
}

Re-exports

pub use crate::db::Aurora;

pub use crate::error::AqlError;

pub use crate::error::ErrorCode;

pub use crate::error::Result;

pub use crate::query::QueryBuilder;

pub use crate::query::SearchBuilder;

pub use crate::query::SimpleQueryBuilder;

pub use types::AuroraConfig;

pub use types::ColdStoreMode;

pub use types::Collection;

pub use types::Document;

pub use types::DurabilityMode;

pub use types::FieldDefinition;

pub use types::FieldType;

pub use types::Value;

pub use crate::parser::validator::InMemorySchema;

pub use crate::parser::validator::SchemaProvider;

pub use crate::parser::validator::ValidationError;

pub use crate::parser::validator::ValidationResult;

pub use crate::parser::validator::validate_document;

pub use crate::parser::executor::ExecutionResult;

pub use crate::parser::executor::MigrationResult;

pub use crate::parser::executor::MutationResult;

pub use crate::parser::executor::QueryResult;

pub use crate::parser::executor::SchemaResult;

pub use crate::parser::executor::SubscriptionResult;

pub use storage::EvictionPolicy;

pub use storage::HotStore;

pub use pubsub::ChangeEvent;

pub use pubsub::ChangeListener;

pub use pubsub::ChangeType;

pub use workers::Job;

pub use workers::JobPriority;

pub use workers::JobStatus;

pub use transaction::TransactionBuffer;

pub use transaction::TransactionId;

Modules

audit

client

computed

db

Aurora Core Engine

error

index

macros

network

parser

Aurora Query Language (AQL) Parser

pubsub

query

Aurora Query System

reactive

search

Aurora Full-Text Search Engine

storage

transaction

types

Aurora Data Types

wal

workers

Macros

array

Constructs an Aurora Value::Array (Vec) from a list of values.

doc

Creates a (String, ExecutionOptions) tuple to be executed by db.execute().

object

Constructs an Aurora Value::Object (HashMap) from key-value pairs.

value

Constructs an Aurora Value from Rust literals.