Tutorial de controladores de MongoDB Go

UPD: el tutorial se ha actualizado en relación con el lanzamiento de la versión de lanzamiento.

Buenas noticias! Se ha lanzado el controlador oficial de go para mongoDB .
Con un poco de reflexión, decidí traducir el artículo del sitio web oficial de mongoDB en lugar de escribir el material yo mismo (esta traducción es diferente del artículo).
Esto es lo que habrá en este tutorial:

• Instalar mongo-go-driver
• Conéctese a mongoDB usando mongo-go-driver
• Usando objetos BSON
• Usando métodos CRUD

El código original se puede encontrar en la documentación oficial .
Para usar esta guía, debe haber instalado la versión de MongoDB no inferior a 2.6 y Golang 1.10 o posterior.

Instalar mongo-go-driver

Se recomienda que instale el controlador usando dep (por supuesto, si aún no ha cambiado a módulos):

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

Creación de fundaciones

Cree un proyecto y agregue el archivo main.go con los siguientes contenidos:

 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 } 

En este código, importamos mongo-go-driver, algunas bibliotecas estándar y definimos el tipo Entrenador.

Conéctese a mongoDB usando mongo-go-driver

Después de importar mongo-go-driver, tuvimos la oportunidad de crear una conexión con mongoDB usando la función mongo.NewClient () . Tenemos la oportunidad de pasar a esta función como argumentos el contexto y la línea que contiene la dirección de la conexión a mongodb. Si lo desea, también podemos pasar el objeto options.ClientOptions como el tercer argumento para ajustar la configuración del controlador.
La documentación detalla las opciones disponibles.

Agreguemos el siguiente código al cuerpo de la función 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!") 

Después de conectarnos con éxito a mongoDB, podemos acceder a la colección de entrenadores , que se encuentra en la base de datos llamada prueba agregando el siguiente código al final de la función principal:

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

Se recomienda mantener abierta la conexión con mongoDB para que no tenga que abrir y cerrar la conexión para cada solicitud. Sin embargo, si la aplicación ya no requiere una conexión, se puede cerrar con el cliente. La función Disconnect () es la siguiente:

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

Comente los paquetes no utilizados.

Ejecute nuestro código ( vaya a ejecutar main.go ) para verificar la conexión al servidor mongoDB.

Usando objetos BSON

Los documentos JSON en mongoDB se almacenan en un formato binario llamado BSON. A diferencia de otras bases de datos en las que los datos JSON se almacenan en forma de cadenas y números, la codificación BSON agrega nuevos tipos, como int , long , date , float y decimal128 .

Esto simplifica enormemente el procesamiento, la clasificación y la comparación de datos por aplicaciones. El controlador Go tiene dos familias de tipos para representar datos BSON: tipos D y tipos RAW.

La familia D consta de cuatro tipos:

• D : documento BSON. Este tipo debe usarse en situaciones en las que el orden es importante, por ejemplo, los comandos MongoDB.
• M : Diccionario desordenado (matriz asociativa, mapa). Es lo mismo que D , excepto que no conserva el orden.
• A : matriz BSON.
• E : elemento único dentro de D.

Aquí hay un ejemplo de un filtro creado con tipos D que busca documentos en los que el campo de nombre coincide con los valores de Alice o Bob :

La familia de tipos sin formato se utiliza para comprobar el corte de bytes. Puede extraer elementos individuales de tipos sin formato con Lookup () .

Esto puede ser útil cuando necesita deshacerse de la carga adicional al convertir BSON a otro tipo.
Solo se usará la familia tipo D en este tutorial.

Usando métodos CRUD

Después de conectarse con éxito a la base de datos, podemos comenzar a agregar y modificar datos en nuestra colección.
El tipo Colección contiene métodos que le permiten enviar consultas a la base de datos.

Inserción (creación) de documentos

Primero necesita crear algunas nuevas estructuras de Entrenador para insertar en la base de datos:

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

Para incrustar un solo documento, use el 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 insertar varios documentos al mismo tiempo, existe el 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) 

Actualización de documento

El método collection.UpdateOne () le permite actualizar un solo documento. Debe crear un filtro para buscar un documento en la base de datos y un documento para la operación de actualización. Puede crearlos usando los tipos bson.D :

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

El siguiente código encontrará un documento en el que el campo de nombre coincide con el valor de Ash y aumenta el valor de la edad en 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) 

Búsqueda de documentos

Para encontrar un documento, necesitará un filtro, así como un puntero a una variable en la que se pueda decodificar el resultado.

Para encontrar un solo documento, use collection.FindOne () . Este método devuelve un valor único que puede decodificarse en una variable.

Utilizaremos la misma variable de filtro que se usó en la solicitud de actualización.

 // 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 varios documentos, use collection.Find () .

Este método devuelve el cursor . El cursor proporciona una secuencia de documentos con los que puede iterar y decodificar un documento a la vez.

Cuando los documentos en Cursor están agotados, debe cerrar Cursor . También puede ajustar Cursor utilizando el paquete de opciones .

En nuestro ejemplo, establecemos un límite en la emisión de dos 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) 

Eliminar documentos

Puede eliminar documentos usando collection.DeleteOne () o collection.DeleteMany () . Pasamos nil como argumento de filtro, que coincidirá con todos los documentos de la colección. También puede usar collection.Drop () para eliminar toda la colección.

 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) 

Pasos adicionales

→ El código final para este tutorial está en el repositorio de GitHub
→ Documentación del controlador disponible en GoDoc

Si tiene alguna pregunta, contáctenos en el grupo de google mongo-go-driver .
Envíe informes de errores a MongoDB JIRA .
Estaremos encantados de recibir sus comentarios sobre Go Driver.