Gestion de la Persistance des Données : Bases de Données SQL et NoSQL avec Go

Contexte du cours : Maîtrisez Go pour le Backend : Construisez des APIs Performantes et Scalables

Introduction à la Persistance des Données

Dans le monde du développement backend, l'un des piliers fondamentaux est la capacité à stocker et récupérer des données de manière fiable et efficace. Une API ne serait d'aucune utilité si elle ne pouvait pas conserver l'état de ses utilisateurs, les produits d'une boutique en ligne, ou les articles d'un blog. C'est ici qu'intervient la persistance des données.

La persistance des données fait référence à la capacité d'un programme à enregistrer et à récupérer des informations de telle sorte qu'elles survivent à l'exécution du programme. En d'autres termes, si votre serveur redémarre ou que votre application plante, les données ne sont pas perdues. Pour les applications backend, cela est généralement réalisé en stockant les données dans des systèmes de gestion de bases de données (SGBD).

Ce chapitre explorera les deux paradigmes principaux de bases de données utilisés aujourd'hui : les bases de données relationnelles (SQL) et non-relationnelles (NoSQL), et comment Go interagit avec elles pour bâtir des APIs robustes et scalables.

Comprendre la Persistance des Données

Qu'est-ce que la Persistance ?

La persistance est la caractéristique des données qui les maintient dans le temps, même après l'arrêt du processus qui les a créées ou utilisées. Sans persistance, toute information serait éphémère et perdue à chaque redémarrage de l'application ou du serveur.

Pourquoi la Persistance est-elle Cruciale pour les APIs Backend ?

Gestion de l'État : Les APIs doivent maintenir un état (par exemple, des sessions utilisateur, des paniers d'achat, des configurations). Sans persistance, chaque requête serait traitée comme une nouvelle interaction sans connaissance des précédentes.
Fiabilité et Cohérence : Les données doivent être disponibles et cohérentes. Une base de données assure que les données sont enregistrées correctement et peuvent être récupérées fidèlement, même en cas de pannes.
Scalabilité : Les bases de données modernes sont conçues pour gérer d'énormes volumes de données et un grand nombre de requêtes concurrentes, permettant aux APIs de servir un public croissant.
Intégration : Les données sont souvent partagées entre différentes applications ou services. Une base de données centralisée ou distribuée facilite cette intégration.

Les Bases de Données Relationnelles (SQL)

Qu'est-ce que c'est ?

Les bases de données relationnelles, basées sur le modèle relationnel introduit par Edgar F. Codd, stockent les données dans des tables (ou relations). Chaque table est composée de lignes (enregistrements) et de colonnes (attributs). Les relations entre les tables sont définies par des clés primaires et étrangères. L'interrogation et la manipulation des données se font via le langage SQL (Structured Query Language).

Les bases de données SQL adhèrent généralement aux propriétés ACID (Atomicity, Consistency, Isolation, Durability) pour garantir la fiabilité des transactions :

Atomicité : Une transaction est tout ou rien. Soit toutes les opérations réussissent, soit aucune ne réussit.
Cohérence : Une transaction amène la base de données d'un état valide à un autre état valide.
Isolation : Des transactions concurrentes s'exécutent comme si elles étaient sérielles, sans interférer les unes avec les autres.
Durabilité : Une fois qu'une transaction est validée (commitée), ses modifications sont permanentes et survivent aux pannes.

Exemples populaires : PostgreSQL, MySQL, Oracle, SQL Server, SQLite.

Avantages

Intégrité des Données Forte : Grâce aux schémas stricts et aux contraintes (clés primaires/étrangères, types de données), l'intégrité des données est intrinsèquement maintenue.
Transactions ACID : Essentielles pour les applications où la fiabilité des transactions est primordiale (ex: systèmes bancaires, e-commerce).
Requêtes Complexes : Le SQL permet des requêtes complexes, des jointures (JOINs) entre plusieurs tables, et des agrégations avancées.
Maturité et Écosystème : Existence depuis des décennies, avec une grande communauté, de nombreux outils et une expertise répandue.

Inconvénients

