Używanie MongoDB jako źródła danych w GoLang

Zanim zaczniesz

Ten samouczek zakłada, że ​​masz:

• Podstawowe zrozumienie języka Go
• Najnowsza wersja GoLang zainstalowana w Twoim systemie
• Najnowsza wersja MongoDB zainstalowana w Twoim systemie

W tym samouczku użyjemy oficjalnego sterownika MongoDB Go do zarządzania naszą bazą danych MongoDB. W odpowiednim procesie napiszemy program, który dowie się, jak zainstalować sterownik MongoDB Go i wykonywać z nim operacje CRUD.

Instalacja

Najpierw w pustym folderze uruchom poniższe polecenie

go mod init gomongo

go mod init tworzy nowy plik go.mod i automatycznie importuje zależności po uruchomieniu programu go. Następnie stwórz plik main.go i napisz poniższy kod, W ciągu min wyjaśnimy, co ten kod zrobi.

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

W powyższym kodzie zaimportowaliśmy pakiety bson, mongo i mongo/options z mongo-driver i zdefiniowaliśmy Book typ, który będzie używany w tym samouczku

W głównej funkcji najpierw utworzyliśmy clientOptions z adresem URL MongoDB i poświadczeniami i przekazaliśmy je do mongo.Connect funkcja, Po połączeniu możemy sprawdzić nasze połączenie przez client.Ping funkcja.

Poniższy kod użyje booksCollection zmienna do zapytania books zbieranie z testdb.

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

Wstaw dokumenty

Najpierw stwórzmy strukturę Book do wstawienia do kolekcji, w poniższym kodzie używamy collection.InsertOne funkcja wstawiania pojedynczego dokumentu do kolekcji

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

Aby wstawić wiele dokumentów naraz, musimy utworzyć kawałek books obiektu i przekaż go do 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)

Aktualizuj dokumenty

Możemy zaktualizować pojedynczy dokument za pomocą funkcji collection.UpdateOne . Wymaga dokumentu filtru, aby dopasować dokumenty w kolekcji i zaktualizowanego dokumentu, aby opisać operację aktualizacji. Możesz je zbudować za pomocą typów bson.D. Poniższy kod będzie pasował do książki z ISBN 0451526341 i zwiększ pole kopii o 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.")