Go (Golang) est devenu un choix populaire pour créer des services backend robustes et hautes performances. L'un des principaux atouts de Go est son excellente prise en charge des opérations de bases de données, que vous travailliez avec des bases de données SQL traditionnelles ou des solutions NoSQL modernes. Dans ce guide, nous explorerons comment interagir avec les bases de données dans Go, en couvrant à la fois les approches SQL et NoSQL.
La bibliothèque standard de Go fournit le package database/sql, qui propose une interface générique autour des bases de données SQL (ou de type SQL). Ce package est conçu pour être utilisé avec des pilotes spécifiques à la base de données.
Commençons par un exemple simple utilisant SQLite :
package main
import (
"database/sql"
"fmt"
"log"
)
func main() {
// Open the database
db, err := sql.Open("sqlite3", "./test.db")
if err != nil {
log.Fatal(err)
}
defer db.Close()
// Create table
_, err = db.Exec(`CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT,
age INTEGER
)`)
if err != nil {
log.Fatal(err)
}
// Insert a user
result, err := db.Exec("INSERT INTO users (name, age) VALUES (?, ?)", "Alice", 30)
if err != nil {
log.Fatal(err)
}
// Get the ID of the inserted user
id, err := result.LastInsertId()
if err != nil {
log.Fatal(err)
}
fmt.Printf("Inserted user with ID: %d\n", id)
// Query for the user
var name string
var age int
err = db.QueryRow("SELECT name, age FROM users WHERE id = ?", id).Scan(&name, &age)
if err != nil {
log.Fatal(err)
}
fmt.Printf("User: %s, Age: %d\n", name, age)
}
Cet exemple montre les bases de l'utilisation des bases de données SQL dans Go :
Le package database/sql fournit une interface de bas niveau à la base de données, vous donnant un contrôle précis sur vos requêtes et opérations.
Bien que le package base de données/sql soit puissant, de nombreux développeurs préfèrent utiliser un outil de mappage objet-relationnel (ORM) pour des opérations de base de données plus pratiques. GORM est l'un des ORM les plus populaires pour Go.
Voici un exemple d'utilisation de GORM avec SQLite :
package main
import (
"fmt"
"log"
"gorm.io/driver/sqlite"
"gorm.io/gorm"
)
type User struct {
ID uint
Name string
Age int
}
func main() {
// Open the database
db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
if err != nil {
log.Fatal(err)
}
// Auto Migrate the schema
db.AutoMigrate(&User{})
// Create a user
user := User{Name: "Bob", Age: 25}
result := db.Create(&user)
if result.Error != nil {
log.Fatal(result.Error)
}
fmt.Printf("Inserted user with ID: %d\n", user.ID)
// Query for the user
var fetchedUser User
db.First(&fetchedUser, user.ID)
fmt.Printf("User: %s, Age: %d\n", fetchedUser.Name, fetchedUser.Age)
// Update the user
db.Model(&fetchedUser).Update("Age", 26)
// Delete the user
db.Delete(&fetchedUser)
}
GORM fournit une abstraction de niveau supérieur sur les opérations de base de données, vous permettant de travailler directement avec les structures Go au lieu d'écrire des requêtes SQL brutes. Il offre également des fonctionnalités telles que les migrations automatiques, les hooks et les associations.
Pour les bases de données NoSQL, voyons comment interagir avec MongoDB à l'aide du pilote Go officiel :
package main
import (
"context"
"fmt"
"log"
"time"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
type User struct {
Name string `bson:"name"`
Age int `bson:"age"`
}
func main() {
// Set client options
clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
// Connect to MongoDB
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
client, err := mongo.Connect(ctx, clientOptions)
if err != nil {
log.Fatal(err)
}
// Check the connection
err = client.Ping(context.TODO(), nil)
if err != nil {
log.Fatal(err)
}
fmt.Println("Connected to MongoDB!")
// Get a handle for your collection
collection := client.Database("test").Collection("users")
// Insert a user
user := User{Name: "Charlie", Age: 35}
insertResult, err := collection.InsertOne(context.TODO(), user)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Inserted user with ID: %v\n", insertResult.InsertedID)
// Find a user
var result User
filter := bson.M{"name": "Charlie"}
err = collection.FindOne(context.TODO(), filter).Decode(&result)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Found user: %+v\n", result)
// Update a user
update := bson.M{
"$set": bson.M{
"age": 36,
},
}
updateResult, err := collection.UpdateOne(context.TODO(), filter, update)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Updated %v user(s)\n", updateResult.ModifiedCount)
// Delete a user
deleteResult, err := collection.DeleteOne(context.TODO(), filter)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Deleted %v user(s)\n", deleteResult.DeletedCount)
// Disconnect
err = client.Disconnect(context.TODO())
if err != nil {
log.Fatal(err)
}
fmt.Println("Connection to MongoDB closed.")
}
Cet exemple illustre les opérations de base CRUD (Créer, Lire, Mettre à jour, Supprimer) avec MongoDB à l'aide du pilote Go officiel.
Lorsque vous travaillez avec des bases de données dans Go, gardez ces bonnes pratiques à l'esprit :
Utiliser le pooling de connexions : la base de données/sql et la plupart des pilotes NoSQL implémentent le pooling de connexions. Assurez-vous de réutiliser les connexions à la base de données au lieu d'en ouvrir de nouvelles pour chaque opération.
Gérez les erreurs correctement : vérifiez toujours les erreurs renvoyées par les opérations de base de données et gérez-les de manière appropriée.
Utiliser des instructions préparées : pour les bases de données SQL, utilisez des instructions préparées pour améliorer les performances et empêcher les attaques par injection SQL.
Fermer les ressources : fermez toujours les ensembles de résultats, les instructions et les connexions à la base de données lorsque vous en avez terminé avec eux. Le mot-clé defer est utile pour cela.
Utiliser les transactions si nécessaire : pour les opérations qui nécessitent plusieurs étapes, utilisez des transactions pour garantir la cohérence des données.
Soyez conscient des problèmes de requête N 1 : lorsque vous utilisez des ORM, soyez conscient du problème de requête N 1 et utilisez le chargement hâtif le cas échéant.
Utiliser le contexte pour les délais d'attente : utilisez le contexte pour définir des délais d'attente pour les opérations de base de données, en particulier pour les requêtes de longue durée.
Les pièges courants à éviter :
Go offre une prise en charge robuste des interactions avec les bases de données SQL et NoSQL. Que vous préfériez le contrôle de bas niveau de base de données/sql, la commodité d'un ORM comme GORM ou travailler avec des bases de données NoSQL comme MongoDB, Go l'a pour vous.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
valeur absolue python
Comment changer la couleur de la police dans Dreamweaver
Les membres Weibo peuvent-ils consulter les enregistrements des visiteurs ?
Applications logicielles de spéculation monétaire formelles et faciles à utiliser recommandées en 2024
solution de chemin fakepath
Comment faire correspondre les nombres dans les expressions régulières
Comment obtenir la longueur d'un tableau en js
Les systèmes logiciels informatiques comprennent
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
