MongoDB——golang操作（链接，CURD，聚合）

MongoDB golang操作

中文文档

链接

package main

import (
	"context"
	"fmt"
	"log"

	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

func main() {
	// 设置客户端连接配置
	clientOptions := options.Client().ApplyURI("mongodb://192.168.157.142:27017").SetAuth(
			options.Credential{
				Username: "admin",
				Password: "12346",
			},
		)

	// 连接到MongoDB
	client, err := mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}

	// 检查连接
	err = client.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Connected to MongoDB!")
	// Close the connection once no longer needed
	err = client.Disconnect(context.TODO())

	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println("\nConnection to MongoDB closed.")
	}
}

CURD

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"
)

type Student struct {
	Name string
	Age  int
}

func main() {
	// 设置客户端连接配置
	clientOptions := options.Client().ApplyURI("mongodb://192.168.157.142:27017")

	// 连接到MongoDB
	client, err := mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}

	// 检查连接
	err = client.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Connected to MongoDB!\n")

	// 获取集合
	collection := client.Database("test").Collection("trainers")

	// 插入文档
	s1 := Student{"小红", 12}
	s2 := Student{"小兰", 10}
	s3 := Student{"小黄", 11}
	// 使用collection.InsertOne()方法插入一条文档记录
	insertResult, err := collection.InsertOne(context.TODO(), s1)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("\nInserted a single document: ", insertResult.InsertedID)
	// 使用collection.InsertMany()方法插入多条文档记录：
	students := []interface{}{s2, s3}
	insertManyResult, err := collection.InsertMany(context.TODO(), students)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Inserted multiple documents: ", insertManyResult.InsertedIDs)

	// 更新文档
	// 需要一个筛选器文档来匹配数据库中的文档，并需要一个更新文档来描述更新操作。你可以使用bson.D类型来构建筛选文档和更新文档
	filter := bson.D{{"name", "小兰"}}
	update := bson.D{
		{"$inc", bson.D{
			{"age", 1},
		}},
	}
	// updateone()方法允许你更新单个文档 通过下面的语句找到小兰，给他增加一岁
	updateResult, err := collection.UpdateOne(context.TODO(), filter, update)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("\nMatched %v documents and updated %v documents.\n", updateResult.MatchedCount, updateResult.ModifiedCount)

	// 查找文档
	// 创建一个Student变量用来接收查询的结果
	var result Student
	// 这个方法返回一个可以解码为值的结果
	err = collection.FindOne(context.TODO(), filter).Decode(&result)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("\nFound a single document: %+v\n", result)

	// 查询多个
	// 将选项传递给Find()
	findOptions := options.Find()
	findOptions.SetLimit(3) //用options包设置一个限制以便只返回两个文档
	findOptions.SetSkip(1)

	// 定义一个切片用来存储查询结果
	var results []*Student

	// 把bson.D{{}}作为一个filter来匹配所有文档
	// 此方法返回一个游标。游标提供了一个文档流，你可以通过它一次迭代和解码一个文档。当游标用完之后，应该关闭游标。
	cur, err := collection.Find(context.TODO(), bson.D{{}}, findOptions)
	if err != nil {
		log.Fatal(err)
	}

	// 查找多个文档返回一个光标
	// 遍历游标允许我们一次解码一个文档
	for cur.Next(context.TODO()) {
		// 创建一个值，将单个文档解码为该值
		var elem Student
		err := cur.Decode(&elem)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Printf("Found multiple document: %+v\n", elem)
		results = append(results, &elem)
	}

	if err := cur.Err(); err != nil {
		log.Fatal(err)
	}

	// 完成后关闭游标
	cur.Close(context.TODO())
	fmt.Printf("\nFound multiple documents (array of pointers): %+v\n\n", results)

	// 删除文档
	// 使用collection.DeleteOne()或collection.DeleteMany()删除文档。如果你传递bson.D{{}}作为过滤器参数，它将匹配数据集中的所有文档。还可以使用collection. drop()删除整个数据集。
	// 删除名字是小黄的那个
	deleteResult1, err := collection.DeleteOne(context.TODO(), bson.D{{"name", "小黄"}})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("\nDeleted %v documents in the trainers collection\n", deleteResult1.DeletedCount)
	// 删除所有
	deleteResult2, err := collection.DeleteMany(context.TODO(), bson.D{{}})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("\nDeleted %v documents in the trainers collection\n", deleteResult2.DeletedCount)

	err = collection.Drop(context.TODO())
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println("\nDrop document")
	}

	// Close the connection once no longer needed
	err = client.Disconnect(context.TODO())

	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println("\nConnection to MongoDB closed.")
	}
}

