【go】【mongo】

写在前面

相关博文
个人博客首页
免责声明：仅供学习交流使用！开源框架可能存在的风险和相关后果将完全由用户自行承担，本人不承担任何法律责任。

[install]

https://www.mongodb.com/zh-cn/docs/drivers/go/current/quick-reference/

go get go.mongodb.org/mongo-driver/mongo

[connection]

https://www.mongodb.com/zh-cn/docs/drivers/go/current/fundamentals/connections/connection-guide/

	// To configure auth via a URI instead of a Credential, use
	// "mongodb://ldap-user:ldap-pwd@localhost:27017/?authMechanism=PLAIN".
	credential := options.Credential{
		//AuthMechanism: "PLAIN",
		Username: username,
		Password: password,
	}

	clientOpts := options.Client().ApplyURI(fmt.Sprintf("mongodb://%s:%d", host, port)).SetAuth(credential)
``
## document
### create one 
```go
		user := bson.M{"name": "user1", "age": 18, "six": true, "info": "info 1 any to be command"}
		result, err := c.InsertOne(context.TODO(), user)

create many

		users := []any{
			bson.M{"name": "user2", "age": 18, "six": true, "info": "info 2 any to be command"},
			bson.M{"name": "user3", "age": 18, "six": true, "info": "info 3 any to be command"},
			bson.M{"name": "user4", "age": 18, "six": true, "info": "info 4 any to be command"},
			bson.M{"name": "user5", "age": 18, "six": true, "info": "info 5 any to be command"},
		}
		result, err := c.InsertMany(context.TODO(), users)

create delete one

		filter := bson.M{"age": bson.M{"$gt": 18}}
		result, err := c.DeleteOne(context.TODO(), filter)

delete many

		filter := bson.M{}
		result, err := c.DeleteMany(context.TODO(), filter)

update one

		filter := bson.M{"name": "user1"}
		update := bson.M{"$inc": bson.M{"age": 1}}
		result, err := c.UpdateOne(context.TODO(), filter, update)

update many

		filter := bson.M{"age": bson.M{"$gte": 25}}
		update := bson.M{"$inc": bson.M{"age": -10}}
		result, err := c.UpdateMany(context.TODO(), filter, update)

find one

		var result Users
		filter := bson.M{"age": bson.M{"$lt": 19}}
		err := c.FindOne(context.TODO(), filter).Decode(&result)

find many Next

		var results []Users
		course, err := c.Find(context.TODO(), bson.M{})
		
		defer course.Close(context.TODO())
		for course.Next(context.TODO()) {
			var result Users
			err := course.Decode(&result)
			results = append(results, result)
		}
	})

find many All

		filter := bson.M{"$and": []bson.M{
			{"age": bson.M{"$gte": 18}},
			//{"name": "2"},
		}}
		course, err := c.Find(context.TODO(), filter)
		var results []Users
		err = course.All(context.TODO(), &results)

find many filter

		filter := bson.M{"$text": bson.M{"$search": "info"}}
		cursor, err := c.Find(context.TODO(), filter)
		defer cursor.Close(context.TODO())
			var result []Users
			errs := cursor.All(context.TODO(), &result)

建立索引

coll := client.Database("sample_mflix").Collection("movies")
indexModel := mongo.IndexModel{
    Keys: bson.D{{"title", 1}},
}
name, err := coll.Indexes().CreateOne(context.TODO(), indexModel)
if err != nil {
    panic(err)
}
fmt.Println("Name of Index Created: " + name)

查询单条索引

package main

import (
	"context"
	"fmt"
	"log"
	"regexp"

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

func main() {
	// MongoDB服务连接配置
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")

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

	// 指定数据库和集合
	collection := client.Database("yourDatabase").Collection("yourCollection")

	// 构建查询条件，使用正则表达式检索特定字符
	// 下面的例子是查找fieldname字段中包含"specificString"字符的文档
	regex := bson.M{"$regex": regexp.QuoteMeta("specificString")}
	filter := bson.M{"fieldname": regex}

	// 执行查询
	cursor, err := collection.Find(context.Background(), filter)
	if err != nil {
		log.Fatal(err)
	}
	defer cursor.Close(context.Background())

	// 遍历查询结果
	var results []YourStructType
	if err = cursor.All(context.Background(), &results); err != nil {
		log.Fatal(err)
	}

	// 打印查询结果
	for _, result := range results {
		fmt.Printf("Found document: %+v\n", result)
	}
}

// YourStructType 应该是匹配你MongoDB集合中文档结构的Go struct
type YourStructType struct {
	Fieldname string `bson:"fieldname"`
	// 添加更多字段...
}

查询全部索引

创建索引

index := mongo.IndexModel{
    Keys: bson.M{"$**": "text"}, // 这个索引将覆盖所有字段
}
collection := client.Database("yourDatabase").Collection("yourCollection")
indexName, err := collection.Indexes().CreateOne(context.Background(), index)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Created index named: %s\n", indexName)

查询全部索引

collection := client.Database("yourDatabase").Collection("yourCollection")

// 构建查询条件
query := bson.M{"$text": bson.M{"$search": "specificString"}}

// 执行查询，这将在所有字段上应用文本搜索
cursor, err := collection.Find(context.Background(), query)
if err != nil {
    log.Fatal(err)
}
defer cursor.Close(context.Background())

// 遍历结果
for cursor.Next(context.Background()) {
	var result bson.M // 或者你自己的结构体类型
	if err := cursor.Decode(&result); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Found document: %+v\n", result)
}

// 检查遍历过后是否有错误发生
if err := cursor.Err(); err != nil {
	log.Fatal(err)
}

分页索引

package main

import (
	"context"
	"fmt"
	"log"

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

func main() {
	// MongoDB服务连接配置
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	client, err := mongo.Connect(context.Background(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Disconnect(context.Background())

	// 指定数据库和集合
	collection := client.Database("yourDatabase").Collection("yourCollection")

	// 设置分页参数
	pageSize := 10 // 每页文档数量
	pageNumber := 1 // 获取第几页，这里为例子只获取第一页

	// 创建分页查询的options
	findOptions := options.Find().
		SetSkip(int64((pageNumber - 1) * pageSize)).
		SetLimit(int64(pageSize))

	// 进行分页查询
	cursor, err := collection.Find(context.Background(), bson.D{{}}, findOptions)
	if err != nil {
		log.Fatal(err)
	}
	defer cursor.Close(context.Background())

	// 遍历查询结果
	for cursor.Next(context.Background()) {
		// 在这里定义你的结构体以匹配集合格式
		var document bson.M // 也可以换成YourStructType
		if err := cursor.Decode(&document); err != nil {
			log.Fatal(err)
		}
		fmt.Println(document) // 打印文档
	}

	// 检查遍历过后是否有错误发生
	if err := cursor.Err(); err != nil {
		log.Fatal(err)
	}
}

正则表达

package main

import (
	"context"
	"fmt"
	"log"
	"regexp"

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

func main() {
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	client, err := mongo.Connect(context.Background(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Disconnect(context.Background())

	collection := client.Database("yourDatabase").Collection("yourCollection")

	// 使用正则表达式构建查询条件
	specificString := "searchString"
	filter := bson.M{
		"$or": []bson.M{
			{"field1": bson.M{"$regex": regexp.QuoteMeta(specificString), "$options": "i"}},
			{"field2": bson.M{"$regex": regexp.QuoteMeta(specificString), "$options": "i"}},
			// 为更多字段添加相同结构的正则表达式条件
		},
	}

	cursor, err := collection.Find(context.Background(), filter)
	if err != nil {
		log.Fatal(err)
	}
	defer cursor.Close(context.Background())

	for cursor.Next(context.Background()) {
		var result bson.M // 或者你的自定义结构体类型
		if err := cursor.Decode(&result); err != nil {
			log.Fatal(err)
		}
		fmt.Printf("Found document: %+v\n", result)
	}

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

// 定义一个与你的文档结构相匹配的Go struct类型
type YourDocumentType struct {
	Field1 string `bson:"field1"`
	Field2 string `bson:"field2"`
	// 其他字段
}

索引检索

index := mongo.IndexModel{
    Keys: bson.M{
        "field1": "text",
        "field2": "text",
        // 为更多字段添加"text"索引
    },
}
_, err := collection.Indexes().CreateOne(context.Background(), index)
if err != nil {
    // 处理错误
}
filter := bson.M{"$text": bson.M{"$search": "searchString"}}
cursor, err := collection.Find(context.Background(), filter)
// 处理错误和遍历结果 cursor 的代码与之前相同
// 文本索引有一些限制，比如不能在文本索引字段中使用通配符"$**"创建索引。
// 因此，如果你需要对所有字段进行文本搜索，可能需要一个更复杂的解决方案，或者使用正则表达式的方法。再次强调，正则表达式方法通常不如文本索引效率高，特别是在缺少索引的大型数据库中，所以在使用前请评估性能方面的需求和成本。

mongo bson 动态数据 `难度`

bson.M是一个map，你可以像在Go中修改任何其他map一样来修改它。
示例：添加、更新、删除字段

// 创建一个bson.M对象
doc := bson.M{"name": "John", "age": 30, "city": "New York"}

// 更新字段
doc["age"] = 31

// 添加新字段
doc["gender"] = "male"

// 删除字段
delete(doc, "city")

fmt.Println(doc)

bson.D是一个有序的元素列表，每一个元素都是bson.E或bson.Element类型，包含键和值。修改bson.D通常需要遍历元素列表。


示例：更新bson.D中的字段
// 创建一个bson.D对象
doc := bson.D{{"name", "John"}, {"age", 30}, {"city", "New York"}}

// 更新age字段
for i, elem := range doc {
    if elem.Key == "age" {
        doc[i] = bson.E{Key: "age", Value: 31}
    }
}

fmt.Println(doc)

// 假设根据某些业务逻辑，我们需要动态地添加字段到文档中
fieldsToAdd := map[string]interface{}{
	"name":      "Dynamic John",
	"timestamp": time.Now().Unix(),
	"tags":      []string{"dynamic", "data", "go"},
}

// 将map中的字段添加到bson.D类型的文档中
for key, value := range fieldsToAdd {
	dynamicDoc = append(dynamicDoc, bson.E{Key: key, Value: value})
}

参考资料

`基础/标准库/第三方库`

`golang 导航`

`编程规范`

`算法｜面试`

`项目`

posted @ 2024-05-06 17:22 Nones 阅读(11) 评论(0) 编辑收藏举报

刷新页面返回顶部

Nones

【go】【mongo】

写在前面

[install]

[connection]

create many

create delete one

delete many

update one

update many

find one

find many Next

find many All

find many filter

建立索引

查询单条索引

查询全部索引

创建索引

查询全部索引

分页索引

正则表达

索引检索

mongo bson 动态数据 难度

参考资料

基础/标准库/第三方库

golang 导航

编程规范

算法｜面试

项目

公告

mongo bson 动态数据 `难度`

`基础/标准库/第三方库`

`golang 导航`

`编程规范`

`算法｜面试`

`项目`