sqliteproxy

package module
v0.0.0-...-e5d54d9 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 30, 2025 License: MIT Imports: 15 Imported by: 0

README

SQLiteProxy Logo

SQLite Multi-Tenant Proxy

A lightweight, efficient proxy for routing SQLite database queries to organization-specific databases in Go applications. This library enables seamless multi-tenancy while maintaining complete compatibility with the standard database/sql interface.

📋 Overview

SQLiteProxy automatically routes queries to organization-specific SQLite databases based on context information. It uses only standard library interfaces, making it a true drop-in replacement for *sql.DB.

graph TB
    A[Repository Layer] -->|Standard sql.DB Methods| B[SQLiteProxy or sql.DB]
    B -->|Configuration Choice| C[Multi-Tenant Mode]
    B -->|Configuration Choice| D[Single-Tenant Mode]
    C -->|Routes Based on Context| E[Org A Database]
    C -->|Routes Based on Context| F[Org B Database]
    C -->|Routes Based on Context| G[Org C Database]
    D -->|Direct Connection| H[Single Database]

✨ Features

  • Zero Custom Interfaces: Uses only standard Go library types
  • 100% Drop-in Compatible: Implements the same methods as *sql.DB
  • Configuration-Based: Switch between multi-tenant and single-tenant modes with a simple configuration change
  • Dynamic DSN Resolution: Flexible mapping of organization IDs to database paths
  • Connection Pooling: Efficient connection management per organization
  • Context Driven: Uses organization info from context for routing
  • Schema Migrations: Built-in migration system with auto, manual, and check modes

📦 Installation

go get uradical.io/go/sqliteproxy

🚀 Quick Start

Basic Usage
import (
    "context"
    "database/sql"
    
    "uradical.io/go/sqliteproxy"
)

// Choose implementation based on configuration
var db interface {
    QueryRowContext(context.Context, string, ...interface{}) *sql.Row
    ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
    Close() error
}

if config.MultiTenantMode {
    // Multi-tenant mode with SQLite proxy
    proxy := sqliteproxy.NewSQLiteProxy("./data/orgs")
    db = proxy
    
    // Add organization to context
    ctx = context.WithValue(context.Background(), 
          sqliteproxy.DefaultOrgIDKey, "organization-id")
} else {
    // Single-tenant mode with standard sql.DB
    sqlDB, _ := sql.Open("sqlite3", "./data/app.db")
    db = sqlDB
    
    // Standard context
    ctx = context.Background()
}

// Repository works the same either way
repo := NewUserRepository(db)
user, err := repo.FindByID(ctx, 123)
Repository Implementation

Your repositories can use standard database/sql methods without any awareness of multi-tenancy:

type UserRepository struct {
    db interface {
        QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row
        ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
    }
}

func NewUserRepository(db interface {
    QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row
    ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
}) *UserRepository {
    return &UserRepository{db: db}
}

func (r *UserRepository) FindByID(ctx context.Context, id int64) (*User, error) {
    // Works with both SQLiteProxy and standard sql.DB
    row := r.db.QueryRowContext(
        ctx, 
        "SELECT id, username, email FROM users WHERE id = ?", 
        id,
    )
    
    // Rest of the implementation...
}

🏗️ Architecture

The SQLiteProxy is designed to be a direct replacement for *sql.DB while adding multi-tenancy capabilities:

classDiagram
    class sqlDB {
        +QueryContext(ctx, query, args) *sql.Rows
        +ExecContext(ctx, query, args) sql.Result
        +BeginTx(ctx, opts) *sql.Tx
        +Close() error
    }
    
    class SQLiteProxy {
        -dsnResolver func(orgID, baseDSN) string
        -connections map[string]*sql.DB
        +QueryContext(ctx, query, args) *sql.Rows
        +ExecContext(ctx, query, args) sql.Result
        +BeginTx(ctx, opts) *sql.Tx
        +Close() error
    }
    
    sqlDB <|-- SQLiteProxy : implements same interface
