Geode Overview

┌───────────────────────────────────────────────────────────┐
│                     Client Layer                          │
│  ┌─────────┐  ┌─────────┐  ┌──────┐  ┌──────┐           │
│  │   Go    │  │ Python  │  │ Rust │  │ Zig  │  + more   │
│  └────┬────┘  └────┬────┘  └───┬──┘  └───┬──┘           │
└───────┼───────────┼───────────┼─────────┼───────────────┘
        │           │           │         │
        └───────────┴───────────┴─────────┘
                    │
         QUIC + TLS 1.3 (Port 3141)
                    │
┌───────────────────▼───────────────────────────────────────┐
│              Geode Server                                 │
│  ┌────────────────────────────────────────────────────┐   │
│  │         Protocol Layer (JSON Line Protocol)        │   │
│  └────────────────────┬───────────────────────────────┘   │
│                       │                                   │
│  ┌────────────────────▼───────────────────────────────┐   │
│  │              Query Engine                          │   │
│  │  ┌──────────┐  ┌────────┐  ┌─────────────┐        │   │
│  │  │  Parser  │→ │Optimizer│→ │  Executor   │        │   │
│  │  │  (GQL)   │  │         │  │ (Parallel)  │        │   │
│  │  └──────────┘  └────────┘  └─────────────┘        │   │
│  └────────────────────┬───────────────────────────────┘   │
│                       │                                   │
│  ┌────────────────────▼───────────────────────────────┐   │
│  │           Storage Engine                           │   │
│  │  ┌──────────────┐  ┌──────────┐  ┌─────────────┐  │   │
│  │  │ Graph Store  │  │  Indexes │  │     WAL     │  │   │
│  │  │ (Native)     │  │          │  │ (Durable)   │  │   │
│  │  └──────────────┘  └──────────┘  └─────────────┘  │   │
│  │  ┌──────────────┐  ┌──────────┐                   │   │
│  │  │ Transaction  │  │   RLS    │                   │   │
│  │  │   Manager    │  │  Engine  │                   │   │
│  │  └──────────────┘  └──────────┘                   │   │
│  └────────────────────────────────────────────────────┘   │
└───────────────────────────────────────────────────────────┘

-- Pattern matching
MATCH (p:Person)-[:KNOWS*2..4]->(friend)
WHERE p.city = 'San Francisco'
RETURN friend.name, friend.city;

-- Aggregations
MATCH (u:User)-[:PURCHASED]->(p:Product)
RETURN p.category, count(u) AS buyers, sum(p.price) AS revenue
GROUP BY p.category
ORDER BY revenue DESC;

-- Temporal queries
MATCH (e:Event)
WHERE e.timestamp >= CURRENT_TIMESTAMP - DURATION 'P7D'
RETURN e.name, e.timestamp;

BEGIN TRANSACTION;

-- Multiple operations
INSERT (order:Order {id: 'o123', total: 299.99});
MATCH (customer:Customer {id: 'c456'})
INSERT (customer)-[:PLACED]->(order);

-- Savepoints for partial rollback
SAVEPOINT sp1;

-- Risky operation
INSERT (payment:Payment {amount: 299.99});

-- Rollback to savepoint if needed
ROLLBACK TO SAVEPOINT sp1;

COMMIT;

-- Define security policy
CREATE POLICY user_data_isolation ON User
  USING (id = current_user_id());

CREATE POLICY confidential_relationships ON MANAGES
  USING (current_user_role IN ['admin', 'manager']);

-- Automatically enforced on all queries
MATCH (u:User) RETURN u.name;  -- Only returns accessible users

-- B-tree indexes for equality and range queries
CREATE INDEX user_email ON User(email);
CREATE INDEX order_date ON Order(date);

-- Composite indexes
CREATE INDEX product_category_price ON Product(category, price);

-- Full-text search indexes
CREATE FULLTEXT INDEX product_search ON Product(name, description);

-- Use full-text search
MATCH (p:Product)
WHERE fulltext_search(p, 'wireless headphones bluetooth')
RETURN p.name, p.price;

-- Temporal data types
INSERT (event:Event {
  name: 'Conference',
  start: TIMESTAMP '2024-06-15 09:00:00-07:00',
  duration: DURATION 'PT8H',
  scheduled_date: DATE '2024-06-15'
});

-- Temporal queries
MATCH (e:Event)
WHERE e.start >= CURRENT_TIMESTAMP
  AND e.start <= CURRENT_TIMESTAMP + DURATION 'P30D'
RETURN e.name, e.start
ORDER BY e.start;

-- Time-series aggregations
MATCH (sale:Sale)
WHERE sale.timestamp >= DATE '2024-01-01'
RETURN
  date_trunc('month', sale.timestamp) AS month,
  count(*) AS sale_count,
  sum(sale.amount) AS revenue
GROUP BY month
ORDER BY month;

-- Friend suggestions (friends of friends)
MATCH (me:User {id: $user_id})-[:FRIEND]->(f1)-[:FRIEND]->(f2)
WHERE f2 <> me
  AND NOT EXISTS { MATCH (me)-[:FRIEND]->(f2) }
