Installez le pilote MongoDB
mkdr mongodb
cd mongodb
go mod init
go get go.mongodb.org/mongo-driver/mongoConnectez-vous à MongoDB
Créez un fichier main.go et
importez les packages suivants dans le fichier main.go
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"
"time"
)Le format URI pour la connexion à MongoDB est
mongodb://[username:password@]host1[:port1][,...hostN[:portN]][/[defaultauthdb][?options]]vision unique
mongodb://localhost:27017Ensemble de répliques
mongodb://mongodb0.example.com:27017,mongodb1.example.com：27017，mongodb2.example.com：27017 /?replicaSet = myReplCluster éclaté
mongodb://mongos0.example.com:27017,mongos1.example.com:27017,mongos2.example.com:27017mongo.Connect () accepte les objets Context et options.ClientOptions, qui sont utilisés pour définir la chaîne de connexion et d'autres paramètres du pilote.
En context.TODO()exprimant que vous n'êtes pas sûr du contexte à utiliser maintenant, mais que vous ajouterez une
méthode Ping à l'avenir pour détecter si MongoDB a été connecté normalement
func main() {
clientOptions := options.Client().ApplyURI("mongodb://admin:password@localhost:27017")
var ctx = context.TODO()
// Connect to MongoDB
client, err := mongo.Connect(ctx, clientOptions)
if err != nil {
log.Fatal(err)
}
// Check the connection
err = client.Ping(ctx, nil)
if err != nil {
log.Fatal(err)
}
fmt.Println("Connected to MongoDB!")
defer client.Disconnect(ctx)Lister toutes les bases de données
databases, err := client.ListDatabaseNames(ctx, bson.M{})
if err != nil {
log.Fatal(err)
}
fmt.Println(databases)Utiliser des objets BSON dans GO
Les documents JSON dans MongoDB sont stockés dans une représentation binaire appelée BSON (Binary Encoded JSON). Contrairement à d'autres bases de données qui stockent des données JSON sous forme de chaînes et de nombres simples, le codage BSON étend la représentation JSON, telle que int, long, date, virgule flottante et décimal128. Cela permet aux applications de traiter, trier et comparer plus facilement les données de manière fiable. Go Driver a deux séries pour représenter les données BSON: le type et le Raw系列type de série D. DLa série comprend quatre types:
D: Document BSON. Ce type est utilisé dans les scénarios où l'ordre est important, comme les commandes MongoDB.M: Carte non ordonnée.DIdem sauf que l'ordre n'est pas conservé .A: Une baie BSON.E:DUn seul élément dans.Insérer des données dans MongoDB
Insérer un seul document
//定义插入数据的结构体 type sunshareboy struct { Name string Age int City string }
// Se connecter à la collection sunshare de la bibliothèque de test. Si la collection n'existe pas, la collection sera créée automatiquement
: = client.Database ("test"). Collection ("sunshare")
wanger: = sunshareboy {"wanger", 24, "Beijing"}
insertOne , err: = collection.InsertOne (ctx, wanger)
if err! = nil {
log.Fatal (err)
}
fmt.Println ("Inséré un seul document:", insertOne.InsertedID)
执行结果如下
#### 同时插入多条文档
```go
collection := client.Database("test").Collection("sunshare")
dongdong:=sunshareboy{"张冬冬",29,"成都"}
huazai:=sunshareboy{"华仔",28,"深圳"}
suxin:=sunshareboy{"素心",24,"甘肃"}
god:=sunshareboy{"刘大仙",24,"杭州"}
qiaoke:=sunshareboy{"乔克",29,"重庆"}
jiang:=sunshareboy{"姜总",24,"上海"}
//插入多条数据要用到切片
boys:=[]interface{}{dongdong,huazai,suxin,god,qiaoke,jiang}
insertMany,err:= collection.InsertMany(ctx,boys)
if err != nil {
log.Fatal(err)
}
fmt.Println("Inserted multiple documents: ", insertMany.InsertedIDs)Interroger les données de MongDB
Interroger un seul document
Pour interroger un seul document, utilisez la fonction collection.FindOne (), qui nécessite un document filtre et un pointeur capable de décoder le résultat à sa valeur
var result sunshareboy
filter := bson.D{{"name","wanger"}}
err = collection.FindOne(context.TODO(), filter).Decode(&result)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Found a single document: %+v\n", result)Le résultat renvoyé est le suivant
Connected to MongoDB!
Found a single document: {Name:wanger Age:24 City:北京}
Connection to MongoDB closed.Interroger plusieurs documents
Pour interroger plusieurs documents, utilisez la fonction collection.Find (). Cette fonction renvoie un curseur, qui peut être utilisé pour itérer et décoder les documents. Une fois l'itération terminée, fermez le curseur
- La fonction Find exécute la commande find et renvoie Cursor sur les documents correspondants dans la collection.
- Le paramètre de filtre doit être le document contenant l'opérateur de requête et peut être utilisé pour sélectionner les documents inclus dans le résultat. Cela ne peut pas être zéro. Les documents vides (tels que bson.D {}) doivent être utilisés pour inclure tous les documents.
-
Le paramètre opts peut être utilisé pour spécifier les options de l'opération. Par exemple, nous pouvons définir la limite de renvoi de cinq documents seulement (https://godoc.org/go.mongodb.org/mongo-driver/mongo/options#Find）。
//定义返回文档数量 findOptions := options.Find() findOptions.SetLimit(5) //定义一个切片存储结果 var results []*sunshareboy //将bson.D{{}}作为一个filter来匹配所有文档 cur, err := collection.Find(context.TODO(), bson.D{{}}, findOptions) if err != nil { log.Fatal(err) } //查找多个文档返回一个游标 //遍历游标一次解码一个游标 for cur.Next(context.TODO()) { //定义一个文档，将单个文档解码为result var result sunshareboy err := cur.Decode(&result) if err != nil { log.Fatal(err) } results = append(results, &result) } fmt.Println(result) if err := cur.Err(); err != nil { log.Fatal(err) } //遍历结束后关闭游标 cur.Close(context.TODO()) fmt.Printf("Found multiple documents (array of pointers): %+v\n", results)Le résultat renvoyé est le suivant
Connected to MongoDB! {wanger 24 北京} {张冬冬 29 成都} {华仔 28 深圳} {素心 24 甘肃} {刘大仙 24 杭州} Found multiple documents (array of pointers): &[0xc000266450 0xc000266510 0xc000266570 0xc0002665d0 0xc000266630] Connection to MongoDB closed.Mettre à jour la documentation MongoDB
Mettre à jour un seul document
Pour mettre à jour un seul document, utilisez la fonction collection.UpdateOne (), un filtre est nécessaire pour faire correspondre le document dans la base de données, et un document de mise à jour est également nécessaire pour mettre à jour l'opération
- Le paramètre de filtre doit être le document contenant l'opérateur de requête et peut être utilisé pour sélectionner le document à mettre à jour. Cela ne peut pas être zéro. Si le filtre ne correspond à aucun document, l'opération réussira et un UpdateResult avec un MatchCount de 0 sera renvoyé. Si le filtre correspond à plusieurs documents, un sera sélectionné dans l'ensemble correspondant et MatchedCount est égal à 1.
- Le paramètre de mise à jour doit être un document contenant l'opérateur de mise à jour (https://docs.mongodb.com/manual/reference/operator/update/ ), et peut être utilisé pour spécifier des modifications au document sélectionné. Il ne peut pas être nul ou vide.
- Le paramètre opts peut être utilisé pour spécifier des options pour l'opération.
filter := bson.D{{"name","张冬冬"}} //如果过滤的文档不存在，则插入新的文档 opts := options.Update().SetUpsert(true) update := bson.D{ {"$set", bson.D{ {"city", "北京"}}, }} result, err := collection.UpdateOne(context.TODO(), filter, update,opts) if err != nil { log.Fatal(err) } if result.MatchedCount != 0 { fmt.Printf("Matched %v documents and updated %v documents.\n", result.MatchedCount, result.ModifiedCount) } if result.UpsertedCount != 0 { fmt.Printf("inserted a new document with ID %v\n", result.UpsertedID) }Le résultat renvoyé est le suivant
Connected to MongoDB! Matched 1 documents and updated 1 documents. Connection to MongoDB closed.Mettre à jour plusieurs documents
Pour mettre à jour plusieurs documents, utilisez la fonction collection.UpdateOne () avec les mêmes paramètres que la fonction collection.UpdateOne ()
filter := bson.D{{"city","北京"}} //如果过滤的文档不存在，则插入新的文档 opts := options.Update().SetUpsert(true) update := bson.D{ {"$set", bson.D{ {"city", "铁岭"}}, }} result, err := collection.UpdateMany(context.TODO(), filter, update,opts) if err != nil { log.Fatal(err) } if result.MatchedCount != 0 { fmt.Printf("Matched %v documents and updated %v documents.\n", result.MatchedCount, result.ModifiedCount) } if result.UpsertedCount != 0 { fmt.Printf("inserted a new document with ID %v\n", result.UpsertedID) }Le résultat renvoyé est le suivant
Connected to MongoDB! Matched 2 documents and updated 2 documents. Connection to MongoDB closed.Supprimer les documents MongoDB
Vous pouvez utiliser
collection.DeleteOne()oucollection.DeleteMany()supprimer le document. Si vous le transmettez enbson.D{{}}tant que paramètre de filtre, il correspondra à tous les documents de l'ensemble de données. Vous pouvez également utiliser pourcollection. drop()supprimer l'ensemble de données.filter := bson.D{{"city","铁岭"}} 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)Le résultat renvoyé est le suivant
Connected to MongoDB! Deleted 2 documents in the trainers collection Connection to MongoDB closed.Obtenir l'état du service MongoDB
Ci-dessus, nous avons présenté CRUD pour MongoDB. En fait, il prend également en charge de nombreuses opérations sur MongoDB, telles que l' agrégation , les transactions, etc. Ensuite, introduisons l'utilisation de golang pour obtenir l'état du service MongoDB. Après l'exécution, il renverra un type de données bson.Raw.
ctx, _ = context.WithTimeout(context.Background(), 30*time.Second) serverStatus, err := client.Database("admin").RunCommand( ctx, bsonx.Doc{{"serverStatus", bsonx.Int32(1)}}, ).DecodeBytes() if err != nil { fmt.Println(err) } fmt.Println(serverStatus) fmt.Println(reflect.TypeOf(serverStatus)) version, err := serverStatus.LookupErr("version") fmt.Println(version.StringValue()) if err != nil { fmt.Println(err) }Lien de référence
https://www.mongodb.com/blog/post/mongodb-go-driver-tutorial
https://godoc.org/go.mongodb.org/mongo-driver/mongo
Bienvenue à tous pour prêter attention à mon compte public personnel "Histoire de développement de l'exploitation et de la maintenance"