Request Flow

This diagram shows how a database query flows through the system:

sequenceDiagram
    participant R as Repository
    participant P as SQLiteProxy
    participant DB as SQLite Databases
    
    R->>P: QueryContext(ctx, "SELECT * FROM users")
    P->>P: Extract orgID from context
    P->>P: Resolve DSN from orgID
    P->>P: Get/create connection for DSN
    P->>DB: Forward query to org-specific DB
    DB->>P: Return results
    P->>R: Return results to repository

📝 Configuration Options

The SQLiteProxy can be configured in various ways:

Basic Configuration
// Basic initialization
proxy := sqliteproxy.NewSQLiteProxy("./data/orgs")

// With custom options
proxy := sqliteproxy.NewSQLiteProxy(
    "./data/orgs",
    // Custom organization ID key in context
    sqliteproxy.WithOrgIDKey("my_custom_org_key"),
    
    // Custom DSN resolver
    sqliteproxy.WithDSNResolver(func(orgID, baseDir string) string {
        return fmt.Sprintf("%s/tenant_%s.db", baseDir, orgID)
    }),
    
    // Connection pool settings
    sqliteproxy.WithMaxOpenConns(10),
    sqliteproxy.WithMaxIdleConns(5),
    sqliteproxy.WithConnMaxLifetime(time.Hour),
    sqliteproxy.WithConnMaxIdleTime(time.Minute * 10),
)
With Migrations
// Add migrations for automatic schema management
migrations := []sqliteproxy.Migration{
    {Version: 1, Name: "create_users_table", Up: `CREATE TABLE users (...)`},
    {Version: 2, Name: "add_name_column", Up: `ALTER TABLE users ADD COLUMN name TEXT`},
}

proxy := sqliteproxy.NewSQLiteProxy("./data/orgs",
    sqliteproxy.WithMigrations(migrations...),
    sqliteproxy.WithMigrationMode(sqliteproxy.MigrationModeAuto),
)

🔄 Schema Migrations

SQLiteProxy includes a comprehensive migration system designed for multi-tenant applications.

Migration Modes
  • Auto Mode (default): Migrations run automatically when a tenant connects
  • Manual Mode: Migrations must be explicitly triggered via API
  • Check Mode: Connections fail if schema is outdated (for strict production environments)
Using Migrations
// 1. Define your migrations
migrations := []sqliteproxy.Migration{
    {
        Version: 1,
        Name:    "initial_schema",
        Up:      `CREATE TABLE users (id INTEGER PRIMARY KEY, email TEXT)`,
        Down:    `DROP TABLE users`, // Optional for rollback
    },
    // Add more migrations as your schema evolves
}

// 2. Configure proxy with migrations
proxy := sqliteproxy.NewSQLiteProxy("./data",
    sqliteproxy.WithMigrations(migrations...),
    sqliteproxy.WithMigrationMode(sqliteproxy.MigrationModeAuto),
)

// 3. For production, use the migrator API
migrator := proxy.Migrator()

// Check migration status
statuses, _ := migrator.Status(ctx)
for _, status := range statuses {
    fmt.Printf("Org %s: version %d/%d\n", 
        status.OrgID, status.CurrentVersion, status.TargetVersion)
}

// Run migrations manually
migrator.MigrateOrg(ctx, "org-123")        // Single org
migrator.MigrateBatch(ctx, orgIDs)         // Multiple orgs
migrator.MigrateAll(ctx)                   // All orgs

// Dry run to see pending migrations
pending, _ := migrator.DryRun(ctx, "org-123")

// Rollback if needed (requires Down migrations)
migrator.Rollback(ctx, "org-123", targetVersion)
Migration Best Practices
  1. Development: Use MigrationModeAuto for seamless development
  2. Production: Use MigrationModeManual or MigrationModeCheck for controlled deployments
  3. New Tenants: Always get the latest schema automatically
  4. Rollbacks: Always provide Down migrations for critical changes

