En marzo de 2019, se lanzó el controlador GO oficial listo para producción para MongoDB y ha estado recibiendo actualizaciones continuas desde su lanzamiento. En este tutorial, aprenderemos a realizar operaciones MongoDB CRUD simples utilizando el controlador Go.
Requisitos
Se requieren dos cosas antes de comenzar con este tutorial.
- Go debe estar instalado en su máquina. Para este tutorial se utiliza la versión 1.15 de Go. Puede descargar el paquete Go desde este enlace.
- Instala la última versión de MongoDB en tu máquina e inicia el servidor local de MongoDB.
Instalación del controlador MongoDB
Instale el controlador MongoDB go ejecutando el siguiente comando:
go get go.mongodb.org/mongo-driverSi está utilizando módulos Go, cree un archivo go.mod y luego el comando anterior agregará la dependencia requerida en el archivo mod. Este archivo bloquea todos los requisitos del proyecto en su versión correcta.
Configuración del archivo principal
Cree un archivo main.go en la carpeta de su proyecto y ábralo en su IDE. Antes de escribir el código para las operaciones de MongoDB, importemos todos los paquetes necesarios en el archivo.
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"
)Ahora, cree las siguientes variables globales que usaremos en todas las funciones de operación CRUD.
var client *mongo.Client
var collection *mongo.Collection
var ctx = context.TODO()Además, cree la estructura para el tipo de documento.
type Person struct {
Name string
Age int
City string
}Conectando a MongoDB
Ahora la configuración base está lista. Creemos nuestra primera función para conectarnos 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
}Esta función configurará la conexión con nuestro MongoDB que se ejecuta localmente y devolverá el objeto del cliente. Una vez que el método de conexión devuelve el objeto del cliente, podemos usar el método Ping() para verificar si la conexión fue exitosa o no. Si el método Ping() devuelve algún error, podemos generar el error y regresar.
Insertar operación
Para insertar solo un documento, podemos usar el método insertOne y para insertar varios documentos juntos, podemos usar el método insertMany. La siguiente es la función para insertar un documento en la colección 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)
}Esta es la función para agregar múltiples documentos a la colección:
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)
}Para ambas operaciones, necesitamos usar la estructura Person que creamos anteriormente e inicializarla con nuestros datos. Con la función InsertMany, necesitaremos pasar la interfaz de tipo para todos los documentos.
Operación de recuperación
Para encontrar datos de la colección, necesitaremos un filtro aprobado, así que asegúrese de haber importado el paquete bson. Usaremos el tipo bson.D para crear filtros usando objetos 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)
}De la misma manera, podemos usar el método Buscar para recuperar todos los documentos coincidentes.
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())
}Puede usar el paquete de opciones para especificar opciones como límite u órdenes.
Operación de actualización
Igual que el método FineOne, para la actualización también puede usar el método UpdateOne con el objeto de filtro bson. Este código actualizará todos los documentos con el nombre Akash y aumentará el valor de Edad en uno.
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)
}Operación de eliminación
Para eliminar documentos de cualquier colección, puede usar el método DeleteOne o DeleteMany. Aquí también, podemos pasar objetos de filtro bson para que coincidan con los documentos y eliminarlos.
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)
}Si pasa el objeto bson.D{{}} como parámetro de filtro, se eliminarán todos los documentos. Puede usar el método collection.Drop() para eliminar toda la colección.
Una vez que todas estas funciones estén listas, puede usarlas en su función de controlador según sus necesidades. Con suerte, esto será suficiente para comenzar a escribir funciones de MongoDB en Go. Para obtener más información, puede consultar la documentación oficial del controlador Go Mongo.
