Write Model & Data Lifecycle

Lifecycle at a Glance

eeCLOUD is designed around ordered data and deterministic operations. A record typically follows this lifecycle:

WRITE  →  READ  →  UPDATE (by address)  →  DELETE (soft)  →  RESTORE  →  ERASE (hard)

Write Data

Write operations append data to a Memory. Multiple overloads allow you to control record identity (id), secondary index (index), timestamps (date), grouping (reference), and physical partitioning (clusterized).

Basic write

await app.WriteData(
    "myApp",
    "users",
    new { name = "John", role = "admin" }
);

Write with reference

reference is a first-class numeric dimension used to group records (e.g., userId, tenantId, deviceId). This enables highly efficient reference-based reads.

await app.WriteData(
    "myApp",
    "orders",
    new { total = 99.90 },
    reference: userId
);

Clusterized write

When clusterized is enabled, eeCLOUD physically partitions the Memory to improve scalability and isolation.

await app.WriteData(
    "myApp",
    "orders",
    new { total = 99.90 },
    reference: userId,
    clusterized: true
);

Deterministic writes (advanced)

Use overloads with explicit id, index and/or date for controlled ingestion, migrations or deterministic pipelines.

await app.WriteData(
    "myApp",
    "events",
    id: "event-0001",
    date: new DateTime(2026, 1, 1, 12, 0, 0, DateTimeKind.Utc),
    data: new { type = "boot" },
    reference: deviceId,
    clusterized: false
);

Address and Deterministic Modifications

Every stored record has a unique address (see MemoryArea.address). Updates and deletes are primarily performed using this address.

Update Data

Update operations modify existing records. The most deterministic approach is updating by address. eeCLOUD also supports targeted updates and atomic increments.

Update full JSON payload (by address)

await app.UpdateData(
    "myApp",
    "users",
    address,
    new { name = "John", role = "owner" }
);

Update a single field (by address)

await app.UpdateValue("myApp", "users", address, "active", true);
await app.UpdateValue("myApp", "users", address, "email", "[email protected]");
await app.UpdateValue("myApp", "users", address, "balance", 12.50m);

Update by filter (order-aware)

When updating by filter (field/value), the Order parameter decides which matching record is updated. Default is DESC (most recent).

await app.UpdateData(
    "myApp",
    "sessions",
    field: "token",
    value: token,
    data: new { status = "expired" },
    order: Order.DESC
);

Update identity fields

await app.UpdateID("myApp", "users", address, "user-0001");
await app.UpdateIndex("myApp", "users", address, "IDX-A");

Atomic increments

await app.IncreaseDataValue("myApp", "counters", address, "hits", 1);
await app.IncreaseDataValue("myApp", "wallets", address, "balance", 2.5m);

Delete, Restore and Erase

eeCLOUD supports a complete lifecycle for deletion:

• Delete: soft delete (record remains stored, marked as deleted)
• Restore: revert a soft delete
• Erase: permanent deletion (hard delete)

Soft delete

await app.DeleteData("myApp", "users", address);

Restore

await app.RestoreData("myApp", "users", address);

Hard delete (erase)

await app.EraseData("myApp", "users", address);

Practical Guidelines

• Use reference when data has an owner (user, tenant, device)
• Use clusterized for high-cardinality references and large multi-tenant workloads
• Prefer address-based updates for deterministic behavior
• Use soft delete for auditability and recovery
• Use erase only when you need permanent removal

Understanding Reads