聚合

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"
)

type IdDept struct {
	Dept string
	Age  int
}

type ResultDept struct {
	_id IdDept
	// Pers          int
	DeptAvgSalary int
}

func main() {
	// 设置客户端连接配置
	clientOptions := options.Client().ApplyURI("mongodb://192.168.157.142:27017")

	// 连接到MongoDB
	client, err := mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}

	// 检查连接
	err = client.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Connected to MongoDB!\n")

	// 获取集合
	persons := client.Database("test").Collection("persons")

	// Start Aggregation Example 1
    /*
    获取 6 个年龄大于 22 周岁的用户，其中如果薪水如果小于 1000，直接将薪水上调到 4000，
    前面一步做好后，需要排除年龄最大的一个，求出每个部门，相同年龄的员工的平均薪水，并得到
    薪水最高的三个人。
    思路：1、投影出年龄(age),部门(dept),薪水(salary)字段
    2、查出年龄大于 22 周岁的员工
    3、以年龄倒序进行排序
    4、限制返回 7 条数据，并跳过一条数据
    5、以部门年龄进行分组，并求出平均分
    6、以上一步的平均分在进行倒序排序
	7、然后再返回 3 条数据*/
	pipeline := []bson.M{
		bson.M{"$project": bson.M{
			"age":    1,
			"dept":   1,
			"salary": 1}},
		bson.M{"$addFields": bson.M{"salary": bson.M{"$cond": bson.M{
			"if":   bson.M{"$lt": []interface{}{"$salary", 1000}},
			"then": bson.M{"$add": []interface{}{"$salary", 4000}},
			"else": "$salary"}}}},
		bson.M{"$match": bson.M{"age": bson.M{"$gt": 22}}},
		bson.M{"$sort": bson.M{"age": -1}},
		bson.M{"$skip": 1},
		bson.M{"$limit": 7},
		bson.M{"$group": bson.M{
			"_id": bson.M{"dept":"$dept", "age":"$age"},
			"avg": bson.M{"$avg": "$salary"}}},
		bson.M{"$sort": bson.M{"avg": -1}},
		bson.M{"$limit": 3},
	}

	cur, err := persons.Aggregate(context.TODO(), pipeline)
	if err != nil {
		log.Fatal(err)
	}
	// 定义一个切片用来存储查询结果
	var results []*ResultDept
	// 查找多个文档返回一个光标
	// 遍历游标允许我们一次解码一个文档
	for cur.Next(context.TODO()) {
		// 创建一个值，将单个文档解码为该值
		// var elem ResultDept
		var elem map[string]interface{}
		err := cur.Decode(&elem)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Printf("Found multiple document: %+v\n", elem)
		// results = append(results, &elem)
	}

	if err := cur.Err(); err != nil {
		log.Fatal(err)
	}

	// 完成后关闭游标
	cur.Close(context.TODO())
	fmt.Printf("\nAggregate multiple documents (array of pointers): %+v\n\n", results)

	// Close the connection once no longer needed
	err = client.Disconnect(context.TODO())

	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println("\nConnection to MongoDB closed.")
	}
}