from sochdb import Database

# Open database (creates if not exists)
db = Database.open("./my_database")

# Store and retrieve data
db.put(b"user:1", b'{"name": "Alice"}')
value = db.get(b"user:1")
print(value)  # b'{"name": "Alice"}'

# Clean up
db.close()

from sochdb import Database

with Database.open("./my_database") as db:
    db.put(b"key", b"value")
    value = db.get(b"key")
# Database automatically closed

from sochdb import Database

# Basic open
db = Database.open("./data")

# Context manager (recommended)
with Database.open("./data") as db:
    # operations here
    pass

# Put (create/update)
db.put(b"key", b"value")

# Get (returns None if not found)
value = db.get(b"key")

# Delete
db.delete(b"key")

# Store at path
db.put_path("users/alice/email", b"alice@example.com")
db.put_path("config/app/theme", b"dark")

# Retrieve by path
email = db.get_path("users/alice/email")

# Auto-commit with context manager
with db.transaction() as txn:
    txn.put(b"key1", b"value1")
    txn.put(b"key2", b"value2")
    # Automatically commits on success
    # Automatically aborts on exception

# Manual control
txn = db.transaction()
txn.put(b"key", b"value")
txn.commit()  # or txn.abort()

# Scan all keys
for key, value in db.scan():
    print(key, value)

# Scan range [start, end)
for key, value in db.scan(b"user:", b"user;"):
    print(key, value)

# Prefix scan pattern
prefix = b"log:2024-01-15:"
end = prefix[:-1] + bytes([prefix[-1] + 1])
for key, value in db.scan(prefix, end):
    print(key, value)

# Force checkpoint to disk
lsn = db.checkpoint()

# Get storage statistics
stats = db.stats()
print(stats)
# {'memtable_size_bytes': 1024, 'wal_size_bytes': 4096, ...}

from sochdb import IpcClient

client = IpcClient.connect("/tmp/sochdb.sock", timeout=30.0)

# Ping (returns latency in seconds)
latency = client.ping()

# Put/Get/Delete - same as embedded
client.put(b"key", b"value")
value = client.get(b"key")
client.delete(b"key")

# Note: IPC uses list of path segments
client.put_path(["users", "alice", "email"], b"alice@example.com")
email = client.get_path(["users", "alice", "email"])

# Begin transaction
txn_id = client.begin_transaction()

# Perform operations
# (Note: IPC operations don't use txn_id directly yet)

# Commit or abort
commit_ts = client.commit(txn_id)
# or: client.abort(txn_id)

from sochdb import Query

# Fluent query interface
results = client.query("users/") \
    .limit(10) \
    .offset(0) \
    .select(["name", "email"]) \
    .execute()  # Returns TOON string

# Parse to list of dicts
results_list = client.query("users/") \
    .limit(10) \
    .to_list()

# Scan with prefix
results = client.scan("users/")
# Returns: [{"key": b"users/1", "value": b"..."}, ...]

from sochdb.bulk import bulk_build_index
import numpy as np

# Your embeddings (N × D)
embeddings = np.random.randn(10000, 768).astype(np.float32)

# Build HNSW index
stats = bulk_build_index(
    embeddings,
    output="my_index.hnsw",
    m=16,                    # HNSW max connections
    ef_construction=100,     # Construction search depth
    threads=0,               # 0 = auto
    quiet=False,             # Show progress
)

print(f"Built {stats.vectors} vectors at {stats.rate:.0f} vec/s")

from sochdb.bulk import bulk_query_index
import numpy as np

# Single query
query = np.random.randn(768).astype(np.float32)
results = bulk_query_index(
    index="my_index.hnsw",
    query=query,
    k=10,
    ef_search=64,
)

for neighbor in results:
    print(f"ID: {neighbor.id}, Distance: {neighbor.distance:.4f}")

from sochdb.bulk import get_sochdb_bulk_path

# Returns path to bundled or installed binary
path = get_sochdb_bulk_path()
print(f"Using binary: {path}")

@dataclass
class BulkBuildStats:
    vectors: int          # Total vectors indexed
    dimension: int        # Vector dimension
    elapsed_seconds: float
    rate: float           # vec/s
    index_size_bytes: int

from sochdb import Database

records = [
    {"id": 1, "name": "Alice", "email": "alice@example.com", "age": 30},
    {"id": 2, "name": "Bob", "email": "bob@example.com", "age": 25},
]

# Convert all fields
toon_str = Database.to_toon("users", records)
print(toon_str)
# users[2]{id,name,email,age}:1,Alice,alice@example.com,30;2,Bob,bob@example.com,25

# Convert specific fields only
toon_str = Database.to_toon("users", records, ["name", "email"])
print(toon_str)
# users[2]{name,email}:Alice,alice@example.com;Bob,bob@example.com

