monogodb示例2

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
)

func main() {

	// Requires the MongoDB Go Driver
	// https://go.mongodb.org/mongo-driver
	ctx := context.TODO()

	// Set client options
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017/")

	// Connect to MongoDB
	client, err := mongo.Connect(ctx, clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	defer func() {
		if err := client.Disconnect(ctx); err != nil {
			log.Fatal(err)
		}
	}()

	// Open an aggregation cursor
	coll := client.Database("tpuc").Collection("onboard")
	id := "123456"
	filter := bson.M{"_id": id}

	/**
	// 删除数据，map
	deletepaths := []string{
		"Device.DHCPv4.Server.Pool.2.StaticAddress.3.Chaddr",
		"Device.DHCPv4.Server.Pool.2.StaticAddress.4.Chaddr",
	}
	delete := bson.M{"$pull": bson.M{"paths": bson.M{"path": bson.M{"$in": deletepaths}}}}
	ResDelete, deleteerr := coll.UpdateOne(ctx, filter, delete)
	if deleteerr != nil {
		log.Fatal(deleteerr)
	} else {
		log.Println(ResDelete.MatchedCount, ResDelete.ModifiedCount)
	}

	*/

	/**
	// 删除数据,正则表达式
	regexPath := "^Device\\.DHCPv4\\.Server\\.Pool\\.2\\.StaticAddress\\.[1-9]d*\\.Chaddr$"
	delete := bson.M{"$pull": bson.M{"paths": bson.M{"path": bson.M{"$regex": regexPath}}}}
	Res, err1 := coll.UpdateOne(ctx, filter, delete)
	if err1 != nil {
		log.Fatal(err1)
	} else {
		log.Println(Res.MatchedCount, Res.ModifiedCount)
	}

	// 插入数据 push 插入数据会重复
	// addToSet 如果数据不存在则插入，存在则更新，但是对象键次序不同，对象也不同，使用bson.D
	insertdata := bson.A{
		bson.D{
			{"path", "Device.DHCPv4.Server.Pool.2.StaticAddress.3.Chaddr"},
			{"old_value", ""},
			{"new_value", "tretgerg"},
			{"log", bson.A{"init"}},
		},
		bson.D{
			{"path", "Device.DHCPv4.Server.Pool.2.StaticAddress.4.Chaddr"},
			{"old_value", ""},
			{"new_value", "345643645"},
			{"log", bson.A{"init"}},
		},
	}

	insert := bson.M{"$addToSet": bson.M{"paths": bson.M{"$each": insertdata}}}
	ResInsert, inserterr := coll.UpdateOne(ctx, filter, insert)
	if inserterr != nil {
		log.Fatal(inserterr)
	} else {
		log.Println(ResInsert.MatchedCount, ResInsert.ModifiedCount)
	}

	*/

	// 更新数据 批量
	updatepaths := []string{
		"Device.DHCPv4.Server.Pool.2.StaticAddress.3.Chaddr",
		"Device.DHCPv4.Server.Pool.2.StaticAddress.4.Chaddr",
	}

	var bulkUpadteOps []mongo.WriteModel
	for _, value := range updatepaths {
		operationA := mongo.NewUpdateOneModel()
		operationA.SetFilter(filter)
		operationA.SetUpdate(bson.M{"$addToSet": bson.M{"paths.$[out].log": "add"}, "$set": bson.M{"paths.$[out].new_value": "465456"}})
		// Set Upsert flag option to turn the update operation to upsert
		operationA.SetUpsert(true)
		operationA.SetArrayFilters(
			options.ArrayFilters{
				Filters: []interface{}{
					bson.M{"out.path": value},
				},
			})
		bulkUpadteOps = append(bulkUpadteOps, operationA)
	}

	ResUpdate, updateerr := coll.BulkWrite(ctx, bulkUpadteOps)
	if updateerr != nil {
		log.Fatal(updateerr)
	} else {
		log.Println(ResUpdate.MatchedCount, ResUpdate.ModifiedCount)
	}

	// 查询数据
	regexpath := "^Device\\.DHCPv4\\.Server\\.Pool\\.2\\.StaticAddress\\.[1-9]d*\\.Chaddr$"
	showInfoCursor, err := coll.Aggregate(ctx, bson.A{
		bson.D{{"$unwind", bson.D{{"path", "$paths"}}}},
		bson.D{{"$match", bson.D{{"paths.path", bson.D{{"$regex", regexpath}}}}}},
	})
	if err != nil {
		log.Fatal(err)
	} else {
		log.Println("success")
	}

	var showsWithInfo []map[string]interface{}
	if err = showInfoCursor.All(context.TODO(), &showsWithInfo); err != nil {
		log.Printf("collection %s", err)
		panic(err)
	}

	for _, value := range showsWithInfo {
		fmt.Println(value)
	}

}