Transaction Management Guide

import asyncio
from enum import Enum
from geode_client import Client, IsolationLevel

class TransactionIsolation(Enum):
    READ_UNCOMMITTED = "read_uncommitted"
    READ_COMMITTED = "read_committed"
    REPEATABLE_READ = "repeatable_read"
    SERIALIZABLE = "serializable"


async def transfer_funds(
    client: Client,
    from_account: int,
    to_account: int,
    amount: float,
    isolation: TransactionIsolation = TransactionIsolation.SERIALIZABLE
) -> None:
    """Transfer funds between accounts with specified isolation level."""
    async with client.connection() as conn:
        # Begin transaction with isolation level
        await conn.begin(isolation_level=isolation.value)

        try:
            # Debit source account
            await conn.execute("""
                MATCH (a:Account {id: $id})
                SET a.balance = a.balance - $amount
            """, {"id": from_account, "amount": amount})

            # Credit destination account
            await conn.execute("""
                MATCH (a:Account {id: $id})
                SET a.balance = a.balance + $amount
            """, {"id": to_account, "amount": amount})

            await conn.commit()
            print("Transfer completed successfully")

        except Exception as e:
            await conn.rollback()
            print(f"Transfer failed: {e}")
            raise


async def read_only_query(client: Client) -> int:
    """Execute read-only query with appropriate isolation."""
    async with client.connection() as conn:
        # Read committed is sufficient for read-only
        await conn.begin(
            isolation_level="read_committed",
            read_only=True
        )

        try:
            result, _ = await conn.query("MATCH (n) RETURN count(n) as count")
            count = result.rows[0]["count"].as_int if result.rows else 0
            await conn.commit()
            return count
        except Exception:
            await conn.rollback()
            raise


async def critical_operation(client: Client) -> None:
    """Execute critical operation with serializable isolation."""
    async with client.connection() as conn:
        await conn.begin(isolation_level="serializable")

        try:
            # Check preconditions
            result, _ = await conn.query("""
                MATCH (a:Account {id: 1})
                RETURN a.balance as balance
            """)

            balance = result.rows[0]["balance"].as_float if result.rows else 0

            if balance < 100:
                raise ValueError("Insufficient funds")

            # Perform critical update
            await conn.execute("""
                MATCH (a:Account {id: 1})
                SET a.balance = a.balance - 100
            """)

            await conn.commit()

        except Exception as e:
            await conn.rollback()
            raise


async def main():
    client = Client(host="localhost", port=3141, skip_verify=True)

    # Different isolation for different operations
    await transfer_funds(
        client, 1, 2, 100.0,
        isolation=TransactionIsolation.SERIALIZABLE
    )

    count = await read_only_query(client)
    print(f"Total nodes: {count}")


if __name__ == "__main__":
    asyncio.run(main())

use geode_client::{Client, Connection, IsolationLevel, TransactionOptions, Value};
use std::collections::HashMap;

async fn transfer_funds(
    conn: &mut Connection,
    from_account: i64,
    to_account: i64,
    amount: f64,
    isolation: IsolationLevel,
) -> Result<(), Box<dyn std::error::Error>> {
    // Begin transaction with specified isolation level
    let options = TransactionOptions {
        isolation_level: isolation,
        read_only: false,
    };
    conn.begin_with_options(options).await?;

    // Debit source account
    let mut params = HashMap::new();
    params.insert("id".to_string(), Value::int(from_account));
    params.insert("amount".to_string(), Value::float(amount));

    match conn.query_with_params(
        "MATCH (a:Account {id: $id}) SET a.balance = a.balance - $amount",
        &params
    ).await {
        Ok(_) => {}
        Err(e) => {
            conn.rollback().await?;
            return Err(e.into());
        }
    }

    // Credit destination account
    params.insert("id".to_string(), Value::int(to_account));

    match conn.query_with_params(
        "MATCH (a:Account {id: $id}) SET a.balance = a.balance + $amount",
        &params
    ).await {
        Ok(_) => {
            conn.commit().await?;
            println!("Transfer completed successfully");
            Ok(())
        }
        Err(e) => {
            conn.rollback().await?;
            Err(e.into())
        }
    }
}