🔄 Converting Existing Applications

Single-Tenant to Multi-Tenant

Converting an existing single-tenant application to multi-tenancy is seamless:

graph TB
    subgraph "Step 1: Original Single-Tenant App"
        A1[Repository] -->|sql.DB| B1[Single SQLite DB]
    end
    
    subgraph "Step 2: Refactor Repository"
        A2[Repository] -->|"interface{ QueryContext, ExecContext }"| B2[DB Implementation]
    end
    
    subgraph "Step 3: Configuration-Based Choice"
        A3[Repository] -->|Same Interface| B3[Configuration]
        B3 -->|"config.MultiTenant=false"| C3[sql.DB]
        B3 -->|"config.MultiTenant=true"| D3[SQLiteProxy]
    end

The key advantages:

  1. No Repository Changes: Your repository code doesn't need to change at all
  2. Configuration-Based: Switch between single and multi-tenant modes via configuration
  3. Standard Interfaces: No custom interfaces or types required
  4. Gradual Migration: Convert one repository at a time
Migration Steps

  1. Update Repository Constructors: Change from concrete *sql.DB type to interface requirements

    // Before
func NewUserRepo(db *sql.DB) *UserRepo {
    return &UserRepo{db: db}
}

// After
func NewUserRepo(db interface {
    QueryRowContext(context.Context, string, ...interface{}) *sql.Row
    ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
}) *UserRepo {
    return &UserRepo{db: db}
}

  2. Update Main/Config Code: Add logic to choose implementation

    var database interface {
    // Required methods
    QueryRowContext(context.Context, string, ...interface{}) *sql.Row
    ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
    Close() error
}

if config.MultiTenant {
    database = sqliteproxy.NewSQLiteProxy("./data")
} else {
    database = sql.Open("sqlite3", "./data/app.db")
}

// Create repositories
userRepo := repository.NewUserRepo(database)
orderRepo := repository.NewOrderRepo(database)

  3. Update Context Creation: Ensure organization ID is in context when in multi-tenant mode

    if config.MultiTenant {
    ctx = context.WithValue(ctx, sqliteproxy.DefaultOrgIDKey, orgID)
}

🔒 Security Considerations

  • DSN Resolution: Use a custom DSN resolver to validate organization IDs and prevent path traversal attacks
  • Context Validation: Be careful about context propagation throughout your application
  • Query Isolation: While queries go to separate databases, be mindful of resource limits on the host system
  • Error Handling: Handle errors from the proxy appropriately to prevent information leakage

🧪 Testing

Mocking for Unit Tests

The interface-based approach makes mocking very simple:

type mockDB struct {
    queryRowFunc func(ctx context.Context, query string, args ...interface{}) *sql.Row
    execFunc func(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
}

func (m *mockDB) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row {
    return m.queryRowFunc(ctx, query, args...)
}

func (m *mockDB) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) {
    return m.execFunc(ctx, query, args...)
}

// In tests
mock := &mockDB{
    queryRowFunc: func(ctx context.Context, query string, args ...interface{}) *sql.Row {
        // Return mock data
    },
}
repo := NewUserRepo(mock)
Integration Testing

For integration tests, you can use the actual proxy with in-memory SQLite databases:

// Create in-memory database proxy
proxy := sqliteproxy.NewSQLiteProxy(
    ":memory:",
    sqliteproxy.WithDSNResolver(func(orgID, _ string) string {
        return fmt.Sprintf("file::memory:?cache=shared&org=%s", orgID)
    }),
)

// Initialize with test data
initTestData(ctx, proxy)

// Run tests with the proxy
repo := NewUserRepo(proxy)
// ...

📚 Advanced Usage

Middleware for HTTP Handlers

Extract organization ID from HTTP requests:

func OrganizationMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Extract org ID from header, subdomain, JWT, etc.
        orgID := r.Header.Get("X-Organization-ID")
        
        // Add to context
        ctx := context.WithValue(r.Context(), sqliteproxy.DefaultOrgIDKey, orgID)
        
        // Call next handler with updated context
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}
Database Initialization

