Document Store: CRUD Operations

Document Store: CRUD Operations

Part of: HeliosDB Document Store User Guide

CRUD Operations

Insert Operations

insertOne

MongoDB API:

use mongodb::bson::doc;

let doc = doc! {
    "name": "Alice Smith",
    "email": "alice@example.com",
    "age": 30,
    "role": "developer",
    "skills": ["Rust", "MongoDB", "PostgreSQL"],
    "address": {
        "city": "San Francisco",
        "state": "CA",
        "zip": "94102"
    }
};

let result = collection.insert_one(doc, None).await?;
println!("Inserted ID: {}", result.inserted_id);

HeliosDB Native API:

use heliosdb_document::{DocumentStore, Collection, DocumentId, InsertOptions};
use serde_json::json;

let doc = store.insert(
    &Collection::new("users"),
    &DocumentId::new("alice_smith"),
    json!({
        "name": "Alice Smith",
        "email": "alice@example.com",
        "age": 30,
        "role": "developer",
        "skills": ["Rust", "MongoDB", "PostgreSQL"],
        "address": {
            "city": "San Francisco",
            "state": "CA",
            "zip": "94102"
        }
    })
)?;

insertMany

Batch Insert for Performance:

let users = vec![
    doc! { "name": "Alice", "age": 30 },
    doc! { "name": "Bob", "age": 25 },
    doc! { "name": "Carol", "age": 35 },
];

let result = collection.insert_many(users, None).await?;
println!("Inserted {} documents", result.inserted_ids.len());

// Performance: 120K docs/sec in batches of 100-1000

HeliosDB Native (Transaction):

use heliosdb_document::{IsolationLevel, Document};

let txn = store.begin_transaction(IsolationLevel::SnapshotIsolation)?;

for i in 0..1000 {
    let doc = Document::new(
        DocumentId::new(&format!("user{}", i)),
        Collection::new("users"),
        json!({
            "name": format!("User {}", i),
            "email": format!("user{}@example.com", i),
            "created_at": chrono::Utc::now(),
        }),
    );
    txn.record_insert(doc)?;
}

store.commit_transaction(txn).await?;

Read Operations

findOne

// Find single document by ID
let doc = collection.find_one(doc! { "_id": "alice_smith" }, None).await?;

if let Some(user) = doc {
    println!("Found: {:?}", user);
}

find

Simple Query:

// Find all developers
let cursor = collection.find(doc! { "role": "developer" }, None).await?;

while cursor.advance().await? {
    let doc = cursor.deserialize_current()?;
    println!("{:?}", doc);
}

Query with Projection:

use mongodb::options::FindOptions;

let options = FindOptions::builder()
    .projection(doc! { "name": 1, "email": 1, "_id": 0 })
    .build();

let cursor = collection.find(doc! { "age": { "$gte": 25 } }, options).await?;

Query with Sorting and Limit:

let options = FindOptions::builder()
    .sort(doc! { "age": -1 })  // Descending
    .limit(10)
    .skip(20)  // Pagination
    .build();

let cursor = collection.find(doc! {}, options).await?;

countDocuments

let count = collection.count_documents(doc! { "role": "developer" }, None).await?;
println!("Total developers: {}", count);

Update Operations

updateOne

Replace Single Field:

let result = collection.update_one(
    doc! { "_id": "alice_smith" },
    doc! { "$set": { "age": 31 } },
    None,
).await?;

println!("Modified: {}", result.modified_count);

Update Multiple Fields:

let result = collection.update_one(
    doc! { "email": "alice@example.com" },
    doc! {
        "$set": {
            "age": 31,
            "role": "Senior Developer",
            "updated_at": chrono::Utc::now().to_rfc3339()
        }
    },
    None,
).await?;

Array Operations:

// Add to array
collection.update_one(
    doc! { "_id": "alice_smith" },
    doc! { "$push": { "skills": "Kubernetes" } },
    None,
).await?;

// Remove from array
collection.update_one(
    doc! { "_id": "alice_smith" },
    doc! { "$pull": { "skills": "MongoDB" } },
    None,
).await?;

// Add unique to array
collection.update_one(
    doc! { "_id": "alice_smith" },
    doc! { "$addToSet": { "skills": "Docker" } },
    None,
).await?;

updateMany

// Update all developers
let result = collection.update_many(
    doc! { "role": "developer" },
    doc! { "$set": { "department": "Engineering" } },
    None,
).await?;

println!("Updated {} documents", result.modified_count);

replaceOne

Replace Entire Document:

let new_doc = doc! {
    "name": "Alice Johnson",  // Changed last name
    "email": "alice.j@example.com",
    "age": 31,
    "role": "Engineering Manager",
    "skills": ["Leadership", "Architecture"],
};

let result = collection.replace_one(
    doc! { "_id": "alice_smith" },
    new_doc,
    None,
).await?;

Delete Operations

deleteOne

let result = collection.delete_one(doc! { "_id": "alice_smith" }, None).await?;
println!("Deleted: {}", result.deleted_count);

deleteMany

// Delete all inactive users
let result = collection.delete_many(
    doc! { "status": "inactive" },
    None,
).await?;

println!("Deleted {} inactive users", result.deleted_count);

Soft Delete Pattern:

// Instead of deleting, mark as deleted
collection.update_many(
    doc! { "status": "inactive" },
    doc! {
        "$set": {
            "deleted": true,
            "deleted_at": chrono::Utc::now().to_rfc3339()
        }
    },
    None,
).await?;

// Query only active documents
let active = collection.find(
    doc! { "$or": [
        { "deleted": { "$exists": false } },
        { "deleted": false }
    ]},
    None,
).await?;

Bulk Operations

bulkWrite

use mongodb::options::WriteModel;

let operations = vec![
    WriteModel::InsertOne {
        document: doc! { "name": "User 1" },
        ..Default::default()
    },
    WriteModel::UpdateOne {
        filter: doc! { "name": "Alice" },
        update: doc! { "$set": { "age": 31 } }.into(),
        ..Default::default()
    },
    WriteModel::DeleteOne {
        filter: doc! { "status": "deleted" },
        ..Default::default()
    },
];

let result = collection.bulk_write(operations, None).await?;
println!("Inserted: {}, Modified: {}, Deleted: {}",
    result.inserted_count,
    result.modified_count,
    result.deleted_count
);

---

Navigation: ← Previous: Quick Start | Back to Index | Next: Query Language →