async fn read_only_query(conn: &mut Connection) -> Result<i64, Box<dyn std::error::Error>> {
    // Read committed is sufficient for read-only
    let options = TransactionOptions {
        isolation_level: IsolationLevel::ReadCommitted,
        read_only: true,
    };
    conn.begin_with_options(options).await?;

    let (page, _) = conn.query("MATCH (n) RETURN count(n) as count").await?;
    let count = page.rows.first()
        .and_then(|row| row.get("count"))
        .and_then(|v| v.as_int().ok())
        .unwrap_or(0);

    conn.commit().await?;
    Ok(count)
}

async fn critical_operation(conn: &mut Connection) -> Result<(), Box<dyn std::error::Error>> {
    // Serializable for critical operations
    let options = TransactionOptions {
        isolation_level: IsolationLevel::Serializable,
        read_only: false,
    };
    conn.begin_with_options(options).await?;

    // Check preconditions
    let (page, _) = conn.query(
        "MATCH (a:Account {id: 1}) RETURN a.balance as balance"
    ).await?;

    let balance = page.rows.first()
        .and_then(|row| row.get("balance"))
        .and_then(|v| v.as_float().ok())
        .unwrap_or(0.0);

    if balance < 100.0 {
        conn.rollback().await?;
        return Err("Insufficient funds".into());
    }

    // Perform critical update
    match conn.query(
        "MATCH (a:Account {id: 1}) SET a.balance = a.balance - 100"
    ).await {
        Ok(_) => {
            conn.commit().await?;
            Ok(())
        }
        Err(e) => {
            conn.rollback().await?;
            Err(e.into())
        }
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new("127.0.0.1", 3141).skip_verify(true);
    let mut conn = client.connect().await?;

    // Transfer with serializable isolation
    transfer_funds(&mut conn, 1, 2, 100.0, IsolationLevel::Serializable).await?;

    // Read-only query
    let count = read_only_query(&mut conn).await?;
    println!("Total nodes: {}", count);

    Ok(())
}

import { createClient, GeodeClient, IsolationLevel } from '@geodedb/client';

enum TransactionIsolation {
    READ_UNCOMMITTED = 'read_uncommitted',
    READ_COMMITTED = 'read_committed',
    REPEATABLE_READ = 'repeatable_read',
    SERIALIZABLE = 'serializable',
}

async function transferFunds(
    client: GeodeClient,
    fromAccount: number,
    toAccount: number,
    amount: number,
    isolation: TransactionIsolation = TransactionIsolation.SERIALIZABLE
): Promise<void> {
    await client.withTransaction(
        async (tx) => {
            // Debit source account
            await tx.exec(
                'MATCH (a:Account {id: $id}) SET a.balance = a.balance - $amount',
                { params: { id: fromAccount, amount } }
            );

            // Credit destination account
            await tx.exec(
                'MATCH (a:Account {id: $id}) SET a.balance = a.balance + $amount',
                { params: { id: toAccount, amount } }
            );
        },
        { isolationLevel: isolation }
    );

    console.log('Transfer completed successfully');
}

async function readOnlyQuery(client: GeodeClient): Promise<number> {
    let count = 0;

    await client.withTransaction(
        async (tx) => {
            const rows = await tx.queryAll('MATCH (n) RETURN count(n) as count');
            count = rows[0]?.get('count')?.asNumber || 0;
        },
        {
            isolationLevel: TransactionIsolation.READ_COMMITTED,
            readOnly: true,
        }
    );

    return count;
}

async function criticalOperation(client: GeodeClient): Promise<void> {
    await client.withTransaction(
        async (tx) => {
            // Check preconditions
            const rows = await tx.queryAll(
                'MATCH (a:Account {id: 1}) RETURN a.balance as balance'
            );

            const balance = rows[0]?.get('balance')?.asNumber || 0;

            if (balance < 100) {
                throw new Error('Insufficient funds');
            }

            // Perform critical update
            await tx.exec(
                'MATCH (a:Account {id: 1}) SET a.balance = a.balance - 100'
            );
        },
        { isolationLevel: TransactionIsolation.SERIALIZABLE }
    );
}

async function main() {
    const client = await createClient('quic://localhost:3141');

    try {
        // Transfer with serializable isolation
        await transferFunds(client, 1, 2, 100, TransactionIsolation.SERIALIZABLE);

        // Read-only query
        const count = await readOnlyQuery(client);
        console.log(`Total nodes: ${count}`);

        // Critical operation
        await criticalOperation(client);
    } finally {
        await client.close();
    }
}

main().catch(console.error);

const std = @import("std");
const geode = @import("geode_client");

pub const IsolationLevel = enum {
    read_uncommitted,
    read_committed,
    repeatable_read,
    serializable,

    pub fn toString(self: IsolationLevel) []const u8 {
        return switch (self) {
            .read_uncommitted => "READ UNCOMMITTED",
            .read_committed => "READ COMMITTED",
            .repeatable_read => "REPEATABLE READ",
            .serializable => "SERIALIZABLE",
        };
    }
};

pub fn transferFunds(
    client: *geode.GeodeClient,
    from_account: i64,
    to_account: i64,
    amount: f64,
    isolation: IsolationLevel,
) !void {
    // Begin transaction with isolation level
    const begin_query = try std.fmt.allocPrint(
        client.allocator,
        "BEGIN ISOLATION LEVEL {s}",
        .{isolation.toString()},
    );
    defer client.allocator.free(begin_query);

    try client.sendRunGql(1, begin_query, null);
    _ = try client.receiveMessage(30000);

    // Debit source account
    var params = std.json.ObjectMap.init(client.allocator);
    defer params.deinit();
    try params.put("id", .{ .integer = from_account });
    try params.put("amount", .{ .float = amount });

    client.sendRunGql(2,
        "MATCH (a:Account {id: $id}) SET a.balance = a.balance - $amount",
        .{ .object = params }) catch |e| {
        try client.sendRollback();
        _ = try client.receiveMessage(30000);
        return e;
    };
    _ = try client.receiveMessage(30000);

    // Credit destination account
    params.clearRetainingCapacity();
    try params.put("id", .{ .integer = to_account });
    try params.put("amount", .{ .float = amount });

    client.sendRunGql(3,
        "MATCH (a:Account {id: $id}) SET a.balance = a.balance + $amount",
        .{ .object = params }) catch |e| {
        try client.sendRollback();
        _ = try client.receiveMessage(30000);
        return e;
    };
    _ = try client.receiveMessage(30000);

    // Commit
    try client.sendCommit();
    _ = try client.receiveMessage(30000);

    std.debug.print("Transfer completed successfully\n", .{});
}

pub fn readOnlyQuery(client: *geode.GeodeClient) !i64 {
    // Read committed is sufficient for read-only
    try client.sendRunGql(1, "BEGIN ISOLATION LEVEL READ COMMITTED READ ONLY", null);
    _ = try client.receiveMessage(30000);

    try client.sendRunGql(2, "MATCH (n) RETURN count(n) as count", null);
    _ = try client.receiveMessage(30000);

    try client.sendPull(2, 1000);
    const result = try client.receiveMessage(30000);
    defer client.allocator.free(result);

    try client.sendCommit();
    _ = try client.receiveMessage(30000);

    // Parse count from result (simplified)
    // In practice, parse JSON to extract count value
    return 0;
}

pub fn criticalOperation(client: *geode.GeodeClient) !void {
    // Serializable for critical operations
    try client.sendRunGql(1, "BEGIN ISOLATION LEVEL SERIALIZABLE", null);
    _ = try client.receiveMessage(30000);

    // Check preconditions
    try client.sendRunGql(2,
        "MATCH (a:Account {id: 1}) RETURN a.balance as balance",
        null);
    _ = try client.receiveMessage(30000);

    try client.sendPull(2, 1000);
    const balance_result = try client.receiveMessage(30000);
    defer client.allocator.free(balance_result);

    // Parse and check balance (simplified)
    // In practice, parse JSON and check balance >= 100

    // Perform critical update
    client.sendRunGql(3,
        "MATCH (a:Account {id: 1}) SET a.balance = a.balance - 100",
        null) catch |e| {
        try client.sendRollback();
        _ = try client.receiveMessage(30000);
        return e;
    };
    _ = try client.receiveMessage(30000);

    try client.sendCommit();
    _ = try client.receiveMessage(30000);
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    var client = geode.GeodeClient.init(allocator, "localhost", 3141, true);
    defer client.deinit();

    try client.connect();
    try client.sendHello("app", "1.0.0");
    _ = try client.receiveMessage(30000);

    // Transfer with serializable isolation
    try transferFunds(&client, 1, 2, 100.0, .serializable);

    // Read-only query
    const count = try readOnlyQuery(&client);
    std.debug.print("Total nodes: {d}\n", .{count});

    // Critical operation
    try criticalOperation(&client);
}

async def basic_transaction(client: Client) -> None:
    """Basic transaction with explicit begin/commit."""
    async with client.connection() as conn:
        # Begin transaction
        await conn.begin()

        try:
            # Execute operations
            await conn.execute(
                "CREATE (:Person {name: $name})",
                {"name": "Alice"}
            )

            await conn.execute(
                "CREATE (:Person {name: $name})",
                {"name": "Bob"}
            )

            # Commit transaction
            await conn.commit()
            print("Transaction committed successfully")

        except Exception as e:
            # Rollback on error
            await conn.rollback()
            print(f"Transaction rolled back: {e}")
            raise


# Context manager for automatic transaction handling
class TransactionContext:
    def __init__(self, conn):
        self.conn = conn

    async def __aenter__(self):
        await self.conn.begin()
        return self.conn

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        if exc_type is not None:
            await self.conn.rollback()
            return False
        await self.conn.commit()
        return True


async def with_transaction(client: Client, operations) -> None:
    """Execute operations within a transaction context."""
    async with client.connection() as conn:
        async with TransactionContext(conn):
            await operations(conn)


# Usage
async def main():
    client = Client(host="localhost", port=3141, skip_verify=True)

    async def create_people(conn):
        await conn.execute(
            "CREATE (:Person {name: $name})",
            {"name": "Alice"}
        )
        await conn.execute(
            "CREATE (:Person {name: $name})",
            {"name": "Bob"}
        )

    await with_transaction(client, create_people)

async fn basic_transaction(conn: &mut Connection) -> Result<(), Error> {
    // Begin transaction
    conn.begin().await?;

    // Execute operations
    let result = async {
        let mut params = HashMap::new();
        params.insert("name".to_string(), Value::string("Alice"));
        conn.query_with_params(
            "CREATE (:Person {name: $name})",
            &params
        ).await?;

        params.insert("name".to_string(), Value::string("Bob"));
        conn.query_with_params(
            "CREATE (:Person {name: $name})",
            &params
        ).await?;

        Ok::<(), Error>(())
    }.await;

    match result {
        Ok(_) => {
            conn.commit().await?;
            println!("Transaction committed successfully");
            Ok(())
        }
        Err(e) => {
            conn.rollback().await?;
            println!("Transaction rolled back: {}", e);
            Err(e)
        }
    }
}

// Helper function for transaction execution
async fn with_transaction<F, Fut, T>(
    conn: &mut Connection,
    operations: F
) -> Result<T, Error>
where
    F: FnOnce(&mut Connection) -> Fut,
    Fut: std::future::Future<Output = Result<T, Error>>,
{
    conn.begin().await?;

    match operations(conn).await {
        Ok(result) => {
            conn.commit().await?;
            Ok(result)
        }
        Err(e) => {
            let _ = conn.rollback().await;
            Err(e)
        }
    }
}

// Usage
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new("127.0.0.1", 3141).skip_verify(true);
    let mut conn = client.connect().await?;

    with_transaction(&mut conn, |conn| async move {
        let mut params = HashMap::new();
        params.insert("name".to_string(), Value::string("Alice"));
        conn.query_with_params(
            "CREATE (:Person {name: $name})",
            &params
        ).await?;
        Ok(())
    }).await?;

    Ok(())
}