Initialize organization databases on first access:

proxy := sqliteproxy.NewSQLiteProxy(
    "./data",
    sqliteproxy.WithDSNResolver(func(orgID, baseDir string) string {
        dbPath := filepath.Join(baseDir, fmt.Sprintf("%s.db", orgID))
        
        // Check if database exists
        if _, err := os.Stat(dbPath); os.IsNotExist(err) {
            // Initialize database
            if err := initDatabase(dbPath); err != nil {
                log.Printf("Error initializing database: %v", err)
            }
        }
        
        return dbPath
    }),
)
Using Multiple Organization Identifiers

Support different ways to identify organizations:

// Organization from subdomain
func GetOrgFromSubdomain(r *http.Request) string {
    host := r.Host
    parts := strings.Split(host, ".")
    if len(parts) >= 3 {
        return parts[0]
    }
    return "default"
}

// Organization from path
func GetOrgFromPath(r *http.Request) string {
    path := r.URL.Path
    parts := strings.Split(path, "/")
    if len(parts) >= 2 {
        return parts[1]
    }
    return "default"
}

// Use in middleware
func OrgMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        var orgID string
        
        // Try various methods to get org ID
        if orgID = r.Header.Get("X-Organization"); orgID != "" {
            // From header
        } else if orgID = GetOrgFromSubdomain(r); orgID != "" {
            // From subdomain
        } else if orgID = GetOrgFromPath(r); orgID != "" {
            // From path
        } else {
            // Default
            orgID = "default"
        }
        
        ctx := context.WithValue(r.Context(), sqliteproxy.DefaultOrgIDKey, orgID)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

📈 Performance & Production Readiness

Performance Comparison

SQLiteProxy vs Direct SQLite Performance

SQLiteProxy maintains near-identical performance to direct SQLite while adding multi-tenancy. Benchmark testing shows equivalent or better transaction throughput compared to direct connections.

Performance Considerations:

  • Connection Pooling: Efficient per-organization connection management
  • Context Overhead: Minimal organization ID lookup cost
  • Transaction Strength: Particularly efficient with transaction-heavy workloads
  • Monitoring: Use Stats() method for production monitoring

🛡️ Production Readiness & Robustness

SQLiteProxy has undergone comprehensive stress testing to ensure production readiness. Our "evil" test suite pushes the library to its limits across multiple dimensions.

Evil Stress Test Results

62,000+ operations tested across 7 production nightmare scenarios

Test Success Rate Operations Scenario
🚀 Concurrent Chaos 87.7% 10,000 100 goroutines × 200 orgs × 50 ops each
🧠 Memory Torture 100% 50,000 No leaks detected across 1,000 iterations
⚡ Resource Starvation 94.5% 2,000 100 orgs fighting for 20 connections
🔄 Transaction Hell 100% 1,000 10 concurrent long-running transactions
🛡️ Malicious Attacks 100% 13 vectors SQL injection, path traversal, null bytes
⚡ Rapid Shutdown 100% Variable Clean exit under concurrent load
❌ Context Chaos 100% Variable Pre-cancel, mid-operation, timeout patterns

Key Achievement: Fixed critical resource exhaustion bug - 374% improvement from 20% to 94.5% success rate.

✅ VERDICT: Production Ready - Survives extreme load with graceful degradation

