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. Basic Usage
   1. Opening a Database
   2. CRUD Operations
      1. Insert
      2. Get
      3. Delete
      4. Count
3. MVCC Transactions
4. SQL Queries
5. Encryption
   1. Key Rotation
6. GPU Acceleration (Optional)
7. Next Steps

---

Installation

Rust

Add DBX to your Cargo.toml:

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

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

Install via NuGet:

dotnet add package DBX.Client

---

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")?;

Key Rotation

// Rotate encryption key
let new_enc = EncryptionConfig::from_password("new-password");
let count = db.rotate_key(new_enc)?;
println!("Rotated {} records", count);

---

GPU Acceleration (Optional)

Enable GPU features in Cargo.toml:

[dependencies]
dbx-core = { version = "0.0.6-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