Getting Started

This guide will help you install DBX and run your first queries.

Table of contents

1. Installation
   1. Rust
   2. .NET (C#, VB.NET, F#)
2. Running Examples
3. Basic Usage
   1. Opening a Database
   2. CRUD Operations
      1. Insert
      2. Get
      3. Delete
      4. Count
4. MVCC Transactions
5. SQL Queries
6. Encryption
7. GPU Acceleration (Optional)
8. Next Steps

---

Installation

Rust

Add DBX to your Cargo.toml:

[dependencies]
dbx-core = "0.2.0-beta"

.NET (C#, VB.NET, F#)

Install via NuGet or use dbx-csharp bindings:

dotnet add package DBX.Client

---

Running Examples

Since v0.2.0, all examples are separated into the dbx-examples package. You can run them using the following commands:

# Run basic quick-start example
cargo run -p dbx-examples --example quick_start

# Run distributed grid server example
cargo run -p dbx-examples --example distributed_grid

# Run 5-Tier storage tiering example
cargo run -p dbx-examples --example storage_tiering

---

Basic Usage

Opening a Database

use dbx_core::Database;

// In-memory database
let db = Database::open_in_memory()?;

// Persistent database
let db = Database::open("./mydata")?;

CRUD Operations

Insert

db.insert("users", b"user:1", b"Alice")?;
db.insert("users", b"user:2", b"Bob")?;

Get

let value = db.get("users", b"user:1")?;
assert_eq!(value, Some(b"Alice".to_vec()));

Delete

db.delete("users", b"user:1")?;

Count

let count = db.count("users")?;
println!("Total users: {}", count);

---

MVCC Transactions

DBX supports ACID transactions with Snapshot Isolation:

use dbx_core::Database;

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

// Begin transaction
let tx = db.begin_transaction()?;

// Consistent reads with Snapshot Isolation
tx.insert("users", b"user:3", b"Charlie")?;
tx.insert("users", b"user:4", b"David")?;

// Commit (or rollback)
tx.commit()?;

---

SQL Queries

DBX supports standard SQL queries:

use dbx_core::Database;
use arrow::array::{Int32Array, RecordBatch};
use arrow::datatypes::{DataType, Field, Schema};
use std::sync::Arc;

let db = Database::open_in_memory()?;

// Create table schema
let schema = Arc::new(Schema::new(vec![
    Field::new("id", DataType::Int32, false),
    Field::new("age", DataType::Int32, false),
]));

// Create data
let batch = RecordBatch::try_new(
    schema.clone(),
    vec![
        Arc::new(Int32Array::from(vec![1, 2, 3])),
        Arc::new(Int32Array::from(vec![25, 30, 35])),
    ],
).unwrap();

// Register table
db.register_table("users", vec![batch]);

// Execute SQL
let results = db.execute_sql("SELECT id, age FROM users WHERE age > 28")?;

---

Encryption

DBX supports AES-256-GCM-SIV and ChaCha20-Poly1305 encryption:

use dbx_core::Database;
use dbx_core::storage::encryption::EncryptionConfig;

// Create encrypted database
let enc = EncryptionConfig::from_password("my-secret-password");
let db = Database::open_encrypted("./secure-data", enc)?;

// Use normally
db.insert("secrets", b"key1", b"sensitive-data")?;

---

GPU Acceleration (Optional)

Enable GPU features in Cargo.toml:

[dependencies]
dbx-core = { version = "0.2.0-beta", features = ["gpu"] }

Use GPU acceleration:

let db = Database::open_in_memory()?;

// ... register data ...

// Sync GPU cache
db.sync_gpu_cache("users")?;

// GPU-accelerated operations
if let Some(gpu) = db.gpu_manager() {
    let sum = gpu.sum("users", "age")?;
    let filtered = gpu.filter_gt("users", "age", 30)?;
}

---

Next Steps

• Architecture Guide — Learn about the 5-Tier Hybrid Storage
• Benchmarks — See performance comparisons
• Examples — Explore more code examples
• API Documentation — Full Rust API reference