Travailler avec les bases de données en Go : PostgreSQL et MongoDB en pratique

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction : Pourquoi Go et les bases de données forment une paire idéale

Le langage de programmation Go (Golang) a gagné en popularité grâce à ses hautes performances, sa prise en charge intégrée de la concurrence et sa simplicité de déploiement. Cependant, la véritable puissance de Go se révèle lorsqu'il s'agit de travailler avec des bases de données. Qu'il s'agisse de PostgreSQL relationnelle ou de MongoDB orientée documents, Go fournit des outils élégants pour interagir efficacement avec les données.

Dans cet article, nous aborderons les aspects pratiques de la connexion, de l'exécution des opérations CRUD et de l'optimisation des requêtes pour PostgreSQL et MongoDB en Go. Vous apprendrez à utiliser les packages standards et les pilotes populaires pour écrire un code fiable et rapide.

1. Travailler avec PostgreSQL en Go

Pour travailler avec PostgreSQL en Go, on utilise le package standard database/sql associé au pilote pgx ou lib/pq. pgx est recommandé pour ses meilleures performances et sa prise en charge des fonctionnalités avancées de PostgreSQL.

1.1. Installation et connexion

Installez le pilote via go modules :

go get github.com/jackc/pgx/v5

Exemple de connexion à la base de données :

package main

import (    "context"    "fmt"    "github.com/jackc/pgx/v5/pgxpool"    "log")

func main() {    dsn := "postgres://user:password@localhost:5432/mydb?sslmode=disable"    pool, err := pgxpool.New(context.Background(), dsn)    if err != nil {        log.Fatal("Unable to connect to database:", err)    }    defer pool.Close()

    fmt.Println("Connected to PostgreSQL!")}

Conseil : Utilisez un pool de connexions (pgxpool) pour un environnement de production — cela réduit les frais généraux liés à l'établissement de nouvelles connexions.

1.2. Opérations CRUD

Examinons les opérations de base avec l'exemple de la table users :

// CREATEfunc createUser(pool *pgxpool.Pool, name string, email string) (int, error) {    var id int    err := pool.QueryRow(context.Background(),        "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id",        name, email).Scan(&id)    if err != nil {        return 0, err    }    return id, nil}

// READfunc getUser(pool *pgxpool.Pool, id int) (string, string, error) {    var name, email string    err := pool.QueryRow(context.Background(),        "SELECT name, email FROM users WHERE id = $1", id).Scan(&name, &email)    if err != nil {        return "", "", err    }    return name, email, nil}

// UPDATEfunc updateUserEmail(pool *pgxpool.Pool, id int, newEmail string) error {    _, err := pool.Exec(context.Background(),        "UPDATE users SET email = $1 WHERE id = $2", newEmail, id)    return err}

// DELETEfunc deleteUser(pool *pgxpool.Pool, id int) error {    _, err := pool.Exec(context.Background(),        "DELETE FROM users WHERE id = $1", id)    return err}

Notez l'utilisation de requêtes paramétrées avec $1, $2 — cela protège contre les injections SQL.

1.3. Transactions

PostgreSQL prend en charge les transactions, ce qui est essentiel pour l'intégrité des données :

func transferMoney(pool *pgxpool.Pool, fromID, toID int, amount float64) error {    tx, err := pool.Begin(context.Background())    if err != nil {        return err    }    defer tx.Rollback(context.Background()) // annulation en cas d'erreur

    _, err = tx.Exec(context.Background(),        "UPDATE accounts SET balance = balance - $1 WHERE id = $2", amount, fromID)    if err != nil {        return err    }

    _, err = tx.Exec(context.Background(),        "UPDATE accounts SET balance = balance + $1 WHERE id = $2", amount, toID)    if err != nil {        return err    }

    return tx.Commit(context.Background())}