Error Codes Reference

{
  "status_class": "42000",
  "status": "42001",
  "message": "Undefined table: NonExistentTable",
  "details": {
    "table_name": "NonExistentTable",
    "suggestion": "Check table name spelling or create the table first"
  }
}

-- Returns 00000 on success
CREATE (p:Person {name: 'Alice'});

-- Returns 02000 if no matches
MATCH (p:Person {name: 'NonExistent'}) RETURN p;

-- 0A001: Transaction already active
BEGIN TRANSACTION;
BEGIN TRANSACTION;  -- ERROR

-- 0A002: No active transaction
COMMIT;  -- ERROR (no transaction started)

-- Correct usage
BEGIN TRANSACTION;
CREATE (p:Person {name: 'Bob'});
COMMIT;

-- 22001: String truncation
CREATE (p:Person {name: Char('VeryLongNameThatExceedsLimit', 10)});
-- ERROR: String 'VeryLongNameThatExceedsLimit' exceeds Char(10) limit

-- 22003: Numeric out of range
RETURN SmallInt(100000);  -- ERROR: Value exceeds i16 range

-- 22007: Invalid datetime
RETURN Date('invalid-date');  -- ERROR

-- 22012: Division by zero
RETURN 10 / 0;  -- ERROR

-- Correct usage
RETURN 10 / CASE WHEN $divisor = 0 THEN 1 ELSE $divisor END;

-- 23502: Not null violation
CREATE (p:Person {age: null});  -- ERROR if age has NOT NULL constraint

-- 23505: Unique violation
CREATE (p1:Person {email: '[email protected]'});
CREATE (p2:Person {email: '[email protected]'});  -- ERROR if email is UNIQUE

-- 23503: Foreign key violation
CREATE (o:Order {customer_id: 999});  -- ERROR if customer 999 doesn't exist

-- 42001: Undefined object
MATCH (n:NonExistentLabel) RETURN n;
-- ERROR: Label 'NonExistentLabel' not found

-- 42002: Duplicate object
CREATE INDEX person_email ON Person(email);
CREATE INDEX person_email ON Person(email);  -- ERROR

-- 42601: Syntax error
MATCH (n) RETURN n WHERE n.age > 30;  -- ERROR: WHERE after RETURN

-- 42P01: Undefined table
MATCH (n:Person) WHERE n.age > 30 RETURN n;
-- ERROR if Person label doesn't exist

-- Correct: Use IF NOT EXISTS
CREATE INDEX IF NOT EXISTS person_email ON Person(email);

-- 53200: Out of memory
MATCH (n)-[r*]-(m)  -- ERROR: Unbounded path may exhaust memory
RETURN n, m;

-- Correct: Limit path length
MATCH (n)-[r*1..5]-(m)
WHERE n.id = 123
RETURN n, m
LIMIT 100;

-- ERR_OOM: Large aggregation without limits
MATCH (n)-[r*]-(m)
RETURN collect(n) AS all_nodes;  -- May cause OOM

-- Solution: Add limits
MATCH (n)-[r*1..3]-(m)
WHERE n.id = 123
RETURN collect(n) AS nearby_nodes
LIMIT 1000;

-- ERR_FLOAT_NAN
RETURN sqrt(-1);  -- ERROR: NaN not allowed

-- ERR_CHAR_LEN
CREATE (p:Person {code: Char('TOOLONG', 5)});  -- ERROR

-- ERR_IP_PARSE
RETURN IpAddr('999.999.999.999');  -- ERROR

-- ERR_JSON_PARSE
RETURN Json('{invalid json}');  -- ERROR

-- Correct usage
RETURN IpAddr('192.168.1.1');
RETURN Json('{"valid": "json"}');

-- ERR_TRANSACTION_CONFLICT
BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE SNAPSHOT;
-- ... operations ...
COMMIT;  -- May fail with conflict, retry needed

-- Retry logic (pseudocode)
max_retries = 3
for attempt in range(max_retries):
    try:
        execute_transaction()
        break
    except ERR_TRANSACTION_CONFLICT:
        if attempt == max_retries - 1:
            raise
        sleep(exponential_backoff(attempt))

# Python client example
from geode_client import Client, QueryError

client = Client(host="localhost", port=3141)
async with client.connection() as conn:
    try:
        page, _ = await conn.query("MATCH (p:Person) RETURN p")
    except QueryError as e:
        message = str(e)
        if message.startswith("42P01:"):
            print("Table doesn't exist - creating it")
            await conn.execute("CREATE (:Person {name: 'Alice'})")
        elif message.startswith("53200:"):
            print("Out of memory - reducing query complexity")
            page, _ = await conn.query("MATCH (p:Person) RETURN p LIMIT 100")
        else:
            raise

// Go client example
import "geodedb.com/geode"

func executeWithRetry(db *sql.DB, query string, maxRetries int) error {
    for i := 0; i < maxRetries; i++ {
        _, err := db.Exec(query)
        if err == nil {
            return nil
        }

        // Check if error is retryable
        if isRetryable(err) {
            time.Sleep(time.Duration(i*100) * time.Millisecond)
            continue
        }

        return err
    }
    return fmt.Errorf("max retries exceeded")
}

func isRetryable(err error) bool {
    // Transaction conflicts, deadlocks, timeouts
    statusCode := extractStatusCode(err)
    return statusCode == "ERR_TRANSACTION_CONFLICT" ||
           statusCode == "ERR_DEADLOCK" ||
           statusCode == "ERR_TIMEOUT"
}

// Rust client example
use geode_client::{Connection, Error, Result};

async fn create_person(conn: &mut Connection, name: &str, age: i32) -> Result<()> {
    // Validate before sending to database
    if name.is_empty() {
        return Err(Error::validation("Name cannot be empty"));
    }

    if age < 0 || age > 150 {
        return Err(Error::validation("Age must be 0-150"));
    }

    let query = format!("CREATE (p:Person {{name: '{}', age: {}}})", name, age);
    conn.query(&query).await?;

    Ok(())
}

-- Enable detailed error logging
-- Set in server configuration
logging:
  level: 'debug'
  include_stack_traces: true
  error_details: true

-- Check if label exists
SHOW LABELS;

-- Create label by inserting node
CREATE (:Person {name: 'Alice'});

-- Then retry query
MATCH (p:Person) RETURN p;

-- Option 1: Use different value
CREATE (p:Person {email: '[email protected]'});

-- Option 2: Update existing record
MATCH (p:Person {email: '[email protected]'})
SET p.updated_at = timestamp();

-- Option 3: Use MERGE to update or insert
MERGE (p:Person {email: '[email protected]'})
ON CREATE SET p.created_at = timestamp()
ON MATCH SET p.updated_at = timestamp();

# Implement retry with exponential backoff
import time
from geode_client import Client, QueryError

client = Client(host="localhost", port=3141)

async def execute_with_retry(conn, query, max_retries=3):
    for attempt in range(max_retries):
        try:
            await conn.begin()
            await conn.query(query)
            await conn.commit()
            return
        except QueryError:
            await conn.rollback()
            if attempt == max_retries - 1:
                raise
            time.sleep(0.1 * (2 ** attempt))  # Exponential backoff

# async with client.connection() as conn:
#     await execute_with_retry(conn, "MATCH (n) RETURN count(n)")

-- Original (slow)
MATCH (n)-[r*]-(m)
RETURN n, m;

-- Optimized
MATCH (n)-[r*1..3]-(m)
WHERE n.id = 123
RETURN n, m
LIMIT 100;

-- Or increase timeout
-- Client configuration:
-- timeout_ms: 60000