Data Export Guide

import asyncio
import csv
from geode_client import Client

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

    async with client.connection() as conn:
        # Query all users
        page, has_more = await conn.query("""
            MATCH (u:User)
            RETURN u.id, u.name, u.email, u.age, u.city
            ORDER BY u.id
        """)

        with open(filename, 'w', newline='') as file:
            writer = csv.writer(file)

            # Write header
            writer.writerow(['id', 'name', 'email', 'age', 'city'])

            # Write first page
            for row in page.rows:
                writer.writerow([
                    row['u.id'].as_int,
                    row['u.name'].as_string,
                    row['u.email'].as_string,
                    row['u.age'].as_int,
                    row['u.city'].as_string
                ])

            # Fetch remaining pages
            while has_more:
                page, has_more = await conn.pull()
                for row in page.rows:
                    writer.writerow([
                        row['u.id'].as_int,
                        row['u.name'].as_string,
                        row['u.email'].as_string,
                        row['u.age'].as_int,
                        row['u.city'].as_string
                    ])

        print(f"Exported to {filename}")

asyncio.run(export_to_csv("users_export.csv"))

use geode_client::Client;
use std::fs::File;
use std::io::Write;

#[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?;

    // Query data
    let (page, _) = conn.query(r#"
        MATCH (u:User)
        RETURN u.id, u.name, u.email, u.age, u.city
        ORDER BY u.id
    "#).await?;

    // Create CSV file
    let mut file = File::create("users_export.csv")?;

    // Write header
    writeln!(file, "id,name,email,age,city")?;

    // Write rows
    let mut count = 0;
    for row in &page.rows {
        let id = row.get("u.id").unwrap().as_int()?;
        let name = row.get("u.name").unwrap().as_string()?;
        let email = row.get("u.email").unwrap().as_string()?;
        let age = row.get("u.age").unwrap().as_int()?;
        let city = row.get("u.city").unwrap().as_string()?;

        // Escape CSV fields properly
        writeln!(file, "{},\"{}\",\"{}\",{},\"{}\"",
            id,
            name.replace("\"", "\"\""),
            email.replace("\"", "\"\""),
            age,
            city.replace("\"", "\"\"")
        )?;
        count += 1;
    }

    println!("Exported {} users to users_export.csv", count);
    Ok(())
}

