Em março de 2019, o driver GO oficial e pronto para produção para MongoDB foi lançado e vem recebendo atualizações contínuas desde o seu lançamento. Neste tutorial, aprenderemos a fazer operações simples do MongoDB CRUD usando o driver Go.
Pré-requisitos
Duas coisas são necessárias antes de começarmos com este tutorial.
- Go deve estar instalado em sua máquina. Go versão 1.15 é usado para este tutorial. Você pode baixar o pacote Go neste link.
- Instale a versão mais recente do MongoDB em sua máquina e inicie o servidor local do MongoDB.
Instalação do Driver MongoDB
Instale o driver MongoDB go executando o seguinte comando:
go get go.mongodb.org/mongo-driverSe você estiver usando Go Modules, crie um arquivo go.mod e, em seguida, o comando acima adicionará a dependência necessária no arquivo mod. Este arquivo bloqueia todos os requisitos do projeto para sua versão correta.
Configurando o arquivo principal
Crie um arquivo main.go na pasta do seu projeto e abra-o em seu IDE. Antes de escrevermos o código para as operações do MongoDB, vamos importar todos os pacotes necessários no arquivo.
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"
)Agora, crie as seguintes variáveis globais que usaremos em todas as funções de operação CRUD.
var client *mongo.Client
var collection *mongo.Collection
var ctx = context.TODO()Além disso, crie a estrutura para o tipo de documento.
type Person struct {
Name string
Age int
City string
}Conectando ao MongoDB
Agora a configuração básica está pronta. Vamos criar nossa primeira função para conectar ao 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 função irá configurar a conexão com nosso MongoDB rodando localmente e retornar o objeto cliente. Uma vez que o método connect retorna o objeto cliente, podemos usar o método Ping() para verificar se a conexão foi bem sucedida ou não. Se o método Ping() retornar algum erro, podemos gerar o erro e retornar.
Inserir Operação
Para inserir apenas um documento, podemos usar o método insertOne e para inserir vários documentos juntos, podemos usar o método insertMany. A seguir está a função para inserir um documento na coleção Person:
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)
}Aqui está a função para adicionar vários documentos à coleção:
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 as operações, precisamos usar a estrutura Person que criamos anteriormente e inicializá-la com nossos dados. Com a função InsertMany, precisaremos passar a interface de tipo para todos os documentos.
Recuperar operação
Para localizar dados da coleção, precisaremos de um filtro de passagem, portanto, certifique-se de ter importado o pacote bson. Usaremos o tipo bson.D para criar 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)
}Da mesma forma, podemos usar o método Find para recuperar todos os documentos correspondentes.
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())
}Você pode usar o pacote de opções para especificar opções como limite ou ordens.
Operação de atualização
Igual ao método FineOne, para atualização também você pode usar o método UpdateOne com o objeto de filtro bson. Este código atualizará todos os documentos com o nome Akash e aumentará o valor de Idade em um.
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)
}Excluir operação
Para excluir documentos de qualquer coleção, você pode usar o método DeleteOne ou DeleteMany. Aqui também, podemos passar objetos de filtro bson para corresponder aos documentos e excluí-los.
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)
}Se você passar o objeto bson.D{{}} como um parâmetro de filtro, ele excluirá todos os documentos. Você pode usar o método collection.Drop() para descartar a coleção inteira.
Quando todas essas funções estiverem prontas, você poderá usá-las em sua função de driver de acordo com sua necessidade. Espero que isso seja suficiente para você começar a escrever funções do MongoDB em Go. Para obter mais informações, consulte a documentação oficial do driver Go Mongo.
