Utilizzo di MongoDB come origine dati in GoLang

Prima di iniziare

Questo tutorial presuppone che tu abbia:

• Una conoscenza di base di Go Language
• Ultima versione di GoLang installata sul tuo sistema
• Ultima versione di MongoDB installata sul tuo sistema

In questo tutorial utilizzeremo il Driver MongoDB Go ufficiale per gestire il nostro database MongoDB. A tempo debito, scriveremo un programma per imparare come installare MongoDB Go Driver ed eseguire operazioni CRUD con esso.

Installazione

Innanzitutto in una cartella vuota esegui il comando seguente

go mod init gomongo

go mod init crea un nuovo file go.mod e importa automaticamente le dipendenze quando esegui il programma go. Quindi crea il file main.go e scrivi il codice seguente, ti spiegheremo cosa farà questo codice in un minuto.

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"
)

// Book - We will be using this Book type to perform crud operations
type Book struct {
  Title     string
  Author    string
  ISBN      string
  Publisher string
  Copies     int
}

func main() {
    
  // Set client options
  clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")

  // Connect to MongoDB
  client, err := mongo.Connect(context.TODO(), 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!")
  booksCollection := client.Database("testdb").Collection("books")
}

Nel codice sopra, abbiamo importato i pacchetti bson, mongo e mongo/options di mongo-driver e definito un Book tipo che verrà utilizzato in questo tutorial

Nella funzione principale prima, abbiamo creato clientOptions con l'URL e le credenziali MongoDB e lo abbiamo passato a mongo.Connect funzione, una volta connessi possiamo controllare la nostra connessione tramite client.Ping funzione.

Il codice seguente utilizzerà booksCollection variabile per interrogare i books raccolta da testdb.

booksCollection := client.Database("testdb").Collection("books")

Inserisci documenti

Per prima cosa creiamo una struttura Book da inserire nella collezione, nel codice sottostante stiamo usando collection.InsertOne funzione per inserire un unico documento nella collezione

// Insert One document
book1 := Book{"Animal Farm", "George Orwell", "0451526341", "Signet Classics", 100}
insertResult, err := booksCollection.InsertOne(context.TODO(), book1)
if err != nil {
    log.Fatal(err)
}

fmt.Println("Inserted a single document: ", insertResult.InsertedID)

Per inserire più documenti contemporaneamente dobbiamo creare una fetta di Book oggetto e passalo a collection.InsertMany

// Insert multiple documents
book2 := Book{"Super Freakonomics", "Steven D. Levitt", "0062312871", "HARPER COLLINS USA", 100}
book3 := Book{"The Alchemist", "Paulo Coelho", "0062315005", "HarperOne", 100}
multipleBooks := []interface{}{book2, book3}

insertManyResult, err := booksCollection.InsertMany(context.TODO(), multipleBooks)
if err != nil {
    log.Fatal(err)
}

fmt.Println("Inserted multiple documents: ", insertManyResult.InsertedIDs)

Aggiorna documenti

Possiamo aggiornare un singolo documento tramite la funzione collection.UpdateOne . Richiede un documento filtro per abbinare i documenti nella raccolta e un documento aggiornato per descrivere l'operazione di aggiornamento. Puoi costruirli usando i tipi bson.D. Il codice seguente corrisponderà al libro con ISBN 0451526341 e incrementa il campo delle copie di 10

//Update one document
filter := bson.D{{"isbn", "0451526341"}}

update := bson.D{
    {"$inc", bson.D{
        {"copies", 10},
    }},
}

updateResult, err := booksCollection.UpdateOne(context.TODO(), filter, update)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Matched %v documents and updated %v documents.\n", updateResult.MatchedCount, updateResult.ModifiedCount)

// A variable in which result will be decoded
var result Book

err = booksCollection.FindOne(context.TODO(), filter).Decode(&result)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Found a single document: %+v\n", result)

cursor, err := booksCollection.Find(context.TODO(), bson.D{{}})
if err != nil {
  log.Fatal(err)
}
var books []Book
if err = cursor.All(context.TODO(), &books); err != nil {
  log.Fatal(err)
}
fmt.Printf("Found multiple documents: %+v\n", books)

deleteCollection, err := booksCollection.DeleteMany(context.TODO(), bson.D{{}})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Deleted %v documents in the books collection\n", deleteCollection.DeletedCount)

err = client.Disconnect(context.TODO())

if err != nil {
    log.Fatal(err)
}

fmt.Println("Connection to MongoDB closed.")