Scalabilité Verticale : Traditionnellement, les bases de données SQL sont conçues pour être scalées verticalement (augmenter la puissance du serveur : CPU, RAM, disque). La scalabilité horizontale (répartir la charge sur plusieurs serveurs) est plus complexe à mettre en œuvre.
Rigidité du Schéma : Toute modification du schéma (ajout/suppression de colonnes) peut être coûteuse et nécessite souvent des migrations, ce qui ralentit le développement agile.
Gestion des Données Non-Structurées : Moins adaptées pour les données non-structurées ou semi-structurées.

Quand l'utiliser ?

Applications nécessitant une forte cohérence et des transactions complexes (ex: finance, ERP, CRM).
Données avec une structure claire et bien définie qui ne change pas fréquemment.
Applications où les relations entre les données sont centrales et complexes.

Go et SQL : Le Package `database/sql`

Go offre une interface générique pour interagir avec les bases de données relationnelles via le package standard database/sql. Ce package fournit une API abstraite, et des pilotes (drivers) spécifiques à chaque base de données implémentent cette interface.

Pour utiliser une base de données SQL avec Go, vous aurez généralement besoin de :

Importer le package database/sql.
Importer le pilote spécifique à votre base de données (ex: github.com/lib/pq pour PostgreSQL, github.com/go-sql-driver/mysql pour MySQL). L'importation du pilote se fait généralement avec un underscore _ pour n'exécuter que son initialisation.
Ouvrir une connexion à la base de données en utilisant sql.Open().
Vérifier la connexion avec db.Ping().
Exécuter des requêtes (insertion, mise à jour, suppression) avec db.Exec().
Exécuter des requêtes de sélection avec db.Query() pour plusieurs lignes ou db.QueryRow() pour une seule ligne.
Fermer la connexion avec db.Close() (généralement en defer).

Exemple de Code : Interaction avec PostgreSQL

Assurez-vous d'avoir installé le pilote PostgreSQL : go get github.com/lib/pq. Et d'avoir une instance PostgreSQL qui tourne (ex: postgres://user:password@localhost:5432/dbname?sslmode=disable).

package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github.com/lib/pq" // Importer le driver PostgreSQL
)

// User représente un utilisateur dans notre base de données
type User struct {
	ID    int
	Name  string
	Email string
}

func main() {
	// 1. Connexion à la base de données
	// L'URL de connexion est spécifique à votre base de données et environnement
	connStr := "postgres://user:password@localhost:5432/mydatabase?sslmode=disable"
	db, err := sql.Open("postgres", connStr)
	if err != nil {
		log.Fatal("Erreur lors de l'ouverture de la base de données :", err)
	}
	defer db.Close() // S'assurer que la connexion est fermée à la fin

	// 2. Vérifier la connexion
	err = db.Ping()
	if err != nil {
		log.Fatal("Impossible de se connecter à la base de données :", err)
	}
	fmt.Println("Connecté à la base de données PostgreSQL !")

	// 3. Création de table (si elle n'existe pas)
	createTableSQL := `
	CREATE TABLE IF NOT EXISTS users (
		id SERIAL PRIMARY KEY,
		name VARCHAR(100) NOT NULL,
		email VARCHAR(100) UNIQUE NOT NULL
	);`
	_, err = db.Exec(createTableSQL)
	if err != nil {
		log.Fatal("Erreur lors de la création de la table :", err)
	}
	fmt.Println("Table 'users' vérifiée/créée.")

	// 4. Insertion d'un nouvel utilisateur
	newUser := User{Name: "Alice Dubois", Email: "alice.dubois@example.com"}
	insertSQL := `INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id;`
	var newID int
	err = db.QueryRow(insertSQL, newUser.Name, newUser.Email).Scan(&newID)
	if err != nil {
		// Gérer le cas où l'email existe déjà (contrainte UNIQUE)
		if err.Error() == `pq: duplicate key value violates unique constraint "users_email_key"` {
			fmt.Println("Erreur: L'email 'alice.dubois@example.com' existe déjà.")
		} else {
			log.Fatal("Erreur lors de l'insertion de l'utilisateur :", err)
		}
	} else {
		fmt.Printf("Utilisateur inséré avec l'ID : %d\n", newID)
	}

	// 5. Sélection d'un utilisateur par son ID
	var fetchedUser User
	querySQL := `SELECT id, name, email FROM users WHERE id = $1;`
	row := db.QueryRow(querySQL, newID) // Utiliser newID si l'insertion a réussi

	err = row.Scan(&fetchedUser.ID, &fetchedUser.Name, &fetchedUser.Email)
	if err != nil {
		if err == sql.ErrNoRows {
			fmt.Println("Aucun utilisateur trouvé avec l'ID spécifié.")
		} else {
			log.Fatal("Erreur lors de la lecture de l'utilisateur :", err)
		}
	} else {
		fmt.Printf("Utilisateur récupéré : ID=%d, Nom=%s, Email=%s\n", fetchedUser.ID, fetchedUser.Name, fetchedUser.Email)
	}

	// 6. Mise à jour d'un utilisateur
	updateSQL := `UPDATE users SET name = $1 WHERE id = $2;`
	_, err = db.Exec(updateSQL, "Alice Updated", newID)
	if err != nil {
		log.Fatal("Erreur lors de la mise à jour de l'utilisateur :", err)
	}
	fmt.Printf("Utilisateur avec l'ID %d mis à jour.\n", newID)

	// 7. Suppression d'un utilisateur
	deleteSQL := `DELETE FROM users WHERE id = $1;`
	_, err = db.Exec(deleteSQL, newID)
	if err != nil {
		log.Fatal("Erreur lors de la suppression de l'utilisateur :", err)
	}
	fmt.Printf("Utilisateur avec l'ID %d supprimé.\n", newID)
}