import { createClient } from '@geodedb/client';
import { createWriteStream } from 'fs';

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

    const writeStream = createWriteStream(filename);

    // Write header
    writeStream.write('id,name,email,age,city\n');

    // Query and stream results
    const rows = await client.queryAll(`
        MATCH (u:User)
        RETURN u.id, u.name, u.email, u.age, u.city
        ORDER BY u.id
    `);

    let count = 0;
    for (const row of rows) {
        const id = row.get('u.id')?.asNumber;
        const name = row.get('u.name')?.asString?.replace(/"/g, '""');
        const email = row.get('u.email')?.asString?.replace(/"/g, '""');
        const age = row.get('u.age')?.asNumber;
        const city = row.get('u.city')?.asString?.replace(/"/g, '""');

        writeStream.write(`${id},"${name}","${email}",${age},"${city}"\n`);
        count++;
    }

    writeStream.end();
    console.log(`Exported ${count} users to ${filename}`);

    await client.close();
}

exportToCSV('users_export.csv');

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

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("csv-export", "1.0.0");
    _ = try client.receiveMessage(30000);

    // Query data
    try client.sendRunGql(1,
        \\MATCH (u:User)
        \\RETURN u.id, u.name, u.email, u.age, u.city
        \\ORDER BY u.id
    , null);
    _ = try client.receiveMessage(30000);

    // Pull results
    try client.sendPull(1, 10000);
    const result = try client.receiveMessage(30000);
    defer allocator.free(result);

    // Create output file
    const file = try std.fs.cwd().createFile("users_export.csv", .{});
    defer file.close();

    // Write header
    try file.writeAll("id,name,email,age,city\n");

    // Parse JSON result and write CSV rows
    const parsed = try std.json.parseFromSlice(std.json.Value, allocator, result, .{});
    defer parsed.deinit();

    if (parsed.value.object.get("rows")) |rows| {
        for (rows.array.items) |row| {
            // Extract fields and write CSV line
            const id = row.object.get("u.id").?.integer;
            const name = row.object.get("u.name").?.string;
            const email = row.object.get("u.email").?.string;
            const age = row.object.get("u.age").?.integer;
            const city = row.object.get("u.city").?.string;

            var buf: [1024]u8 = undefined;
            const line = try std.fmt.bufPrint(&buf, "{d},\"{s}\",\"{s}\",{d},\"{s}\"\n", .{
                id, name, email, age, city,
            });
            try file.writeAll(line);
        }
    }

    std.debug.print("Export complete\n", .{});
}

import asyncio
import json
from datetime import datetime
from geode_client import Client

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

    async with client.connection() as conn:
        page, _ = await conn.query("""
            MATCH (u:User)
            RETURN u.id, u.name, u.email, u.age, u.city, u.tags
            ORDER BY u.id
        """)

        users = []
        for row in page.rows:
            user = {
                "id": row['u.id'].as_int,
                "name": row['u.name'].as_string,
                "email": row['u.email'].as_string,
                "age": row['u.age'].as_int,
                "city": row['u.city'].as_string,
            }

            # Handle optional tags
            if row.get('u.tags'):
                user["tags"] = row['u.tags'].as_list

            users.append(user)

        export_data = {
            "exported_at": datetime.utcnow().isoformat() + "Z",
            "count": len(users),
            "users": users
        }

        with open(filename, 'w') as f:
            json.dump(export_data, f, indent=2)

        print(f"Exported {len(users)} users to {filename}")

asyncio.run(export_to_json("users_export.json"))

use geode_client::Client;
use serde::{Deserialize, Serialize};
use std::fs::File;
use std::io::Write;
use chrono::Utc;

#[derive(Serialize)]
struct User {
    id: i64,
    name: String,
    email: String,
    age: i64,
    city: String,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    tags: Vec<String>,
}

#[derive(Serialize)]
struct ExportData {
    exported_at: String,
    count: usize,
    users: Vec<User>,
}

#[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?;

    let (page, _) = conn.query(r#"
        MATCH (u:User)
        RETURN u.id, u.name, u.email, u.age, u.city, u.tags
        ORDER BY u.id
    "#).await?;

    let mut users = Vec::new();
    for row in &page.rows {
        let tags: Vec<String> = row.get("u.tags")
            .map(|v| v.as_list().unwrap_or_default()
                .iter()
                .map(|t| t.as_string().unwrap_or_default())
                .collect())
            .unwrap_or_default();

        users.push(User {
            id: row.get("u.id").unwrap().as_int()?,
            name: row.get("u.name").unwrap().as_string()?,
            email: row.get("u.email").unwrap().as_string()?,
            age: row.get("u.age").unwrap().as_int()?,
            city: row.get("u.city").unwrap().as_string()?,
            tags,
        });
    }

    let export = ExportData {
        exported_at: Utc::now().to_rfc3339(),
        count: users.len(),
        users,
    };

    let mut file = File::create("users_export.json")?;
    let json = serde_json::to_string_pretty(&export)?;
    file.write_all(json.as_bytes())?;

    println!("Exported {} users", export.count);
    Ok(())
}

import { createClient } from '@geodedb/client';
import { writeFileSync } from 'fs';

interface User {
    id: number;
    name: string;
    email: string;
    age: number;
    city: string;
    tags?: string[];
}

interface ExportData {
    exported_at: string;
    count: number;
    users: User[];
}

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

    const rows = await client.queryAll(`
        MATCH (u:User)
        RETURN u.id, u.name, u.email, u.age, u.city, u.tags
        ORDER BY u.id
    `);

    const users: User[] = [];
    for (const row of rows) {
        const user: User = {
            id: row.get('u.id')?.asNumber!,
            name: row.get('u.name')?.asString!,
            email: row.get('u.email')?.asString!,
            age: row.get('u.age')?.asNumber!,
            city: row.get('u.city')?.asString!,
        };

        const tags = row.get('u.tags')?.asList;
        if (tags && tags.length > 0) {
            user.tags = tags;
        }

        users.push(user);
    }

    const exportData: ExportData = {
        exported_at: new Date().toISOString(),
        count: users.length,
        users,
    };

    writeFileSync(filename, JSON.stringify(exportData, null, 2));
    console.log(`Exported ${users.length} users to ${filename}`);

    await client.close();
}

exportToJSON('users_export.json');

package main

import (
    "bufio"
    "context"
    "database/sql"
    "encoding/json"
    "log"
    "os"

    _ "geodedb.com/geode"
)