Error Recovery & Resilience Patterns
stateDiagram-v2
    [*] --> Normal: System Start
    Normal --> ResourceLimit: High Load Detected
    ResourceLimit --> EvictionTriggered: Connection Limit Reached
    EvictionTriggered --> ConnectionsFreed: Idle Connections Removed
    ConnectionsFreed --> Normal: Capacity Available
    
    ResourceLimit --> GracefulDegradation: Eviction Insufficient
    GracefulDegradation --> Normal: Load Decreases
    
    Normal --> MaliciousInput: Attack Detected
    MaliciousInput --> SecurityBlock: Input Validation Failed
    SecurityBlock --> Normal: Request Rejected
    
    Normal --> ContextCancelled: Client Timeout
    ContextCancelled --> CleanupResources: Graceful Handling
    CleanupResources --> Normal: Resources Released
    
    Normal --> Shutdown: Stop Signal
    Shutdown --> GracefulShutdown: Wait for Active Requests
    GracefulShutdown --> [*]: Clean Exit
    
    note right of EvictionTriggered
        Intelligent LRU eviction
        maintains 50%+ success rate
        even under extreme load
    end note
    
    note right of SecurityBlock
        Handles SQL injection,
        path traversal, malformed
        input gracefully
    end note
Chaos Engineering Results
%%{init: {"pie": {"textPosition": 0.5}, "themeVariables": {"pieSectionTextColor": "#000000", "pieTitleTextSize": "25px", "pie1": "#4caf50", "pie2": "#ffeb3b", "pie3": "#f44336"}}}%%
pie title Chaos Engineering Test Results
    "Complete Success" : 71
    "Graceful Degradation" : 24
    "Hard Failures" : 5
Key Robustness Features

  1. Intelligent Resource Management

    • LRU-based connection eviction
    • Automatic cleanup under pressure
    • 94.5% success rate even when exceeding limits

  2. Security-First Design

    • Path traversal protection
    • SQL injection resistance
    • Input validation and sanitization

  3. Graceful Degradation

    • Clean error handling under all conditions
    • No panics or crashes detected in stress tests
    • Proper resource cleanup on failures

  4. Production Monitoring

    • Built-in metrics and tracing
    • Connection pool statistics
    • Performance monitoring hooks

Running the Benchmarks

To run the benchmarks and generate the performance chart:

# Run the comparison benchmarks
go test -bench=BenchmarkComparison -benchmem ./...

# Run the evil stress tests
go test -v ./sqliteproxy_tests -run TestEvil

To generate this chart and run the benchmarks yourself:

go run ./cmd/benchmark_chart.go

Last updated: 2025-07-30

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

Documentation

Overview

Package sqliteproxy provides a multi-tenant SQLite database proxy that routes queries to organization-specific databases based on context.

This package enables seamless multi-tenancy for SQLite applications while maintaining complete compatibility with the standard database/sql interface.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Migration 

type Migration struct {
	Version     int
	Name        string
	Up          string // SQL to apply the migration
	Down        string // SQL to rollback the migration (optional)
	Description string // Human-readable description
}

Migration represents a single schema migration

type MigrationMode 

type MigrationMode int

MigrationMode defines how migrations are applied 

const (
	// MigrationModeAuto automatically runs migrations on first connection (default)
	MigrationModeAuto MigrationMode = iota
	// MigrationModeManual requires explicit migration calls
	MigrationModeManual
	// MigrationModeCheck verifies schema version, fails if outdated
	MigrationModeCheck
)

type MigrationStatus 

type MigrationStatus struct {
	OrgID          string
	CurrentVersion int
	TargetVersion  int
	IsUpToDate     bool
	AppliedAt      *time.Time
}

MigrationStatus represents the current migration state

type Migrator 

type Migrator struct {
	// contains filtered or unexported fields
}

Migrator handles schema migrations for the proxy

func (*Migrator) DryRun 

func (m *Migrator) DryRun(ctx context.Context, orgID string) ([]Migration, error)

DryRun simulates migrations without applying them

func (*Migrator) MigrateAll 

func (m *Migrator) MigrateAll(ctx context.Context) error

MigrateAll applies pending migrations to all organizations

func (*Migrator) MigrateBatch 

func (m *Migrator) MigrateBatch(ctx context.Context, orgIDs []string) error

MigrateBatch applies pending migrations to a specific set of organizations

func (*Migrator) MigrateOrg 