Explication du code SQL en Go :

_ "github.com/lib/pq" : L'underscore indique que nous importons le package uniquement pour ses effets secondaires (son initialisation qui enregistre le driver).
sql.Open("postgres", connStr) : Établit une connexion logique à la base de données. Il ne vérifie pas encore si la connexion est valide.
db.Ping() : Vérifie la validité de la connexion. C'est une bonne pratique pour s'assurer que la base de données est accessible avant d'effectuer d'autres opérations.
db.Exec(sqlStatement, args...) : Utilisé pour les commandes qui ne retournent pas de jeu de résultats (comme INSERT, UPDATE, DELETE, CREATE TABLE).
db.QueryRow(sqlStatement, args...).Scan(&dest...) : Pour récupérer une unique ligne de résultat. Scan permet de mapper les colonnes du résultat directement vers des variables Go.
db.Query(sqlStatement, args...) : Pour récupérer plusieurs lignes de résultat. Il retourne un *sql.Rows que vous devez itérer avec rows.Next() et scanner avec rows.Scan(). N'oubliez pas defer rows.Close().
Gestion des erreurs : Le package database/sql renvoie des erreurs pour indiquer des problèmes de connexion, de requête ou de données manquantes (sql.ErrNoRows). Il est crucial de vérifier les erreurs après chaque opération.

Les Bases de Données Non-Relationnelles (NoSQL)

Qu'est-ce que c'est ?

Le terme NoSQL (qui signifie "Not only SQL", et non "No SQL") désigne une catégorie large de systèmes de gestion de bases de données qui s'écartent du modèle relationnel traditionnel. Elles sont conçues pour des cas d'utilisation spécifiques nécessitant une scalabilité horizontale, une flexibilité du schéma, et une performance élevée pour des types de données et des charges de travail spécifiques.

Les bases de données NoSQL privilégient généralement le modèle de cohérence BASE (Basically Available, Soft state, Eventually consistent) plutôt que ACID :

Basically Available : Le système reste disponible même en cas de panne de nœuds.
Soft state : L'état du système peut changer avec le temps, même sans input.
Eventually consistent : Les données finiront par être cohérentes à travers tous les nœuds, mais il peut y avoir un délai.

Typologie des BDD NoSQL

Les bases de données NoSQL peuvent être classées en plusieurs catégories principales, chacune adaptée à des besoins différents :

