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

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 un duo idéal

Go (Golang) est un langage compilé, typé statiquement, conçu pour des performances élevées et une simplicité de développement. L'un des principaux avantages de Go est sa riche bibliothèque standard et son écosystème de pilotes pour travailler avec les bases de données. Dans cet article, nous allons voir comment se connecter et effectuer des opérations avec deux des systèmes de gestion de bases de données (SGBD) les plus populaires : le relationnel PostgreSQL et l'orienté documents MongoDB.

Nous aborderons l'installation des pilotes, l'écriture d'opérations CRUD (Create, Read, Update, Delete) et les meilleures pratiques pour chaque type de base de données dans le contexte d'applications Go.

1. Travailler avec PostgreSQL en Go

PostgreSQL est un puissant SGBD objet-relationnel open source. Pour travailler avec lui en Go, il existe plusieurs pilotes, mais les plus populaires sont lib/pq et pgx. pgx est plus moderne et plus performant, c'est pourquoi nous l'utiliserons.

1.1. Installation du pilote

Installez le paquet pgx via go get :

go get github.com/jackc/pgx/v5

1.2. Connexion à la base de données

Créons un fichier main.go et établissons une connexion à PostgreSQL. Notez l'utilisation du contexte (context.Background()) — c'est un modèle standard en Go pour gérer la durée de vie des requêtes.

package main

import (    "context"    "fmt"    "log"

    "github.com/jackc/pgx/v5/pgxpool")

func main() {    // Chaîne de connexion : postgres://username:password@host:port/dbname    connString := "postgres://user:password@localhost:5432/mydb"        // Créer un pool de connexions (recommandé pour la production)    pool, err := pgxpool.New(context.Background(), connString)    if err != nil {        log.Fatal("Impossible de créer le pool de connexions :", err)    }    defer pool.Close()        // Vérifier la connexion    err = pool.Ping(context.Background())    if err != nil {        log.Fatal("Impossible de se connecter à la base de données :", err)    }    fmt.Println("Connecté avec succès à PostgreSQL !")}

1.3. Exécution de requêtes SQL (CRUD)

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

Création de table (CREATE)

// Exécution d'une requête DDL_, err = pool.Exec(context.Background(), `    CREATE TABLE IF NOT EXISTS users (        id SERIAL PRIMARY KEY,        name VARCHAR(100) NOT NULL,        email VARCHAR(100) UNIQUE NOT NULL,        age INT    )`)if err != nil {    log.Fatal("Erreur lors de la création de la table :", err)}

Insertion de données (INSERT)

// Insertion avec retour de l'IDvar userID interr = pool.QueryRow(context.Background(),    "INSERT INTO users (name, email, age) VALUES ($1, $2, $3) RETURNING id",    "Alexeï", "alex@example.com", 30).Scan(&userID)if err != nil {    log.Fatal("Erreur lors de l'insertion :", err)}fmt.Printf("Utilisateur ajouté avec l'ID : %d", userID)

Lecture de données (SELECT)

// Récupération d'un seul utilisateurtype User struct {    ID    int    Name  string    Email string    Age   int}

var user Usererr = pool.QueryRow(context.Background(),    "SELECT id, name, email, age FROM users WHERE id = $1", 1).    Scan(&user.ID, &user.Name, &user.Email, &user.Age)if err != nil {    log.Fatal("Utilisateur non trouvé :", err)}fmt.Printf("Trouvé : %+v", user)

Mise à jour et suppression (UPDATE/DELETE)

// Mise à jour_, err = pool.Exec(context.Background(),    "UPDATE users SET age = $1 WHERE id = $2", 31, 1)

// Suppression_, err = pool.Exec(context.Background(),    "DELETE FROM users WHERE id = $1", 1)