Go SDK

go get github.com/OpenWorkBench-Co/RelataDB/sdks/go

package main
 
import (
    "context"
    "fmt"
    "log"
 
    "github.com/OpenWorkBench-Co/RelataDB/sdks/go/relata"
)
 
func main() {
    client := relata.New("http://localhost:9090", &relata.ClientOptions{
        BearerToken:    "your-token",
        DefaultPurpose: "analytics",
    })
 
    result, err := client.Query(context.Background(), "SELECT * FROM Person LIMIT 10")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%d rows in %d ms\n", result.RowCount, result.ElapsedMs)
    result.Each(func(row map[string]any) {
        fmt.Println(row)
    })
}

m, err := relata.NewMemory("http://localhost:9090", "agent-notes",
    &relata.MemoryOptions{BearerToken: token})
if err != nil {
    log.Fatal(err) // ErrPurposeRequired when purpose is empty
}
defer // Memory has no Close — net/http needs none
 
id, _ := m.Add(ctx, "Alice prefers dark mode")          // store → memory id
hits, _ := m.Search(ctx, "ui preferences", relata.WithTopK(5)) // recall
dec, _ := m.Forget(ctx, id)                              // governed retract, not a hard delete

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
result, err := client.Query(ctx, "SELECT * FROM Person")

client := relata.New(baseURL string, opts *relata.ClientOptions) *relata.Client

type ClientOptions struct {
    BearerToken    string            // Authorization: Bearer <token>
    DefaultPurpose string            // applied when WithPurpose is not passed
    Timeout        time.Duration     // per-request timeout (default 30s)
    HTTPClient     *http.Client      // inject for mTLS, proxies, tracing
 
    // Multi-tenant + delegation (#220, ADR-132)
    Tenant         string            // X-Organization-Id (multi-tenant)
    ActingAs       string            // X-Acting-As (delegation)
    DelegatedBy    string            // X-Delegated-By
 
    // Static caller headers (win over SDK defaults; X-Request-ID pinned here
    // disables the per-request auto-generation)
    Headers        map[string]string
 
    // Transport hardening (mirrors _http.py)
    MaxRetries     int               // retry 502/503/504 + network errors (default 0)
    RetryBackoff   time.Duration     // exponential base (default 500ms)
}

// Default on the client
client := relata.New(url, &relata.ClientOptions{DefaultPurpose: "investigation"})
 
// Or override per-call
result, err := client.Query(ctx, sql, relata.WithPurpose("audit"))

client := relata.New(url, &relata.ClientOptions{
    BearerToken: token,
    Tenant:      "org-acme",     // X-Organization-Id
    ActingAs:    "user-bob",     // X-Acting-As
    DelegatedBy: "user-alice",   // X-Delegated-By
})

result, err := relata.NewQuery("SELECT * FROM Person").
    Purpose("investigation").
    Where("nationality = 'PK'").
    Where("risk_score > 0.7").         // multiple .Where() → AND
    AsOf("2025-01-01").                // bi-temporal point-in-time
    WithProvenance().                  // attach PROV-O lineage columns
    Limit(50).
    Execute(ctx, client)

sql := relata.NewQuery("SELECT * FROM Person").
    Where("risk_score > 0.7").
    AsOf("2025-01-01").
    SQL()
// → SELECT * FROM Person WHERE risk_score > 0.7 AS OF '2025-01-01'

// Graph traversal: Pregel BFS between two entities
result, err := relata.PathsBetween("entity-A", "entity-B", 4).
    Purpose("investigation").Execute(ctx, client)
 
// Biometric face search
result, err := relata.MatchFace("s3://faces/suspect.jpg", 10).
    Purpose("investigation").Execute(ctx, client)
 
// IdentityIndex resolver (phone, Aadhaar, IMEI, IP, …)
result, err := relata.LookupIdentity("+919876543210").
    Purpose("investigation").Execute(ctx, client)
 
// BM25 + vector hybrid search
result, err := relata.HybridSearch("Person", "Ahmed Khalil Karachi", 25).
    Purpose("analysis").Execute(ctx, client)