Bases de Données Clé-Valeur :
- Concept : Stockent les données sous forme de paires clé-valeur, où chaque clé est unique et est utilisée pour récupérer la valeur associée. La valeur peut être n'importe quoi (chaîne, objet JSON sérialisé, etc.).
- Cas d'usage : Caching, gestion de sessions, tableaux de bord en temps réel.
- Exemples : Redis, Memcached, Amazon DynamoDB.
Bases de Données Orientées Document :
- Concept : Stockent les données sous forme de documents (souvent en JSON, BSON ou XML), qui sont des structures auto-descriptives et hiérarchiques. Pas de schéma fixe, ce qui offre une grande flexibilité.
- Cas d'usage : Applications web, catalogues de produits, gestion de contenu, profils utilisateurs.
- Exemples : MongoDB, Couchbase, RavenDB.
Bases de Données Colonnaires (Wide-Column Stores) :
- Concept : Stockent les données dans des colonnes plutôt que des lignes. Optimisées pour les agrégations sur de grandes quantités de données et les requêtes basées sur des plages de valeurs.
- Cas d'usage : Analytique de Big Data, séries temporelles, gestion d'événements.
- Exemples : Apache Cassandra, Apache HBase, Google Bigtable.
Bases de Données de Graphes :
- Concept : Représentent les données sous forme de nœuds (entités) et d'arêtes (relations) entre ces nœuds. Optimisées pour explorer les relations complexes entre les données.
- Cas d'usage : Réseaux sociaux, systèmes de recommandation, détection de fraude, gestion des connaissances.
- Exemples : Neo4j, ArangoDB, Amazon Neptune.

Avantages

Scalabilité Horizontale : Conçues pour être distribuées sur de nombreux serveurs, permettant une gestion facile de volumes massifs de données et de requêtes.
Flexibilité du Schéma : Permettent des évolutions rapides et des changements de structure de données sans migrations coûteuses. Idéal pour le développement agile.
Performance : Peuvent offrir de très hautes performances pour des cas d'usage spécifiques, en optimisant le stockage et la récupération des données pour leur modèle.
Gestion de Données Non-Structurées : Excellentes pour les données dont la structure est inconnue ou très variable.

Inconvénients

Consistance Moins Forte : Privilégient souvent la disponibilité et la tolérance aux partitions au détriment de la cohérence forte (modèle BASE vs ACID). Peut être un problème pour certaines applications.
Pas de Jointures Standards : N'ont pas le concept de jointures comme en SQL, ce qui peut rendre complexes certaines requêtes de récupération de données liées.
Maturité Variable : L'écosystème et la maturité des outils peuvent varier considérablement d'une base de données NoSQL à l'autre.
Apprentissage : Nécessitent d'apprendre de nouveaux paradigmes de modélisation et d'interrogation des données.

Quand l'utiliser ?

Applications nécessitant une scalabilité horizontale massive (Big Data, IoT).
Données avec une structure variable, inconnue ou changeant fréquemment.
Applications où la performance et la disponibilité sont plus critiques que la cohérence forte à chaque instant (ex: réseaux sociaux, systèmes de recommandation).
Lorsque les données sont des documents, des clés-valeurs, ou des graphes par nature.

Go et NoSQL : Utilisation des Pilotes Spécifiques

Contrairement à SQL avec son interface générique database/sql, les bases de données NoSQL n'ont pas de standard unifié comme SQL. Chaque base de données NoSQL aura généralement son propre pilote (ou SDK) officiel ou communautaire pour Go, offrant une API spécifique à son modèle de données.

Exemple de Code : Interaction avec MongoDB