async function basicTransaction(client: GeodeClient): Promise<void> {
    // Using withTransaction helper
    await client.withTransaction(async (tx) => {
        // Execute operations
        await tx.exec(
            'CREATE (:Person {name: $name})',
            { params: { name: 'Alice' } }
        );

        await tx.exec(
            'CREATE (:Person {name: $name})',
            { params: { name: 'Bob' } }
        );

        // Transaction auto-commits on success
    });

    console.log('Transaction committed successfully');
}

// Manual transaction control
async function manualTransaction(client: GeodeClient): Promise<void> {
    const conn = await client.getConnection();

    try {
        await conn.begin();

        await conn.exec(
            'CREATE (:Person {name: $name})',
            { params: { name: 'Alice' } }
        );

        await conn.exec(
            'CREATE (:Person {name: $name})',
            { params: { name: 'Bob' } }
        );

        await conn.commit();
        console.log('Transaction committed successfully');

    } catch (error) {
        await conn.rollback();
        console.error('Transaction rolled back:', error);
        throw error;

    } finally {
        conn.release();
    }
}

// Helper function
async function withTransaction<T>(
    client: GeodeClient,
    operations: (tx: Transaction) => Promise<T>
): Promise<T> {
    return client.withTransaction(operations);
}

// Usage
async function main() {
    const client = await createClient('quic://localhost:3141');

    try {
        await withTransaction(client, async (tx) => {
            await tx.exec(
                'CREATE (:Person {name: $name})',
                { params: { name: 'Alice' } }
            );
        });
    } finally {
        await client.close();
    }
}

