Usando o MongoDB como fonte de dados no GoLang

Antes de começar

Este tutorial pressupõe que você tenha:

Compreensão básica da linguagem Go
Última versão do GoLang instalada em seu sistema
Última versão do MongoDB instalada em seu sistema

Neste tutorial, usaremos o MongoDB Go Driver oficial para gerenciar nosso banco de dados MongoDB. No devido processo, escreveremos um programa para aprender a instalar o MongoDB Go Driver e realizar operações CRUD com ele.

Instalação

Primeiro, em uma pasta vazia, execute o comando abaixo

go mod init gomongo

go mod init cria um novo arquivo go.mod e importa automaticamente as dependências quando você executar o programa go. Em seguida, crie o arquivo main.go e escreva o código abaixo, explicaremos o que esse código fará em um 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")
}

No código acima, importamos os pacotes bson, mongo e mongo/options do mongo-driver e definimos um Book tipo que será usado neste tutorial

Na função principal primeiro, criamos clientOptions com URL e credenciais do MongoDB e passamos para mongo.Connect função, Uma vez conectado, podemos verificar nossa conexão por client.Ping função.

O código a seguir usará booksCollection variável para consultar os books coleção de testdb.

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

Inserir documentos

Primeiro vamos criar uma estrutura Book para inserir na coleção, no código abaixo estamos usando collection.InsertOne função para inserir um único documento na coleção

// 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 inserir vários documentos de uma só vez, precisamos criar uma fatia de Book objeto e passá-lo para 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)

Atualizar documentos

Podemos atualizar um único documento pela função collection.UpdateOne . Requer um documento de filtro para corresponder aos documentos da coleção e um documento atualizado para descrever a operação de atualização. Você pode construí-los usando tipos bson.D. O código abaixo corresponderá ao livro com ISBN 0451526341 e incremente o campo de cópias em 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)

Você também pode atualizar mais de um documento de uma só vez em uma única coleção pela função collection.UpdateMany , Nela, precisamos passar o documento de filtro e atualizar o documento da mesma forma que collection.UpdateOne

Encontrar documentos

Para encontrar um único documento, podemos usar a função collection.FindOne() , passaremos um documento de filtro e decodificaremos o resultado no Book variável de tipo

// 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 vários documentos, usamos a função collection.Find() . Este método retorna um Cursor, Ele fornece um fluxo de documentos nos quais podemos iterar ou podemos obter todos os documentos pela função cursor.All() em uma fatia 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)

Excluir documentos

Podemos excluir documentos de uma coleção usando as funções collection.DeleteOne() ou collection.DeleteMany() . Aqui você passa bson.D{{}} como argumento de filtro, que corresponderá a todos os documentos da coleção.

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)

A coleção inteira pode ser descartada usando a função collection.Drop(), ela removerá todos os documentos e metadados, como índices da coleção

Depois de ter feito toda a operação, não se esqueça de fechar a conexão do MongoDB

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

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

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

Agora você pode usar facilmente o MongoDB como fonte de dados em seu aplicativo go, você pode encontrar o código completo usado neste tutorial em nosso repositório do Github