Tutorial do Driver MongoDB Go

UPD: o tutorial foi atualizado em conexão com o lançamento da versão.

Boas notícias! O driver oficial do mongoDB foi lançado.
Pensando um pouco, decidi traduzir o artigo do site oficial do mongoDB em vez de escrever o material pessoalmente (essa tradução é diferente do artigo).
Aqui está o que estará neste tutorial:

• Instale o mongo-go-driver
• Conecte-se ao mongoDB usando o mongo-go-driver
• Usando objetos BSON
• Usando métodos CRUD

O código original pode ser encontrado na documentação oficial .
Este tutorial requer o MongoDB instalado com a versão 2.6 ou superior e o Golang 1.10 ou posterior.

Instale o mongo-go-driver

É recomendável instalar o driver usando dep (é claro, se você ainda não mudou para os módulos):

dep ensure -add "go.mongodb.org/mongo-driver/mongo@~1.0.0" 

Criação da fundação

Crie um projeto e adicione o arquivo main.go com o seguinte conteúdo:

 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" "go.mongodb.org/mongo-driver/mongo/readpref" ) // You will be using this Trainer type later in the program type Trainer struct { Name string Age int City string } func main() { // Rest of the code will go here } 

Nesse código, importamos o mongo-go-driver, algumas bibliotecas padrão e definimos o tipo Trainer.

Conecte-se ao mongoDB usando o mongo-go-driver

Depois de importar o mongo-go-driver, tivemos a oportunidade de criar uma conexão com o mongoDB usando a função mongo.NewClient () . Temos a oportunidade de passar para essa função como argumentos o contexto e a linha que contém o endereço da conexão com o mongodb. Se desejar, também podemos passar o objeto options.ClientOptions como o terceiro argumento para ajustar as configurações do driver.
A documentação detalha as opções disponíveis.

Vamos adicionar o seguinte código ao corpo da função principal:

 // Create client client, err := mongo.NewClient(options.Client().ApplyURI("mongodb://127.0.0.1:27017")) if err != nil { log.Fatal(err) } // Create connect err = client.Connect(context.TODO()) 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!") 

Após conectar-se com sucesso ao mongoDB, podemos acessar a coleção de treinadores , localizada no banco de dados chamado test, adicionando o seguinte código ao final da função principal:

 collection := client.Database("test").Collection("trainers") 

É recomendável que você mantenha a conexão com o mongoDB aberta, para que você não precise abrir e fechar a conexão para cada solicitação. No entanto, se o aplicativo não precisar mais de uma conexão, ele poderá ser fechado usando a função client.Disconnect () da seguinte maneira:

 err = client.Disconnect(context.TODO()) if err != nil { log.Fatal(err) } fmt.Println("Connection to MongoDB closed.") 

Comente os pacotes não utilizados.

Execute nosso código ( vá em main.go ) para verificar a conexão com o servidor mongoDB.

Usando objetos BSON

Os documentos JSON no mongoDB são armazenados em um formato binário chamado BSON. Diferentemente de outros bancos de dados nos quais os dados JSON são armazenados na forma de sequências e números, a codificação BSON adiciona novos tipos, como int , long , date , float e decimal128 .

Isso simplifica muito o processamento, a classificação e a comparação de dados por aplicativos. O driver Go possui duas famílias de tipos para representar dados BSON: tipos D e tipos RAW.

A família D consiste em quatro tipos:

• Documento D : BSON. Esse tipo deve ser usado em situações em que a ordem é importante, por exemplo, comandos do MongoDB.
• M : Dicionário não ordenado (matriz associativa, mapa). É o mesmo que D , exceto que não preserva a ordem.
• A : matriz BSON.
• E : elemento único dentro de D.

Aqui está um exemplo de um filtro criado usando os tipos D que procura documentos nos quais o campo de nome corresponde aos valores de Alice ou Bob :

A família de tipos brutos é usada para verificar a divisão de bytes. Você pode extrair elementos únicos dos tipos Raw usando Lookup () .

Isso pode ser útil quando você precisar se livrar da carga extra ao converter o BSON para outro tipo.
Somente a família do tipo D será usada neste tutorial.