Assurez-vous d'avoir installé le pilote MongoDB : go get go.mongodb.org/mongo-driver/mongo. Et d'avoir une instance MongoDB qui tourne (ex: mongodb://localhost:27017).

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

// Product représente un produit dans notre base de données MongoDB
type Product struct {
	ID        primitive.ObjectID `bson:"_id,omitempty"` // _id est le champ par défaut de MongoDB
	Name      string             `bson:"name"`
	Price     float64            `bson:"price"`
	Category  string             `bson:"category,omitempty"`
	CreatedAt time.Time          `bson:"createdAt"`
}

func main() {
	// 1. Connexion à MongoDB
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	client, err := mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}

	// 2. Vérifier la connexion
	err = client.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Connecté à MongoDB !")

	// Obtenir une référence à la collection "products" dans la base de données "ecomdb"
	collection := client.Database("ecomdb").Collection("products")

	// 3. Insertion d'un nouveau produit
	newProduct := Product{
		Name:      "Smartphone X",
		Price:     799.99,
		Category:  "Electronics",
		CreatedAt: time.Now(),
	}

	insertResult, err := collection.InsertOne(context.TODO(), newProduct)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Produit inséré avec l'ID : %s\n", insertResult.InsertedID.(primitive.ObjectID).Hex())

	// Pour récupérer l'ID de l'objet inséré et l'utiliser ensuite
	insertedID := insertResult.InsertedID.(primitive.ObjectID)

	// 4. Recherche d'un produit par ID
	var foundProduct Product
	filterByID := bson.M{"_id": insertedID}
	err = collection.FindOne(context.TODO(), filterByID).Decode(&foundProduct)
	if err != nil {
		if err == mongo.ErrNoDocuments {
			fmt.Println("Aucun document trouvé pour l'ID spécifié.")
		} else {
			log.Fatal(err)
		}
	} else {
		fmt.Printf("Produit trouvé : %+v\n", foundProduct)
	}

	// 5. Mise à jour d'un produit
	updateFilter := bson.M{"_id": insertedID}
	update := bson.M{"$set": bson.M{"price": 749.99}} // Mettre à jour le prix

	updateResult, err := collection.UpdateOne(context.TODO(), updateFilter, update)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Nombre de documents mis à jour : %d\n", updateResult.ModifiedCount)

	// 6. Recherche de produits par catégorie
	cursor, err := collection.Find(context.TODO(), bson.M{"category": "Electronics"})
	if err != nil {
		log.Fatal(err)
	}
	defer cursor.Close(context.TODO()) // Toujours fermer le curseur

	var products []Product
	if err = cursor.All(context.TODO(), &products); err != nil {
		log.Fatal(err)
	}
	fmt.Println("\nProduits de la catégorie 'Electronics' :")
	for _, p := range products {
		fmt.Printf("  - %s (%.2f EUR)\n", p.Name, p.Price)
	}

	// 7. Suppression d'un produit
	deleteFilter := bson.M{"_id": insertedID}
	deleteResult, err := collection.DeleteOne(context.TODO(), deleteFilter)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Nombre de documents supprimés : %d\n", deleteResult.DeletedCount)

	// Déconnexion à la fin
	err = client.Disconnect(context.TODO())
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Déconnecté de MongoDB.")
}

Explication du code MongoDB en Go :