m, err := relata.NewMemory(url, "agent-notes", &relata.MemoryOptions{
    BearerToken: token,
    SessionID:   "sess-1",
})

client := relata.New(url, &relata.ClientOptions{
    BearerToken:    token,
    DefaultPurpose: "compliance",
    Tenant:         "org-acme",
})
 
mcp := relata.NewMcpClient(client)
gov := relata.NewGovernanceClient(client)
 
profile, _ := mcp.GetEntityProfile(ctx, "person-123", "compliance")
holds, _ := gov.ListLegalHolds(ctx)
sigma, _ := gov.ImportSigma(ctx, sigmaYAML)

s := relata.NewStreamingClient(client)
it, err := s.QueryRows(ctx, "SELECT * FROM Person", nil) // *RowIterator
if err != nil { log.Fatal(err) }
defer it.Close()
for it.Next() {
    row := it.Row()
    fmt.Println(row["name"])
}
if err := it.Err(); err != nil { log.Fatal(err) }

result, _ := client.Query(ctx, "SELECT * FROM Person LIMIT 10")
for _, row := range result.Rows {        // iterate
    fmt.Println(row["name"])
}
names := result.Column("name")           // []any, nil for missing values
fmt.Printf("%d rows in %d ms\n", result.RowCount, result.ElapsedMs)

import "errors"
 
_, err := client.Query(ctx, sql)
switch {
case errors.Is(err, relata.ErrPurposeRequired):
    // No purpose declared — add WithPurpose or set DefaultPurpose
case errors.Is(err, relata.ErrUnauthorized):
    // Bearer token missing or revoked (401)
case errors.Is(err, relata.ErrForbidden):
    // Cedar ACL denied the query (403)
case errors.Is(err, relata.ErrNotFound):
    // Resource not found (404)
case errors.Is(err, relata.ErrConflict):
    // Version / uniqueness conflict (409)
case errors.Is(err, relata.ErrValidation):
    // Request body failed validation (422)
case errors.Is(err, relata.ErrRateLimited):
    // Rate limit or quota exhausted (429) — ErrQuotaExhausted is an alias
case errors.Is(err, relata.ErrServerError):
    // 5xx (after retries exhausted)
case errors.Is(err, relata.ErrConnection):
    // Network error / timeout / server unreachable
case errors.Is(err, relata.ErrChainCorrupted):
    // Audit hash chain integrity failure — treat as a security event
}
 
// HTTP status + RFC 7807 fields via type assertion
var re *relata.RelataError
if errors.As(err, &re) {
    fmt.Println(re.StatusCode, re.Message)   // HTTP 403: Forbidden: policy deny
    fmt.Println(re.Code)                      // RELATA.ACL.DENY
    fmt.Println(re.TypeURL)                   // https://relata.io/errors/forbidden
    fmt.Println(re.RequestID)                 // rid-xyz
    fmt.Println(re.RetryAfter)                // 5s (from Retry-After header)
}

transport := &http.Transport{TLSClientConfig: tlsCfg}
client := relata.New(url, &relata.ClientOptions{
    HTTPClient: &http.Client{
        Transport: transport,
        Timeout:   45 * time.Second,
    },
})

client := relata.New(url, &relata.ClientOptions{BearerToken: tok})
oc := relata.NewObjectClient(client)
oc.Upsert(ctx, "AgentTask", "t-1",
    map[string]any{"task_id": "t-1", "status": "done"}, nil)

s3 := relata.NewS3Client(client)
hc := s3.HTTP(nil)
req, _ := http.NewRequestWithContext(ctx, "PUT",
    s3.BaseURL()+"/acme-intel/report.pdf", bytes.NewReader(data))
resp, err := hc.Do(req)

./target/debug/relata serve &
 
go run ./sdks/go/examples/basic -url http://localhost:9090
 
go run ./sdks/go/examples/investigation \
    -url   http://localhost:9090 \
    -phone "+919876543210"