Working with databases in Go has taught me valuable lessons about performance optimization. The standard library’s database/sql package provides a solid foundation, but achieving maximum efficiency requires understanding both Go and database internals.

Connection pool management forms the basis of database performance in Go applications. I’ve found that proper configuration prevents many common performance issues before they occur. The database/sql package maintains connections automatically, but requires explicit sizing.

func initializeDB() (*sql.DB, error) {
    db, err := sql.Open("postgres", "postgres://user:password@localhost/mydb?sslmode=disable")
    if err != nil {
        return nil, err
    }
    
    // Configure pool based on application needs
    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(10)
    db.SetConnMaxLifetime(time.Minute * 5)
    
    // Verify connection works
    if err = db.Ping(); err != nil {
        return nil, err
    }
    
    return db, nil
}

Most applications benefit from setting MaxOpenConns to a value appropriate for your database server capabilities and application concurrency. Typically, this ranges from 10-50 for modest workloads. Setting MaxIdleConns to around half this value maintains ready connections without wasting resources.

I learned the hard way that Go’s garbage collector doesn’t immediately free database connections. Setting ConnMaxLifetime prevents connection issues with databases that terminate idle connections after specific periods.

Indexing strategy significantly impacts query performance. Adding indexes improves read operations but can slow down writes, requiring careful balance. I focus on understanding access patterns first, then creating indexes matching those patterns.

For queries filtering on multiple columns, composite indexes often outperform multiple single-column indexes. The order of columns matters - place the most selective columns first.

// Example of creating a composite index in SQL
// CREATE INDEX idx_users_email_status ON users(email, status);

// This query will use the index efficiently
rows, err := db.QueryContext(ctx, 
    "SELECT id, name FROM users WHERE email = $1 AND status = $2",
    "[email protected]", "active")

Query analysis tools provide insights beyond guesswork. I routinely use EXPLAIN ANALYZE to understand exactly how my queries execute. This practice helps identify missing indexes, suboptimal join strategies, or full table scans that could be optimized.

Prepared statements dramatically improve performance for frequently executed queries by parsing and planning queries once, then reusing the plan. They also provide protection against SQL injection attacks.

stmt, err := db.PrepareContext(ctx, "SELECT id, name, email FROM users WHERE id > $1 LIMIT $2")
if err != nil {
    return err
}
defer stmt.Close()

// Reuse the prepared statement multiple times
rows, err := stmt.QueryContext(ctx, lastID, 100)
// Process rows...

// Use it again with different parameters
rows, err = stmt.QueryContext(ctx, newLastID, 200)
// Process more rows...

When working with prepared statements, I maintain them for the application lifetime when possible. Creating and destroying prepared statements frequently negates their performance benefits.

Batch operations reduce database round-trips, providing substantial performance improvements when working with multiple records. Instead of executing many individual queries, I combine operations where possible.

// Instead of multiple individual inserts in a loop
func batchInsertUsers(ctx context.Context, db *sql.DB, users []User) error {
    // Create a transaction for the batch
    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }
    defer tx.Rollback()
    
    // Prepare statement once for the transaction
    stmt, err := tx.PrepareContext(ctx, "INSERT INTO users(name, email) VALUES($1, $2)")
    if err != nil {
        return err
    }
    defer stmt.Close()
    
    // Execute for each user
    for _, user := range users {
        if _, err = stmt.ExecContext(ctx, user.Name, user.Email); err != nil {
            return err
        }
    }
    
    // Commit the transaction
    return tx.Commit()
}

For even better performance with bulk inserts, I use database-specific features like PostgreSQL’s COPY command or MySQL’s batch insert syntax when possible.

Context management prevents resource leaks from hung queries. Every database operation in Go should include a timeout context to avoid indefinite blocking.

func queryWithTimeout(db *sql.DB, userID int) (User, error) {
    var user User
    
    // Create context with 3-second timeout
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()
    
    err := db.QueryRowContext(ctx, "SELECT id, name, email FROM users WHERE id = $1", userID).
        Scan(&user.ID, &user.Name, &user.Email)
    if err != nil {
        if errors.Is(err, context.DeadlineExceeded) {
            return user, fmt.Errorf("database query timed out")
        }
        return user, err
    }
    
    return user, nil
}

Query structuring significantly influences performance. I avoid SELECT * unless absolutely necessary, as it increases network traffic and memory usage. Specifying only needed columns reduces the data transfer between database and application.

// Instead of SELECT * FROM users
rows, err := db.QueryContext(ctx, 
    "SELECT id, name, email FROM users WHERE status = $1",
    "active")

Column data types matter for performance. I use appropriate types for ID columns (like INT or UUID) and create proper indexes for them. String-based IDs often lead to performance problems at scale.

For complex applications, I implement query caching strategies. Simple in-memory caches with expiration for frequently accessed, rarely changed data can significantly reduce database load.

type Cache struct {
    mu    sync.RWMutex
    items map[string]cacheItem
}

type cacheItem struct {
    value      interface{}
    expiration time.Time
}

func (c *Cache) Get(key string) (interface{}, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    
    item, found := c.items[key]
    if !found {
        return nil, false
    }
    
    // Check if item has expired
    if time.Now().After(item.expiration) {
        return nil, false
    }
    
    return item.value, true
}

func (c *Cache) Set(key string, value interface{}, duration time.Duration) {
    c.mu.Lock()
    defer c.mu.Unlock()
    
    c.items[key] = cacheItem{
        value:      value,
        expiration: time.Now().Add(duration),
    }
}

Transaction management improves both performance and data integrity. Grouping related operations reduces lock contention and network round-trips.