func (m *Migrator) MigrateOrg(ctx context.Context, orgID string) error

MigrateOrg applies pending migrations to a specific organization

func (*Migrator) Rollback 

func (m *Migrator) Rollback(ctx context.Context, orgID string, targetVersion int) error

Rollback rolls back to a specific version (if Down migrations are provided)

func (*Migrator) Status 

func (m *Migrator) Status(ctx context.Context) ([]MigrationStatus, error)

Status returns the migration status for all organizations

func (*Migrator) StatusForOrg 

func (m *Migrator) StatusForOrg(ctx context.Context, orgID string) (*MigrationStatus, error)

StatusForOrg returns the migration status for a specific organization

type OrgIDKey 

type OrgIDKey string

OrgIDKey is the context key for storing organization ID 

const (
	// DefaultOrgIDKey is the default context key for the organization ID
	DefaultOrgIDKey OrgIDKey = "organization_id"
)

type SQLiteProxy 

type SQLiteProxy struct {
	// contains filtered or unexported fields
}

SQLiteProxy implements most of the *sql.DB interface methods but routes queries to organization-specific databases based on context

func NewSQLiteProxy 

func NewSQLiteProxy(directoryOrDSN string, options ...SQLiteProxyOption) *SQLiteProxy

NewSQLiteProxy creates a new proxy with the given base directory or DSN template If directoryOrDSN is a directory, each organization will get a file in that directory If it's a DSN template, it will be used with the DSN resolver

func (*SQLiteProxy) Begin 

func (p *SQLiteProxy) Begin() (*sql.Tx, error)

Begin starts a transaction with default options However, since we need organization context, we require the user to use BeginTx

func (*SQLiteProxy) BeginTx 

func (p *SQLiteProxy) BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error)

BeginTx starts a transaction with the organization from the context

func (*SQLiteProxy) Close 

func (p *SQLiteProxy) Close() error

Close performs graceful shutdown of the proxy with default timeout

func (*SQLiteProxy) CloseWithContext 

func (p *SQLiteProxy) CloseWithContext(ctx context.Context) error

CloseWithContext performs graceful shutdown using the provided context

func (*SQLiteProxy) CloseWithTimeout 

func (p *SQLiteProxy) CloseWithTimeout(timeout time.Duration) error

CloseWithTimeout performs graceful shutdown with a custom timeout

func (*SQLiteProxy) Conn 

func (p *SQLiteProxy) Conn(ctx context.Context) (*sql.Conn, error)

Conn returns a raw database connection

func (*SQLiteProxy) Exec 

func (p *SQLiteProxy) Exec(query string, args ...interface{}) (sql.Result, error)

Exec is a convenience method that calls ExecContext with a background context However, since we need organization context, we require the user to use ExecContext

func (*SQLiteProxy) ExecContext 

func (p *SQLiteProxy) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)

ExecContext executes a query with the organization from the context

func (*SQLiteProxy) Migrator 

func (p *SQLiteProxy) Migrator() *Migrator

Migrator returns a Migrator instance for managing migrations

func (*SQLiteProxy) Ping 

func (p *SQLiteProxy) Ping() error

Ping verifies that the connections are available by creating a connection to a test organization

func (*SQLiteProxy) PingContext 

func (p *SQLiteProxy) PingContext(ctx context.Context) error

PingContext verifies that connections can be established

func (*SQLiteProxy) Prepare 

func (p *SQLiteProxy) Prepare(query string) (*sql.Stmt, error)

Prepare is a convenience method that calls PrepareContext with a background context However, since we need organization context, we require the user to use PrepareContext

func (*SQLiteProxy) PrepareContext 

func (p *SQLiteProxy) PrepareContext(ctx context.Context, query string) (*sql.Stmt, error)

PrepareContext prepares a statement for later queries or executions

func (*SQLiteProxy) Query 

func (p *SQLiteProxy) Query(query string, args ...interface{}) (*sql.Rows, error)