toon_str = "users[2]{name,email}:Alice,alice@ex.com;Bob,bob@ex.com"

table_name, fields, records = Database.from_toon(toon_str)

print(table_name)  # "users"
print(fields)      # ["name", "email"]
print(records)     
# [
#   {"name": "Alice", "email": "alice@ex.com"},
#   {"name": "Bob", "email": "bob@ex.com"}
# ]

from sochdb import Database
import openai

with Database.open("./knowledge_base") as db:
    # Query relevant documents
    results = db.execute_sql("""
        SELECT title, content, relevance_score 
        FROM documents 
        WHERE category = 'technical'
        ORDER BY relevance_score DESC
        LIMIT 10
    """)
    
    # Convert to TOON for efficient context
    records = [dict(row) for row in results]
    toon_context = Database.to_toon("documents", records, ["title", "content"])
    
    # Send to LLM (saves tokens!)
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": f"Context:\n{toon_context}"},
            {"role": "user", "content": "Summarize the technical documents"}
        ]
    )

# Regular scan: 1 FFI call per result
for key, value in txn.scan(b"prefix:", b"prefix;"):
    process(key, value)
# 10,000 results = 10,000 FFI calls
# At 500ns per call = 5ms overhead

# Batched scan: 1 FFI call per batch
for key, value in txn.scan_batched(b"prefix:", b"prefix;", batch_size=1000):
    process(key, value)
# 10,000 results = 10 FFI calls
# At 500ns per call = 5µs overhead (1000× faster!)

from sochdb import Database
import time

with Database.open("./my_db") as db:
    # Insert 100K test records
    print("Inserting 100K records...")
    with db.transaction() as txn:
        for i in range(100000):
            txn.put(f"user:{i:06d}".encode(), f"data_{i}".encode())
    
    # Benchmark regular scan
    start = time.time()
    txn = db.transaction()
    count = sum(1 for _ in txn.scan(b"user:", b"user;"))
    regular_time = time.time() - start
    txn.abort()
    print(f"Regular scan: {count} items in {regular_time:.3f}s")
    
    # Benchmark batched scan
    start = time.time()
    txn = db.transaction()
    count = sum(1 for _ in txn.scan_batched(b"user:", b"user;", batch_size=1000))
    batched_time = time.time() - start
    txn.abort()
    print(f"Batched scan: {count} items in {batched_time:.3f}s")
    
    speedup = regular_time / batched_time
    print(f"Speedup: {speedup:.1f}×")

from sochdb import Database

with Database.open("./my_db") as db:
    # Perform operations
    for i in range(1000):
        db.put(f"key:{i}".encode(), f"value:{i}".encode())
    
    # Get comprehensive statistics
    stats = db.stats()
    
    # Storage metrics
    print(f"Total keys: {stats.get('keys_count', 0):,}")
    print(f"Bytes written: {stats.get('bytes_written', 0):,}")
    print(f"Bytes read: {stats.get('bytes_read', 0):,}")
    
    # Transaction metrics
    print(f"Transactions committed: {stats.get('transactions_committed', 0)}")
    print(f"Transactions aborted: {stats.get('transactions_aborted', 0)}")
    
    # Query metrics
    print(f"Queries executed: {stats.get('queries_executed', 0)}")
    
    # Cache metrics
    hits = stats.get('cache_hits', 0)
    misses = stats.get('cache_misses', 0)
    total = hits + misses
    hit_rate = (hits / total * 100) if total > 0 else 0
    print(f"Cache hit rate: {hit_rate:.1f}%")

import time
from sochdb import Database

def monitor_database(db_path: str, interval: int = 5):
    """Monitor database statistics every N seconds."""
    with Database.open(db_path) as db:
        prev_stats = db.stats()
        
        while True:
            time.sleep(interval)
            curr_stats = db.stats()
            
            # Calculate deltas
            writes = curr_stats['bytes_written'] - prev_stats['bytes_written']
            reads = curr_stats['bytes_read'] - prev_stats['bytes_read']
            
            print(f"[{time.strftime('%H:%M:%S')}] "
                  f"Writes: {writes:,} bytes/s, "
                  f"Reads: {reads:,} bytes/s")
            
            prev_stats = curr_stats

# Run monitor
monitor_database("./my_db", interval=5)

from sochdb import Database

with Database.open("./my_db") as db:
    # Bulk import
    print("Importing 100K records...")
    with db.transaction() as txn:
        for i in range(100000):
            txn.put(f"bulk:{i}".encode(), f"data:{i}".encode())
    
    # Force checkpoint for durability
    print("Checkpointing...")
    lsn = db.checkpoint()
    print(f"Checkpoint complete at LSN {lsn}")
    print("All data is now durable on disk!")