func transferFunds(ctx context.Context, db *sql.DB, fromID, toID int, amount float64) error {
    // Start a transaction
    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }
    defer tx.Rollback() // Will be ignored if transaction succeeds
    
    // Perform withdrawal
    _, err = tx.ExecContext(ctx,
        "UPDATE accounts SET balance = balance - $1 WHERE id = $2 AND balance >= $1",
        amount, fromID)
    if err != nil {
        return err
    }
    
    // Check if the withdrawal succeeded (affected a row)
    rows, err := tx.QueryContext(ctx, 
        "SELECT COUNT(*) FROM accounts WHERE id = $1 AND balance >= 0", 
        fromID)
    if err != nil {
        return err
    }
    defer rows.Close()
    
    var count int
    if rows.Next() {
        if err := rows.Scan(&count); err != nil {
            return err
        }
    }
    if count == 0 {
        return fmt.Errorf("insufficient funds")
    }
    
    // Perform deposit
    _, err = tx.ExecContext(ctx,
        "UPDATE accounts SET balance = balance + $1 WHERE id = $2",
        amount, toID)
    if err != nil {
        return err
    }
    
    // Commit the transaction
    return tx.Commit()
}

When dealing with large result sets, I use pagination to limit memory usage and improve response times. Cursor-based pagination usually performs better than offset-based approaches for large datasets.

func paginateUsers(ctx context.Context, db *sql.DB, lastID int, limit int) ([]User, error) {
    rows, err := db.QueryContext(ctx,
        "SELECT id, name, email FROM users WHERE id > $1 ORDER BY id LIMIT $2",
        lastID, limit)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    var users []User
    for rows.Next() {
        var u User
        if err := rows.Scan(&u.ID, &u.Name, &u.Email); err != nil {
            return nil, err
        }
        users = append(users, u)
    }
    
    if err := rows.Err(); err != nil {
        return nil, err
    }
    
    return users, nil
}

For read-heavy applications, I implement database replicas when possible. The Go database/sql package doesn’t directly support read/write splitting, but it’s easy to implement:

type DB struct {
    writer *sql.DB
    reader *sql.DB
}

func NewDB(writerDSN, readerDSN string) (*DB, error) {
    writer, err := sql.Open("postgres", writerDSN)
    if err != nil {
        return nil, err
    }
    
    reader, err := sql.Open("postgres", readerDSN)
    if err != nil {
        writer.Close()
        return nil, err
    }
    
    // Configure connection pools
    writer.SetMaxOpenConns(10)
    reader.SetMaxOpenConns(50) // More connections for reads
    
    return &DB{
        writer: writer,
        reader: reader,
    }, nil
}

func (db *DB) QueryUser(ctx context.Context, id int) (User, error) {
    var user User
    err := db.reader.QueryRowContext(ctx,
        "SELECT id, name, email FROM users WHERE id = $1", id).
        Scan(&user.ID, &user.Name, &user.Email)
    return user, err
}

func (db *DB) UpdateUser(ctx context.Context, user User) error {
    _, err := db.writer.ExecContext(ctx,
        "UPDATE users SET name = $1, email = $2 WHERE id = $3",
        user.Name, user.Email, user.ID)
    return err
}

SQL query logging helps identify performance issues in production. I implement middleware that logs slow queries:

type LoggingDB struct {
    db        *sql.DB
    threshold time.Duration
    logger    Logger
}

func (ldb *LoggingDB) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) {
    start := time.Now()
    rows, err := ldb.db.QueryContext(ctx, query, args...)
    duration := time.Since(start)
    
    if duration > ldb.threshold {
        ldb.logger.Printf("Slow query (%s): %s %v", duration, query, args)
    }
    
    return rows, err
}

// Implement other methods from database/sql.DB similarly

Database-specific optimizations can provide significant performance improvements. For PostgreSQL, I use jsonb for flexible schemas with proper indexing. For MySQL, I optimize for InnoDB buffer pool size and appropriate PRIMARY KEY design.

For multi-tenant applications, I carefully evaluate partitioning strategies. Horizontal partitioning by tenant improves query performance and simplifies data management for large applications.

Error handling strategies significantly impact application resilience. I implement automatic retries with exponential backoff for transient errors:

func queryWithRetry(ctx context.Context, db *sql.DB, query string, args ...interface{}) (*sql.Rows, error) {
    var rows *sql.Rows
    var err error
    
    backoff := 100 * time.Millisecond
    maxRetries := 3
    
    for i := 0; i < maxRetries; i++ {
        rows, err = db.QueryContext(ctx, query, args...)
        if err == nil {
            return rows, nil
        }
        
        // Only retry on specific errors
        if isPgTempError(err) {
            time.Sleep(backoff)
            backoff *= 2 // Exponential backoff
            continue
        }
        
        // Don't retry on other errors
        return nil, err
    }
    
    return nil, fmt.Errorf("max retries exceeded: %w", err)
}

func isPgTempError(err error) bool {
    pqErr, ok := err.(*pq.Error)
    if !ok {
        return false
    }
    
    // Check for connection loss, deadlock, or serialization failure
    switch pqErr.Code {
    case "40001", "40P01", "08006", "08001", "08004":
        return true
    default:
        return false
    }
}

Measuring database performance is essential. I use tools like Prometheus and Grafana to monitor query times, connection pool usage, and error rates in production environments.

Go’s efficient database operations combined with these optimization techniques have helped me build high-performance applications that scale effectively. The focus on connection management, proper query structure, and context usage creates a solid foundation for any database-intensive Go application.