func main() {
    db, err := sql.Open("geode", "localhost:3141")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    ctx := context.Background()

    rows, err := db.QueryContext(ctx, `
        MATCH (u:User)
        RETURN u.id, u.name, u.email, u.age, u.city
        ORDER BY u.id
    `)
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()

    file, _ := os.Create("users_export.jsonl")
    defer file.Close()

    writer := bufio.NewWriter(file)
    defer writer.Flush()

    count := 0
    for rows.Next() {
        var id, age int
        var name, email, city string

        rows.Scan(&id, &name, &email, &age, &city)

        record := map[string]interface{}{
            "id":    id,
            "name":  name,
            "email": email,
            "age":   age,
            "city":  city,
        }

        jsonLine, _ := json.Marshal(record)
        writer.Write(jsonLine)
        writer.WriteString("\n")
        count++

        if count%10000 == 0 {
            writer.Flush()
            log.Printf("Exported %d records...", count)
        }
    }

    log.Printf("Total exported: %d records", count)
}

package main

import (
    "context"
    "database/sql"
    "encoding/json"
    "log"
    "os"
    "time"

    _ "geodedb.com/geode"
)

type ExportState struct {
    LastExport string `json:"last_export"`
}

type Change struct {
    ID        int    `json:"id"`
    Name      string `json:"name"`
    Email     string `json:"email"`
    UpdatedAt string `json:"updated_at"`
}

func loadState(filename string) ExportState {
    data, err := os.ReadFile(filename)
    if err != nil {
        return ExportState{LastExport: "1970-01-01T00:00:00Z"}
    }
    var state ExportState
    json.Unmarshal(data, &state)
    return state
}

func saveState(filename string, state ExportState) {
    data, _ := json.Marshal(state)
    os.WriteFile(filename, data, 0644)
}

func main() {
    db, err := sql.Open("geode", "localhost:3141")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    ctx := context.Background()
    state := loadState("export_state.json")

    rows, err := db.QueryContext(ctx, `
        MATCH (u:User)
        WHERE u.updated_at > ?
        RETURN u.id, u.name, u.email, u.updated_at
        ORDER BY u.updated_at
    `, state.LastExport)
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()

    var changes []Change
    var latestTimestamp string = state.LastExport

    for rows.Next() {
        var c Change
        rows.Scan(&c.ID, &c.Name, &c.Email, &c.UpdatedAt)
        changes = append(changes, c)

        if c.UpdatedAt > latestTimestamp {
            latestTimestamp = c.UpdatedAt
        }
    }

    if len(changes) == 0 {
        log.Println("No changes since last export")
        return
    }

    export := map[string]interface{}{
        "export_type": "incremental",
        "since":       state.LastExport,
        "until":       latestTimestamp,
        "count":       len(changes),
        "changes":     changes,
    }

    file, _ := os.Create("incremental_export.json")
    defer file.Close()
    json.NewEncoder(file).Encode(export)

    state.LastExport = latestTimestamp
    saveState("export_state.json", state)

    log.Printf("Exported %d changed records", len(changes))
}

package main

import (
    "bufio"
    "context"
    "database/sql"
    "encoding/json"
    "log"
    "os"

    _ "geodedb.com/geode"
)

func main() {
    db, err := sql.Open("geode", "localhost:3141")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    ctx := context.Background()

    file, _ := os.Create("large_export.jsonl")
    defer file.Close()
    writer := bufio.NewWriter(file)
    defer writer.Flush()

    pageSize := 10000
    offset := 0
    totalExported := 0

    for {
        rows, err := db.QueryContext(ctx, `
            MATCH (u:User)
            RETURN u.id, u.name, u.email, u.age
            ORDER BY u.id
            SKIP ?
            LIMIT ?
        `, offset, pageSize)
        if err != nil {
            log.Fatal(err)
        }

        count := 0
        for rows.Next() {
            var id, age int
            var name, email string
            rows.Scan(&id, &name, &email, &age)

            record := map[string]interface{}{
                "id":    id,
                "name":  name,
                "email": email,
                "age":   age,
            }

            jsonLine, _ := json.Marshal(record)
            writer.Write(jsonLine)
            writer.WriteString("\n")
            count++
        }
        rows.Close()

        totalExported += count
        log.Printf("Exported %d records...", totalExported)

        if count < pageSize {
            break
        }
        offset += pageSize
    }

    log.Printf("Stream export complete: %d total records", totalExported)
}