from sochdb.plugins import PythonPlugin, PluginRegistry, TriggerEvent

# Define a simple validation plugin
plugin = PythonPlugin(
    name="email_validator",
    code='''
def on_before_insert(row: dict) -> dict:
    """Validate and normalize email addresses."""
    if "email" in row:
        email = row["email"].strip().lower()
        if "@" not in email:
            raise TriggerAbort("Invalid email format", code="INVALID_EMAIL")
        row["email"] = email
    return row
''',
    triggers={"users": ["BEFORE INSERT"]}
)

# Register plugin
registry = PluginRegistry()
registry.register(plugin)

# Test trigger
row = {"name": "Alice", "email": "  ALICE@EXAMPLE.COM  "}
result = registry.fire("users", TriggerEvent.BEFORE_INSERT, row)
print(result["email"])  # "alice@example.com"

from sochdb.plugins import PythonPlugin, TriggerAbort

# ML-powered fraud detection
fraud_detector = PythonPlugin(
    name="fraud_detector",
    code='''
import numpy as np

def on_before_insert(row: dict) -> dict:
    """Detect fraudulent transactions using ML."""
    amount = row.get("amount", 0)
    
    # Simple heuristic (replace with real ML model)
    if amount > 10000:
        raise TriggerAbort(
            f"Transaction amount ${amount} exceeds limit",
            code="FRAUD_DETECTED"
        )
    
    # Add fraud score
    row["fraud_score"] = min(amount / 10000, 1.0)
    
    return row
''',
    version="1.0.0",
    packages=["numpy"],
    triggers={"transactions": ["BEFORE INSERT"]}
)

registry.register(fraud_detector)

from sochdb.plugins import TriggerEvent

# Row-level triggers
TriggerEvent.BEFORE_INSERT  # Before inserting a row
TriggerEvent.AFTER_INSERT   # After inserting a row
TriggerEvent.BEFORE_UPDATE  # Before updating a row
TriggerEvent.AFTER_UPDATE   # After updating a row
TriggerEvent.BEFORE_DELETE  # Before deleting a row
TriggerEvent.AFTER_DELETE   # After deleting a row

# Batch triggers
TriggerEvent.ON_BATCH       # On batch operations

from sochdb.plugins import PluginRegistry

registry = PluginRegistry()

# Register plugin
registry.register(my_plugin)

# List all plugins
plugins = registry.list_plugins()
print(plugins)  # ["email_validator", "fraud_detector"]

# Get plugin by name
plugin = registry.get("email_validator")

# Unregister plugin
registry.unregister("email_validator")

# Fire trigger manually
row = {"email": "test@example.com"}
result = registry.fire("users", TriggerEvent.BEFORE_INSERT, row)

from sochdb.plugins import TriggerAbort

try:
    result = registry.fire("users", TriggerEvent.BEFORE_INSERT, row)
except TriggerAbort as e:
    print(f"Trigger aborted: {e}")
    print(f"Error code: {e.code}")
except RuntimeError as e:
    print(f"Plugin execution failed: {e}")

with Database.open("./my_db") as db:
    txn = db.transaction()
    print(f"Transaction ID: {txn.id}")  # e.g., 42
    txn.commit()

txn = db.transaction()
txn.put(b"key", b"value")
lsn = txn.commit()
print(f"Data committed at LSN {lsn}")

# Later, verify checkpoint includes this LSN
stats = db.stats()
if stats.get('last_checkpoint_lsn', 0) >= lsn:
    print("Data is checkpointed and durable")

with Database.open("./my_db") as db:
    # Create table
    db.execute_sql("CREATE TABLE users (id INT, name TEXT)")
    
    # Atomic multi-table transaction
    txn = db.transaction()
    
    # Insert via SQL
    txn.execute("INSERT INTO users VALUES (1, 'Alice')")
    
    # Insert via KV (same transaction!)
    txn.put(b"user:1:metadata", b'{"verified": true}')
    
    # Commit both SQL and KV operations atomically
    txn.commit()

from sochdb import IpcClient

# Connect to server
client = IpcClient.connect("./my_database/sochdb.sock", timeout=30.0)

# Use like embedded database
client.put(b"key", b"value")
value = client.get(b"key")

# Check latency
latency = client.ping()
print(f"Round-trip latency: {latency*1000:.2f}ms")

# Clean up
client.close()

# Process 1: Writer
from sochdb import IpcClient

client = IpcClient.connect("./shared_db/sochdb.sock")
for i in range(1000):
    client.put(f"log:{i}".encode(), f"entry_{i}".encode())
client.close()

# Process 2: Reader
from sochdb import IpcClient