const std = @import("std");
const geode = @import("geode_client");

pub fn basicTransaction(client: *geode.GeodeClient) !void {
    // Begin transaction
    try client.sendBegin();
    _ = try client.receiveMessage(30000);

    // Execute operations
    var params = std.json.ObjectMap.init(client.allocator);
    defer params.deinit();

    // Create Alice
    try params.put("name", .{ .string = "Alice" });

    client.sendRunGql(1, "CREATE (:Person {name: $name})", .{ .object = params }) catch |e| {
        try client.sendRollback();
        _ = try client.receiveMessage(30000);
        return e;
    };
    _ = try client.receiveMessage(30000);

    // Create Bob
    params.clearRetainingCapacity();
    try params.put("name", .{ .string = "Bob" });

    client.sendRunGql(2, "CREATE (:Person {name: $name})", .{ .object = params }) catch |e| {
        try client.sendRollback();
        _ = try client.receiveMessage(30000);
        return e;
    };
    _ = try client.receiveMessage(30000);

    // Commit transaction
    try client.sendCommit();
    _ = try client.receiveMessage(30000);

    std.debug.print("Transaction committed successfully\n", .{});
}

// Helper for transaction execution
pub fn withTransaction(
    client: *geode.GeodeClient,
    comptime operations: fn (*geode.GeodeClient) anyerror!void,
) !void {
    try client.sendBegin();
    _ = try client.receiveMessage(30000);

    operations(client) catch |e| {
        try client.sendRollback();
        _ = try client.receiveMessage(30000);
        return e;
    };

    try client.sendCommit();
    _ = try client.receiveMessage(30000);
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    var client = geode.GeodeClient.init(allocator, "localhost", 3141, true);
    defer client.deinit();

    try client.connect();
    try client.sendHello("app", "1.0.0");
    _ = try client.receiveMessage(30000);

    try withTransaction(&client, struct {
        fn op(c: *geode.GeodeClient) !void {
            try c.sendRunGql(1, "CREATE (:Person {name: 'Alice'})", null);
            _ = try c.receiveMessage(30000);
        }
    }.op);
}