RETURN f2.name, count(f1) AS mutual_friends
ORDER BY mutual_friends DESC
LIMIT 10;

-- News feed generation
MATCH (me:User {id: $user_id})-[:FOLLOWS]->(author)-[:POSTED]->(post:Post)
WHERE post.created >= CURRENT_TIMESTAMP - DURATION 'P7D'
RETURN post, author.name
ORDER BY post.created DESC
LIMIT 50;

-- Product recommendations (collaborative filtering)
MATCH (me:User {id: $user_id})-[:PURCHASED]->(p:Product)<-[:PURCHASED]-(similar:User)
MATCH (similar)-[:PURCHASED]->(rec:Product)
WHERE NOT EXISTS { MATCH (me)-[:PURCHASED]->(rec) }
RETURN rec.name, count(similar) AS recommendation_score
ORDER BY recommendation_score DESC
LIMIT 20;

-- Similar products (content-based)
MATCH (p:Product {id: $product_id})-[:IN_CATEGORY]->(cat:Category)<-[:IN_CATEGORY]-(similar:Product)
WHERE similar <> p
  AND abs(similar.price - p.price) < 50
RETURN similar.name, similar.price, similar.rating
ORDER BY similar.rating DESC;

-- Circular transaction patterns (money laundering)
MATCH path = (a:Account)-[:TRANSFER*3..5]->(a)
WHERE all(r IN relationships(path) WHERE r.amount > 10000)
  AND all(r IN relationships(path) WHERE r.timestamp >= CURRENT_DATE - DURATION 'P7D')
RETURN path,
  reduce(sum = 0, r IN relationships(path) | sum + r.amount) AS total_amount
ORDER BY total_amount DESC;

-- Velocity checks (rapid transfers)
MATCH (a:Account)-[t:TRANSFER]->(b:Account)
WHERE t.timestamp >= CURRENT_TIMESTAMP - DURATION 'PT1H'
WITH a, count(t) AS transfer_count, sum(t.amount) AS total_amount
WHERE transfer_count > 10 OR total_amount > 100000
RETURN a.id, transfer_count, total_amount
ORDER BY total_amount DESC;

-- Entity relationships
MATCH (entity:Entity {name: 'Albert Einstein'})
      -[r1:RELATED_TO]->(related)
      -[r2:RELATED_TO]->(further)
RETURN
  entity.name,
  type(r1) AS relationship1,
  related.name,
  type(r2) AS relationship2,
  further.name
LIMIT 100;

-- Concept hierarchies
MATCH path = (specific:Concept)-[:IS_A*]->(general:Concept {name: 'Science'})
RETURN specific.name, length(path) AS distance_from_science
ORDER BY distance_from_science;

-- Service dependency tree
MATCH path = (service:Service {name: 'web-api'})-[:DEPENDS_ON*]->(dependency)
RETURN path, length(path) AS depth
ORDER BY depth;

-- Impact analysis (what breaks if this fails?)
MATCH (failed:Server {id: 'srv-42'})<-[:DEPENDS_ON*]-(affected)
RETURN affected.name, affected.criticality, affected.users_affected
ORDER BY affected.criticality DESC;

# Start server
./geode serve --listen 0.0.0.0:3141 --data /var/lib/geode

# Configure
./geode serve --config /etc/geode/geode.conf

# Pull image
docker pull geodedb/geode:latest

# Run container
docker run -d \
  -p 3141:3141 \
  -v /data/geode:/var/lib/geode \
  --name geode-server \
  geodedb/geode:latest

apiVersion: apps/v1
kind: Deployment
metadata:
  name: geode
spec:
  replicas: 3
  selector:
    matchLabels:
      app: geode
  template:
    metadata:
      labels:
        app: geode
    spec:
      containers:
      - name: geode
        image: geodedb/geode:latest
        ports:
        - containerPort: 3141
        volumeMounts:
        - name: data
          mountPath: /var/lib/geode

package main

import (
    "context"
    "fmt"
    "log"
    _ "geodedb.com/geode"
    "database/sql"
)

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

    rows, err := db.QueryContext(context.Background(),
        "MATCH (p:Person) WHERE p.age > $age RETURN p.name, p.city",
        sql.Named("age", 30))
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()

    for rows.Next() {
        var name, city string
        rows.Scan(&name, &city)
        fmt.Printf("%s from %s\n", name, city)
    }
}

2024-06-15T10:30:45Z [INFO] Query executed: duration=15ms
2024-06-15T10:30:46Z [WARN] Slow query detected: duration=2.5s query="MATCH..."
2024-06-15T10:30:47Z [ERROR] Transaction rollback: reason="constraint violation"

# Create backup
./geode backup --output /backups/geode-2024-06-15.tar.gz

# Restore from backup
./geode restore --input /backups/geode-2024-06-15.tar.gz

# Install
curl -sSL https://geodedb.com/install.sh | sh

# Start server
geode serve

# Connect and query
geode shell
> INSERT (p:Person {name: 'Alice', age: 30});
> MATCH (p:Person) RETURN p.name, p.age;