client = IpcClient.connect("./shared_db/sochdb.sock")
results = client.scan("log:")
print(f"Found {len(results)} log entries")
client.close()

import grpc
from sochdb_pb2 import VectorSearchRequest
from sochdb_pb2_grpc import VectorServiceStub

channel = grpc.insecure_channel('localhost:50051')
stub = VectorServiceStub(channel)

request = VectorSearchRequest(
    index_path="index.hnsw",
    query_vector=query_vec.tobytes(),
    k=10,
    ef_search=64
)

response = stub.Search(request)
for neighbor in response.neighbors:
    print(f"ID: {neighbor.id}, Distance: {neighbor.distance}")

from sochdb import Database
import json
from datetime import datetime, timedelta

class SessionCache:
    def __init__(self, db, ttl_hours=24):
        self.db = db
        self.ttl = timedelta(hours=ttl_hours)
    
    def set(self, session_id: str, user_data: dict):
        expires = (datetime.utcnow() + self.ttl).isoformat()
        value = {"data": user_data, "expires": expires}
        self.db.put(f"session:{session_id}".encode(), 
                    json.dumps(value).encode())
    
    def get(self, session_id: str) -> dict | None:
        raw = self.db.get(f"session:{session_id}".encode())
        if not raw:
            return None
        value = json.loads(raw.decode())
        if datetime.fromisoformat(value["expires"]) < datetime.utcnow():
            self.delete(session_id)
            return None
        return value["data"]
    
    def delete(self, session_id: str):
        self.db.delete(f"session:{session_id}".encode())

class UserStore:
    def __init__(self, db):
        self.db = db
    
    def create_user(self, email: str, name: str) -> str:
        # Check uniqueness
        if self.db.get(f"idx:email:{email}".encode()):
            raise ValueError("Email exists")
        
        user_id = f"user_{int(time.time()*1000)}"
        user = {"id": user_id, "email": email, "name": name}
        
        with self.db.transaction() as txn:
            txn.put(f"users:{user_id}".encode(), 
                    json.dumps(user).encode())
            txn.put(f"idx:email:{email}".encode(), 
                    user_id.encode())
        
        return user_id
    
    def get_by_email(self, email: str) -> dict | None:
        user_id = self.db.get(f"idx:email:{email}".encode())
        if not user_id:
            return None
        data = self.db.get(f"users:{user_id.decode()}".encode())
        return json.loads(data.decode()) if data else None

class DocumentStore:
    def __init__(self, db, collection: str):
        self.db = db
        self.collection = collection
    
    def insert(self, doc: dict, doc_id: str = None) -> str:
        if not doc_id:
            doc_id = str(uuid.uuid4())[:8]
        key = f"doc:{self.collection}:{doc_id}".encode()
        self.db.put(key, json.dumps(doc).encode())
        return doc_id
    
    def find_all(self) -> list[dict]:
        prefix = f"doc:{self.collection}:".encode()
        docs = []
        for key, val in self.db.scan(prefix, prefix[:-1] + b";"):
            docs.append(json.loads(val.decode()))
        return docs

class FeatureFlags:
    def __init__(self, db, environment: str):
        self.db = db
        self.env = environment
    
    def set(self, feature: str, enabled: bool):
        path = f"features/{self.env}/{feature}"
        self.db.put_path(path, b"true" if enabled else b"false")
    
    def is_enabled(self, feature: str) -> bool:
        path = f"features/{self.env}/{feature}"
        val = self.db.get_path(path)
        return val and val.decode().lower() == "true"

# ✓ Good
with Database.open("./data") as db:
    db.put(b"key", b"value")

# ✗ Avoid
db = Database.open("./data")
db.put(b"key", b"value")
# Easy to forget db.close()

# ✓ Good - single transaction
with db.transaction() as txn:
    for item in items:
        txn.put(item.key, item.value)

# ✗ Slow - many small transactions
for item in items:
    db.put(item.key, item.value)

# ✓ Good - organized, scannable
db.put(b"user:123:profile", data)
db.put(b"user:123:settings", data)
db.put(b"order:456:items", data)

# ✗ Bad - no structure
db.put(b"user123profile", data)

# ✓ Good
value = db.get(b"key")
if value is None:
    # Handle missing key
    pass

# ✗ Bad - assumes key exists
value = db.get(b"key").decode()  # AttributeError if None

from sochdb.errors import DatabaseError, TransactionError

try:
    with db.transaction() as txn:
        txn.put(b"key", b"value")
except TransactionError as e:
    print(f"Transaction failed: {e}")
except DatabaseError as e:
    print(f"Database error: {e}")

txn = db.transaction()
txn.commit()
# txn.put(...)  # ✗ Error!

# Create new transaction instead
txn2 = db.transaction()
txn2.put(...)