Query is a convenience method that calls QueryContext with a background context However, since we need organization context, we require the user to use QueryContext

func (*SQLiteProxy) QueryContext 

func (p *SQLiteProxy) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)

QueryContext executes a query with the organization from the context Note: No timeout is applied to Query operations because they return lazy *sql.Rows that may be scanned much later. Apply timeouts at the application level if needed.

func (*SQLiteProxy) QueryRow 

func (p *SQLiteProxy) QueryRow(query string, args ...interface{}) *sql.Row

QueryRow is a convenience method that calls QueryRowContext with a background context However, since we need organization context, we require the user to use QueryRowContext

func (*SQLiteProxy) QueryRowContext 

func (p *SQLiteProxy) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row

QueryRowContext executes a query that returns a single row Note: No timeout is applied to QueryRow operations because they return lazy *sql.Row that may be scanned much later. Apply timeouts at the application level if needed.

func (*SQLiteProxy) Stats 

func (p *SQLiteProxy) Stats() StatsInfo

Stats returns current connection statistics

type SQLiteProxyOption 

type SQLiteProxyOption func(*SQLiteProxy)

SQLiteProxyOption configures the SQLiteProxy

func WithConnMaxIdleTime 

func WithConnMaxIdleTime(d time.Duration) SQLiteProxyOption

WithConnMaxIdleTime sets the maximum idle time for connections

func WithConnMaxLifetime 

func WithConnMaxLifetime(d time.Duration) SQLiteProxyOption

WithConnMaxLifetime sets the maximum lifetime of connections

func WithDSNResolver 

func WithDSNResolver(resolver func(orgID, baseDsnInfo string) string) SQLiteProxyOption

WithDSNResolver sets a custom DSN resolver function

func WithEviction 

func WithEviction(maxConnections int, evictionInterval, idleTimeout time.Duration) SQLiteProxyOption

WithEviction enables connection eviction with the specified parameters

func WithLogger 

func WithLogger(logger *slog.Logger) SQLiteProxyOption

WithLogger sets a custom structured logger

func WithMaxIdleConns 

func WithMaxIdleConns(n int) SQLiteProxyOption

WithMaxIdleConns sets the maximum number of idle connections per database

func WithMaxOpenConns 

func WithMaxOpenConns(n int) SQLiteProxyOption

WithMaxOpenConns sets the maximum number of open connections per database

func WithMigrationMode 

func WithMigrationMode(mode MigrationMode) SQLiteProxyOption

WithMigrationMode sets how migrations are applied

func WithMigrations 

func WithMigrations(migrations ...Migration) SQLiteProxyOption

WithMigrations configures the proxy with schema migrations

func WithOrgIDKey 

func WithOrgIDKey(key OrgIDKey) SQLiteProxyOption

WithOrgIDKey sets the context key used to extract organization ID

func WithQueryTimeout 

func WithQueryTimeout(timeout time.Duration) SQLiteProxyOption

WithQueryTimeout sets a timeout that applies to all database operations If timeout is 0, no timeout is applied (database/sql default behavior)

func WithResourceLimits 

func WithResourceLimits(maxTotalConnections int64, maxMemoryPerTenant, maxTotalMemory int64) SQLiteProxyOption

WithResourceLimits sets global resource limits

func WithShutdownTimeout 

func WithShutdownTimeout(timeout time.Duration) SQLiteProxyOption

WithShutdownTimeout sets the graceful shutdown timeout

func WithTelemetry 

func WithTelemetry(traceProvider trace.TracerProvider, meterProvider metric.MeterProvider) SQLiteProxyOption

WithTelemetry enables OpenTelemetry instrumentation

type StatsInfo 

type StatsInfo struct {
	OpenConnections    int
	OrganizationCount  int
	TotalConnections   int64
	EvictionEnabled    bool
	LastEvictionRun    *time.Time
	ConnectionsEvicted int64
}

StatsInfo provides information about the proxy's connection state

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.