A marzo 2019 è stato rilasciato il driver GO ufficiale, pronto per la produzione, per MongoDB e ha ricevuto continui aggiornamenti dal suo lancio. In questo tutorial impareremo a eseguire semplici operazioni CRUD di MongoDB usando il driver Go.
Prerequisiti
Sono necessarie due cose prima di iniziare con questo tutorial.
- Go dovrebbe essere installato sulla tua macchina. Per questo tutorial viene utilizzata la versione 1.15 di Go. Puoi scaricare il pacchetto Go da questo link.
- Installa l'ultima versione di MongoDB sulla tua macchina e avvia il server locale di MongoDB.
Installazione del driver MongoDB
Installa il driver MongoDB go eseguendo il comando seguente:
go get go.mongodb.org/mongo-driverSe stai usando i moduli Go, crea un file go.mod e quindi il comando sopra aggiungerà la dipendenza richiesta nel file mod. Questo file blocca tutti i requisiti del progetto alla versione corretta.
Impostazione del file principale
Crea un file main.go nella cartella del tuo progetto e aprilo nel tuo IDE. Prima di scrivere il codice per le operazioni di MongoDB, importiamo tutti i pacchetti necessari nel file.
package main
import (
"context"
"fmt"
"log"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)Ora, crea le seguenti variabili globali che useremo in tutte le funzioni operative CRUD.
var client *mongo.Client
var collection *mongo.Collection
var ctx = context.TODO()Inoltre, crea la struttura per il tipo di documento.
type Person struct {
Name string
Age int
City string
}Connessione a MongoDB
Ora la configurazione di base è pronta. Creiamo la nostra prima funzione per la connessione a MongoDB.
func connect() *mongo.Client {
clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
client, err := mongo.Connect(ctx, clientOptions)
if err != nil {
log.Fatal(err)
}
err = client.Ping(ctx, nil)
if err != nil {
log.Fatal(err)
}
fmt.Println("Connected to MongoDB!")
return client
}Questa funzione imposterà la connessione con il nostro MongoDB in esecuzione localmente e restituirà l'oggetto client. Una volta che il metodo di connessione restituisce l'oggetto client, possiamo utilizzare il metodo Ping() per verificare se la connessione è andata a buon fine o meno. Se il metodo Ping() restituisce un errore, possiamo aumentare l'errore e restituire.
Inserisci operazione
Per inserire un solo documento, possiamo usare il metodo insertOne e per inserire più documenti insieme, possiamo usare il metodo insertMany. Di seguito la funzione per inserire un documento nella collezione Persona:
func insertOne() {
akash := Person{"Akash", 28, "Bengaluru"}
res, err := collection. InsertOne (ctx, akash)
if err != nil {
log.Fatal(err)
}
fmt.Println("Inserted document: ", res.InsertedID)
}Ecco la funzione per aggiungere più documenti alla raccolta:
func insertMany() {
akash := Person{"Akash", 28, "Bengaluru"}
bob := Person {"Bob", 30, "New York"}
robin := Person {"Robin", 25, "London"}
persons := []interface{}{akash, bob, robin}
res, err := collection.InsertMany(ctx, persons)
if err != nil {
log.Fatal(err)
}
fmt.Println("Inserted documents: ", res.InsertedIDs)
}Per entrambe le operazioni, dobbiamo utilizzare la struttura Person che abbiamo creato in precedenza e inizializzarla con i nostri dati. Con la funzione InsertMany, sarà necessario passare l'interfaccia del tipo per tutti i documenti.
Recupera operazione
Per trovare i dati dalla raccolta, avremo bisogno di un filtro di passaggio, quindi assicurati di aver importato il pacchetto bson. Useremo il tipo bson.D per creare filtri usando oggetti bson.
func retrieveOne() {
var result Person
filter := bson.D{{"name", "Akash"}}
err := collection.FindOne(ctx, filter).Decode(&result)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Found a single document: %+v\n", result)
}Allo stesso modo, possiamo usare il metodo Trova per recuperare tutti i documenti corrispondenti.
func retrieveAll() {
findOptions := options.Find()
findOptions.SetLimit(2)
var results []*Person
cur, err := collection.Find(ctx, bson.D{{}}, findOptions)
if err != nil {
log.Fatal(err)
}
// Loop through the cursor
for cur.Next(context.TODO()) {
var elem Person
err := cur.Decode(&elem)
if err != nil {
log.Fatal(err)
}
results = append(results, &elem)
}
if err := cur.Err(); err != nil {
log.Fatal(err)
}
cur.Close(context.TODO())
}Puoi usare il pacchetto di opzioni per specificare opzioni come limite o ordini.
Operazione di aggiornamento
Come il metodo FineOne, anche per l'aggiornamento è possibile utilizzare il metodo UpdateOne con l'oggetto filtro bson. Questo codice aggiornerà tutti i documenti con il nome Akash e aumenterà di uno il valore di Age.
func update() {
filter := bson.D{{"name", "Akash"}}
update := bson.D{
{"$inc", bson.D{
{"Age", 1},
}},
}
updateResult, err := collection.UpdateOne(context.TODO(), filter, update)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Updated documents: %+v\n", updateResult)
}Elimina operazione
Per eliminare documenti da qualsiasi raccolta, puoi utilizzare il metodo DeleteOne o DeleteMany. Anche qui possiamo passare oggetti filtro bson in modo che corrispondano ai documenti ed eliminarli.
func delete() {
deleteResult, err := collection.DeleteMany(ctx, bson.D{{}})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Deleted %v documents in the trainers collection\n", deleteResult.DeletedCount)
}Se si passa l'oggetto bson.D{{}} come parametro di filtro, verranno eliminati tutti i documenti. Puoi utilizzare il metodo collection.Drop() per eliminare l'intera raccolta.
Una volta che tutte queste funzioni sono pronte, puoi usarle nella funzione del tuo driver in base alle tue esigenze. Si spera che questo sia sufficiente per iniziare a scrivere funzioni MongoDB in Go. Per ulteriori informazioni, puoi fare riferimento alla documentazione ufficiale del driver Go Mongo.
