Visão Geral das Famílias de Pacotes database/sql & net

Go divide redes e SQL em pacotes em camadas que compartilham padrões de context e io.

database/sql gerencia pools de conexão e transações.

A família net (net, net/http, net/url, net/netip) lida com endereços, HTTP e tipos IP modernos.

Resumo

Importe um driver SQL anonimamente, abra um *sql.DB e configure limites de pool para o SLA do seu banco de dados.

Servidores e clientes HTTP construídos sobre net/http reutilizam as mesmas práticas de tempo limite e contexto das consultas SQL.

Use net/netip para IPs e prefixos tipados em vez de analisar strings ad hoc.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

import (
    "context"
    "database/sql"
    _ "github.com/jackc/pgx/v5/stdlib"
    "net/http"
    "time"
)
 
db, _ := sql.Open("pgx", dsn)
db.SetMaxOpenConns(25)
db.SetConnMaxLifetime(30 * time.Minute)
 
http.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    row := db.QueryRowContext(ctx, `SELECT name FROM users WHERE id=$1`, id)
})

Quando usar isso:

• Construindo serviços REST ou RPC que leem/escrevem PostgreSQL, MySQL ou SQLite.
• Escrevendo clientes TCP, consultas DNS ou protocolos personalizados com net.Conn.
• Compartilhando prazos e cancelamento entre manipuladores HTTP e chamadas de banco de dados.
• Analisando URLs e IPs de clientes consistentemente na borda.

Exemplo de Trabalho

package main
 
import (
    "context"
    "database/sql"
    "encoding/json"
    "fmt"
    "net"
    "net/http"
    "time"
 
    _ "modernc.org/sqlite"
)
 
func main() {
    db, err := sql.Open("sqlite", "file:users.db?cache=shared&mode=rwc")
    if err != nil {
        panic(err)
    }
    defer db.Close()
 
    db.SetMaxOpenConns(1) // sqlite single-writer
    if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)`); err != nil {
        panic(err)
    }
    if _, err := db.Exec(`INSERT OR IGNORE INTO users (id, name) VALUES (1, 'Ada')`); err != nil {
        panic(err)
    }
 
    mux := http.NewServeMux()
    mux.HandleFunc("/users/", func(w http.ResponseWriter, r *http.Request) {
        handleUser(db, w, r)
    })
 
    srv := &http.Server{
        Addr:              ":8080",
        Handler:           mux,
        ReadHeaderTimeout: 5 * time.Second,
    }
    fmt.Println("listening", srv.Addr)
    panic(srv.ListenAndServe())
}
 
func handleUser(db *sql.DB, w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
    defer cancel()
 
    host, _, err := net.SplitHostPort(r.RemoteAddr)
    if err != nil {
        http.Error(w, "bad remote addr", http.StatusInternalServerError)
        return
    }
 
    var name string
    err = db.QueryRowContext(ctx, `SELECT name FROM users WHERE id=1`).Scan(&name)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
 
    w.Header().Set("Content-Type", "application/json")
    _ = json.NewEncoder(w).Encode(map[string]string{
        "name": name,
        "peer": host,
    })
}

O que isso demonstra:

• sql.Open com importação de driver e ajuste de pool.
• QueryRowContext respeitando prazos de requisição.
• net.SplitHostPort para metadados do peer.
• http.Server voltado para produção com ReadHeaderTimeout.

Mergulho Profundo

Como Funciona

• sql.Open cria um handle de pool; a primeira conexão real abre na primeira consulta.
• Drivers implementam as interfaces database/sql/driver; pgx, mysql e sqlite são distribuídos como módulos.
• net.Dialer e net.Listen gerenciam sockets TCP/UDP; http.Server adiciona análise HTTP por cima.
• O cancelamento de context fecha consultas em andamento e o trabalho do manipulador HTTP quando os prazos são atingidos.

Mapa da Família de Pacotes

Notas Go

// Sempre pingar após Open para capturar DSN incorreto cedo:
if err := db.PingContext(ctx); err != nil { return err }
 
// Declarações preparadas para consultas frequentes:
stmt, err := db.PrepareContext(ctx, `SELECT ...`)
 
// Prefira netip a net.ParseIP para comparações:
addr, _ := netip.ParseAddr("203.0.113.1")

Armadilhas

• Chamar sql.Open sem Ping - DSN mal configurado falha na primeira requisição. Correção: PingContext durante verificações de integridade de inicialização.
• SetMaxOpenConns ilimitado - Esgota conexões de banco de dados sob carga de pico. Correção: defina conexões abertas e ociosas máximas a partir de fórmulas de capacidade do DB.
• Usar http.DefaultClient em servidores - Sem tempos limite em chamadas de saída. Correção: http.Client dedicado por upstream com ajuste de Transport.
• Ignorar rows.Err() após iteração - Resultados parciais silenciosos. Correção: verifique err após o loop for rows.Next().
• Armazenar *sql.Tx em structs - Vazamentos de transações entre requisições. Correção: mantenha transações no escopo do manipulador ou método de serviço.
• Analisar IPs com divisões de string - IPv6 e IDs de zona quebram código ingênuo. Correção: net/netip.ParseAddr ou net.SplitHostPort.

Alternativas

FAQs

Relacionados

• A Biblioteca Padrão Go: Baterias Incluídas - Modelo de camadas da stdlib
• Integração de tempo, fusos horários e contexto - Prazos em toda a pilha
• net/http: A Pilha HTTP de Baterias Incluídas do Go - Mergulho profundo em HTTP
• crypto/*, compress & math/rand/v2 - TLS para listeners
• Melhores Práticas da Biblioteca Padrão - Padrões de pool e cliente

Versões da Pilha: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizers - verifique o patch na compilação), chi (última - verifique na compilação), gin (última - verifique na compilação), echo (última - verifique na compilação), google.golang.org/grpc (última - verifique na compilação), sigs.k8s.io/controller-runtime (última - verifique na compilação), kubebuilder (última - verifique na compilação), tinygo (última - verifique os alvos de placa na compilação), wazero (última - verifique na compilação) e golangci-lint (última - verifique o conjunto de linters na compilação).