Usando MongoDB como fuente de datos en GoLang

Antes de comenzar

Este tutorial asume que usted tiene:

Una comprensión básica del lenguaje Go
Última versión de GoLang instalada en su sistema
Última versión de MongoDB instalada en su sistema

En este tutorial, utilizaremos el controlador Go de MongoDB oficial. para gestionar nuestra base de datos MongoDB. En el debido proceso, escribiremos un programa para aprender a instalar el controlador MongoDB Go y realizar operaciones CRUD con él.

Instalación

Primero, en una carpeta vacía, ejecute el siguiente comando

go mod init gomongo

go mod init crea un nuevo archivo go.mod e importa automáticamente las dependencias cuando ejecuta el programa go. Luego cree el archivo main.go y escriba el código a continuación. Explicaremos qué hará este código en 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")
}

En el código anterior, importamos los paquetes bson, mongo y mongo/options de mongo-driver y definimos un Book tipo que se usará en este tutorial

Primero, en la función principal, creamos clientOptions con la URL y las credenciales de MongoDB y las pasamos a mongo.Connect función, una vez conectado podemos comprobar nuestra conexión por client.Ping función.

El siguiente código usará booksCollection variable para consultar los books colección de testdb.

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

Insertar documentos

Primero, creemos una estructura de libro para insertar en la colección, en el siguiente código estamos usando collection.InsertOne función para insertar un solo documento en la colección

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

Para insertar varios documentos a la vez, necesitamos crear una porción de Book objeto y páselo 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)

Actualizar documentos

Podemos actualizar un solo documento mediante la función collection.UpdateOne . Requiere un documento de filtro para hacer coincidir los documentos de la colección y un documento actualizado para describir la operación de actualización. Puede construirlos usando tipos bson.D. El siguiente código coincidirá con el libro con ISBN 0451526341 e incrementa el campo de copias en 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)

También puede actualizar más de un documento a la vez en una sola colección mediante la función collection.UpdateMany , En él, necesitamos pasar el documento de filtro y actualizar el documento igual que collection.UpdateOne

Buscar documentos

Para encontrar un solo documento, podemos usar la función collection.FindOne() , pasaremos un documento de filtro y decodificaremos el resultado en el Book tipo de variable

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

Para encontrar múltiples documentos, usamos la función collection.Find() . Este método devuelve un Cursor, proporciona una secuencia de documentos en los que podemos iterar o podemos obtener todos los documentos mediante la función cursor.All() en una porción de Book tipo.

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)

Eliminar documentos

Podemos eliminar documentos de una colección usando las funciones collection.DeleteOne() o collection.DeleteMany() . Aquí pasa bson.D{{}} como argumento de filtro, que coincidirá con todos los documentos de la colección.

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)

Toda la colección se puede eliminar usando la función collection.Drop(), eliminará todos los documentos y metadatos, como los índices de la colección

Una vez que haya realizado toda la operación, no olvide cerrar la conexión MongoDB

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

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

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

Ahora puede usar fácilmente MongoDB como fuente de datos en su aplicación Go. Puede encontrar el código completo utilizado en este tutorial en nuestro Github Repo