go.mongodb.org/mongo-driver/mongo : Le pilote officiel de MongoDB pour Go.
context.TODO() : MongoDB Go Driver utilise des context.Context pour gérer les délais d'attente et l'annulation des opérations, ce qui est une pratique courante en Go pour les opérations réseau ou de longue durée.
options.Client().ApplyURI(...) : Permet de configurer les options de connexion au client.
client.Database("ecomdb").Collection("products") : Accède à une base de données spécifique (ecomdb) et à une collection spécifique (products). En MongoDB, si la base de données ou la collection n'existent pas, elles sont créées lors de la première insertion de données.
bson : Le pilote MongoDB utilise BSON (Binary JSON) pour la sérialisation des données. bson.M est un alias pour map[string]interface{} et est utilisé pour construire des requêtes et des filtres. primitive.ObjectID est le type MongoDB pour les identifiants uniques.
collection.InsertOne(ctx, document) : Insère un seul document. document est généralement une struct ou une map[string]interface{}.
collection.FindOne(ctx, filter).Decode(&target) : Récupère un seul document qui correspond au filter. Le résultat est décodé dans la target struct.
collection.UpdateOne(ctx, filter, update) : Met à jour un seul document. L'update est généralement un bson.M avec des opérateurs comme $set.
collection.Find(ctx, filter) : Récupère plusieurs documents. Il retourne un *mongo.Cursor qui doit être itéré (cursor.Next()) ou lu en bloc (cursor.All()) et fermé (cursor.Close()).
Les tags struct comme `bson:"_id,omitempty"` sont cruciaux pour mapper les champs de la struct Go aux noms des champs BSON/MongoDB, et omitempty indique que le champ doit être omis si sa valeur est nulle (utile pour ID lors de l'insertion).

Choisir la Bonne Base de Données : SQL ou NoSQL ?

Le choix entre une base de données SQL et NoSQL n'est pas anodin et dépend fortement des exigences spécifiques de votre application. Il n'y a pas de "meilleure" option universelle. Voici quelques critères pour vous aider à décider :

Nature des Données :
- SQL : Si vos données sont hautement structurées, avec des relations complexes et des besoins d'intégrité forte.
- NoSQL : Si vos données sont non-structurées, semi-structurées, ou si leur structure évolue fréquemment.
Volume et Vitesse des Données :
- SQL : Bon pour des volumes modérés à grands, mais la scalabilité horizontale peut être un défi.
- NoSQL : Idéal pour des volumes massifs de données et des débits élevés, grâce à leur conception distribuée.
Complexité des Requêtes :
- SQL : Excellent pour les requêtes complexes impliquant des jointures entre plusieurs entités.
- NoSQL : Moins adapté pour les jointures. Les requêtes sont souvent plus simples, axées sur la récupération de documents entiers ou de sous-documents.
Consistance et Intégrité :
- SQL : Cohérence forte (ACID) est garantie, primordiale pour les applications transactionnelles.
- NoSQL : Souvent cohérence éventuelle (BASE), privilégiant la disponibilité et la performance. Acceptez-vous une courte période d'incohérence pour une meilleure scalabilité ?
Scalabilité :
- SQL : Principalement verticale (montée en puissance du serveur), la scalabilité horizontale est plus complexe (réplication, sharding).
- NoSQL : Conçues pour la scalabilité horizontale (distribution des données sur de nombreux nœuds) dès le départ.
Coût et Expertise :
- Évaluez la complexité de l'administration, le coût des licences (pour certaines solutions propriétaires) et l'expertise de votre équipe avec la technologie choisie.

Il est également courant dans les architectures modernes d'utiliser une approche polyglotte (polyglot persistence), où différentes bases de données sont utilisées pour différentes parties de l'application, chacune étant choisie pour son adéquation optimale à une tâche spécifique. Par exemple, une base de données SQL pour les données transactionnelles critiques, et une base de données de documents NoSQL pour les profils utilisateurs ou les catalogues de produits.

Conclusion

La persistance des données est un aspect fondamental du développement backend. Le choix entre une base de données SQL et NoSQL n'est pas une question de supériorité de l'un sur l'autre, mais plutôt de choisir l'outil adapté au problème.

Les bases de données SQL excellent là où la structure est stable, l'intégrité des données est primordiale, et les relations complexes nécessitent des jointures. Go les intègre parfaitement via le package database/sql et ses pilotes dédiés.
Les bases de données NoSQL brillent par leur flexibilité, leur scalabilité horizontale, et leur capacité à gérer d'énormes volumes de données ou des données non-structurées. Go interagit avec elles via des pilotes spécifiques à chaque SGBD.

Comprendre les forces et faiblesses de chaque paradigme vous permettra de prendre des décisions éclairées pour la conception de vos APIs en Go, garantissant qu'elles soient non seulement performantes, mais aussi robustes, maintenables et scalables face aux exigences croissantes de vos applications.

Gestion de la Persistance des Données : Bases de Données SQL et NoSQL avec Go

Introduction à la Persistance des Données

Comprendre la Persistance des Données

Qu'est-ce que la Persistance ?

Pourquoi la Persistance est-elle Cruciale pour les APIs Backend ?

Les Bases de Données Relationnelles (SQL)

Qu'est-ce que c'est ?

Avantages

Inconvénients

Quand l'utiliser ?

Go et SQL : Le Package database/sql

Exemple de Code : Interaction avec PostgreSQL

Les Bases de Données Non-Relationnelles (NoSQL)

Qu'est-ce que c'est ?

Typologie des BDD NoSQL

Avantages

Inconvénients

Quand l'utiliser ?

Go et NoSQL : Utilisation des Pilotes Spécifiques

Exemple de Code : Interaction avec MongoDB

Choisir la Bonne Base de Données : SQL ou NoSQL ?

Conclusion

Go et SQL : Le Package `database/sql`