Usando métodos CRUD

Após a conexão bem-sucedida ao banco de dados, podemos começar a adicionar e modificar dados em nossa coleção.
O tipo de coleção contém métodos que permitem enviar consultas ao banco de dados.

Inserção (criação) de documentos

Primeiro, você precisa criar algumas novas estruturas do Trainer para inserir no banco de dados:

 ash := Trainer{"Ash", 10, "Pallet Town"} misty := Trainer{"Misty", 10, "Cerulean City"} brock := Trainer{"Brock", 15, "Pewter City"} 

Para incorporar um único documento, use o método collection.InsertOne () :

 insertResult, err := collection.InsertOne(context.TODO(), ash) if err != nil { log.Fatal(err) } fmt.Println("Inserted a single document: ", insertResult.InsertedID) 

Para inserir vários documentos ao mesmo tempo, existe o método collection.InsertMany () :

 trainers := []interface{}{misty, brock} insertManyResult, err := collection.InsertMany(context.TODO(), trainers) if err != nil { log.Fatal(err) } fmt.Println("Inserted multiple documents: ", insertManyResult.InsertedIDs) 

Atualização de documento

O método collection.UpdateOne () permite atualizar um único documento. Você precisa criar um filtro para procurar um documento no banco de dados e um documento para a operação de atualização. Você pode criá-los usando os tipos bson.D :

 filter := bson.D{{"name", "Ash"}} update := bson.D{ {"$inc", bson.D{ {"age", 1}, }}, } 

O código a seguir encontrará um documento no qual o campo de nome corresponde ao valor de Ash e aumenta o valor da idade em 1.

 updateResult, err := collection.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) 

Pesquisa de documentos

Para localizar um documento, você precisará de um filtro e um ponteiro para uma variável na qual o resultado possa ser decodificado.

Para encontrar um único documento, use collection.FindOne () . Este método retorna um único valor que pode ser decodificado em uma variável.

Usaremos a mesma variável de filtro usada na solicitação de atualização.

 // create a value into which the result can be decoded var result Trainer err = collection.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, use collection.Find () .

Este método retorna Cursor . O cursor fornece um fluxo de documentos com os quais você pode iterar e decodificar um documento por vez.

Quando os documentos no Cursor estiverem esgotados, feche o Cursor . Você também pode ajustar o Cursor usando o pacote de opções .

No nosso exemplo, estabelecemos um limite para a emissão de dois documentos.

 // Pass these options to the Find method options := options.Find() options.SetLimit(2) filter := bson.M{} // Here's an array in which you can store the decoded documents var results []*Trainer // Passing nil as the filter matches all documents in the collection cur, err := collection.Find(context.TODO(), filter, options) if err != nil { log.Fatal(err) } // Finding multiple documents returns a cursor // Iterating through the cursor allows us to decode documents one at a time for cur.Next(context.TODO()) { // create a value into which the single document can be decoded var elem Trainer err := cur.Decode(&elem) if err != nil { log.Fatal(err) } results = append(results, &elem) } if err := cur.Err(); err != nil { log.Fatal(err) } // Close the cursor once finished cur.Close(context.TODO()) fmt.Printf("Found multiple documents (array of pointers): %+v\n", results) 

Excluir documentos

Você pode excluir documentos usando collection.DeleteOne () ou collection.DeleteMany () . Passamos nulo como um argumento de filtro, que corresponderá a todos os documentos da coleção. Você também pode usar collection.Drop () para excluir a coleção inteira.

 filter := bson.M{} deleteResult, err := collection.DeleteMany(context.TODO(), filter) if err != nil { log.Fatal(err) } fmt.Printf("Deleted %v documents in the trainers collection\n", deleteResult.DeletedCount) 

Passos adicionais

→ O código final deste tutorial está no repositório do GitHub
→ Documentação do driver disponível no GoDoc

Se você tiver alguma dúvida, entre em contato conosco no grupo mongo-go-driver do Google .
Envie relatórios de erros para o MongoDB JIRA .
Teremos o maior prazer em receber seus comentários sobre o Go Driver.