sqlc pour Go : génération de code type-safe à partir de SQL

sqlc est un compilateur qui génère du code Go à partir de vos requêtes SQL. Au lieu d'écrire manuellement des fonctions pour interagir avec votre base de données, vous rédigez du SQL pur, et sqlc crée pour vous des fonctions typées, sûres et performantes. Cette approche est fondamentalement différente des ORM : vous conservez un contrôle total sur le SQL, tout en éliminant le travail fastidieux d'écriture du code boilerplate.

Pourquoi utiliser sqlc ? Premièrement, il garantit la sécurité des types (type-safety) dès la compilation. Si vous modifiez le schéma d'une table ou une requête, sqlc régénère le code, et le compilateur Go vous indique immédiatement tous les endroits à mettre à jour. Deuxièmement, les performances : le code généré n'utilise pas de réflexion et évite les allocations inutiles, le rendant aussi rapide que l'écriture manuelle de requêtes avec database/sql. Troisièmement, il simplifie la revue de code : les requêtes SQL sont clairement visibles dans les fichiers .sql, et non cachées dans des méthodes d'ORM.

sqlc est idéal pour les projets où la performance et le contrôle des requêtes sont cruciaux : API à forte charge, systèmes financiers, plateformes d'analyse. Il s'intègre parfaitement avec les outils de migration (comme golang-migrate) et ne vous enferme pas dans un SGBD spécifique — il prend en charge PostgreSQL, MySQL et SQLite.

Installation

sqlc n'est pas une bibliothèque, mais un utilitaire en ligne de commande. Vous pouvez l'installer de plusieurs façons :

# Via go install (recommandé)
go install github.com/sqlc-dev/sqlc/cmd/sqlc@latest

# Via Homebrew (macOS/Linux)
brew install sqlc

# Télécharger le binaire depuis GitHub
# https://github.com/sqlc-dev/sqlc/releases

Après l'installation, vérifiez la version :

sqlc version

Premiers pas

Créons un projet minimal pour illustrer le fonctionnement de sqlc.

1. Structure du projet

mkdir sqlc-demo && cd sqlc-demo
go mod init sqlc-demo

2. Configuration de sqlc

Créez un fichier sqlc.yaml à la racine du projet :

version: "2"
sql:
  - engine: "postgresql"
    queries: "queries.sql"
    schema: "schema.sql"
    gen:
      go:
        package: "db"
        out: "db"
        sql_package: "pgx/v5"

3. Schéma de la base de données

Fichier schema.sql :

CREATE TABLE authors (
    id   BIGSERIAL PRIMARY KEY,
    name text NOT NULL,
    bio  text
);

4. Requêtes SQL

Fichier queries.sql :

-- name: GetAuthor :one
SELECT * FROM authors
WHERE id = $1;

-- name: ListAuthors :many
SELECT * FROM authors
ORDER BY name;

-- name: CreateAuthor :one
INSERT INTO authors (name, bio)
VALUES ($1, $2)
RETURNING *;

-- name: DeleteAuthor :exec
DELETE FROM authors
WHERE id = $1;

5. Génération du code

sqlc generate

Après exécution, les fichiers générés apparaissent dans le dossier db/. Vous pouvez maintenant les utiliser dans votre code :

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/jackc/pgx/v5/pgxpool"
    "sqlc-demo/db"
)

func main() {
    ctx := context.Background()
    pool, err := pgxpool.New(ctx, "postgres://user:pass@localhost:5432/testdb")
    if err != nil {
        log.Fatal(err)
    }
    defer pool.Close()

    queries := db.New(pool)

    // Création d'un auteur
    author, err := queries.CreateAuthor(ctx, db.CreateAuthorParams{
        Name: "Brian Kernighan",
        Bio:  "Co-auteur de The C Programming Language",
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Auteur créé : %+v\n", author)

    // Récupération d'un auteur par son ID
    fetched, err := queries.GetAuthor(ctx, author.ID)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Auteur récupéré : %+v\n", fetched)
}