golang使用mongo-driver操作——查（数组相关）

数组的查稍微有点不同，篇幅原因，分开来写。

需要完全一样才能匹配到，包括元素的顺序。且演示输出时转化成字符串形式：

// 最基本的查询数组相关数据，下面数组的匹配，需要完全一样才能匹配到，包括元素的顺序
// 参考：https://www.mongodb.com/docs/manual/tutorial/query-arrays/
func Array(mongo *mongo.Database, ctx context.Context) {
	stringlist := []string{"test1", "test2", "test3"}
	findFilter := bson.M{"stringlist": stringlist}
	result := mongo.Collection("test").FindOne(ctx, findFilter)
	// 转化成string输出
	rawByte, _ := result.DecodeBytes()
	fmt.Println(rawByte.String())
}
1
2
3
4
5
6
7
8
9
10

用all关键字实现：查询数组中包含以下元素，且与顺序无关的查询。遍历结果时可以转化成只包含值而不包含key的数组：

func ArrayAll(mongo *mongo.Database, ctx context.Context) {
	stringlist := []string{"test3", "test2"}
	findFilter := bson.M{"stringlist": bson.M{"$all": stringlist}}
	result := mongo.Collection("test").FindOne(ctx, findFilter)
	// 将文档的字段的值转化成数组，然后逐个输出,这种方式仅包含值，而没有键
	rawByte, _ := result.DecodeBytes()
	rawV, _ := rawByte.Values()
	for i := 0; i < len(rawV); i++ {
		fmt.Println("rawV:", rawV[i])
	}
}
1
2
3
4
5
6
7
8
9
10
11

数组类型的字段后面对应一个值，表明是查询数组中是否包含该元素。遍历结果时转化成键值对的数组形式：

// 数组类型的字段后面对应一个值，表明是查询数组中是否包含该元素
func ArrayAtLeastOne(mongo *mongo.Database, ctx context.Context) {
	// 还可以使用gte等关键字去匹配是否有大于小于某值的元素
	findFilter := bson.M{"stringlist": "test3"}
	result := mongo.Collection("test").FindOne(ctx, findFilter)
	// 将文档的字段转化成数组，然后逐个输出，这种方式是键值对的形式
	rawByte, _ := result.DecodeBytes()
	rawV, _ := rawByte.Elements()
	for i := 0; i < len(rawV); i++ {
		fmt.Println("rawV:", rawV[i])
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

多个条件的查询和我们正常的理解不太一样，结果还可以按数组下标去取：

// 有多个条件时的查询
func ArrayGtAndLt(mongo *mongo.Database, ctx context.Context) {
	// 这两个条件,不需要都作用到同一个元素身上，只要有某个元素大于20，且有某个元素小于10，所以下面语句可以查出多条记录
	findFilter := bson.M{"intlist": bson.M{"$gt": 20, "$lt": 10}}
	cur, err := mongo.Collection("test").Find(ctx, findFilter)
	if err != nil {
		fmt.Println("err")
	}
	// 遍历数据
	for cur.TryNext(ctx) {
		// 这种方式是转化成数组后，用数组下标去取数据，输出是键值对形式
		result := cur.Current.Index(0)
		fmt.Println(result)
	}
	cur.Close(ctx)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

下面这种多条件查询才和我们正常的理解差不多。结果还可以用key去取值：

// 和上面这种方法正好相反，必须得有元素同时满足所有条件，才算查询成功
func ArrayElemMatch(mongo *mongo.Database, ctx context.Context) {
	// 需要有某个元素同时满足两个条件才可，不可能有元素满足大于20小于10，所以查询会失败
	findFilter := bson.M{"intlist": bson.M{"$elemMatch": bson.M{"$gt": 20, "$lt": 10}}}
	cur, err := mongo.Collection("test").Find(ctx, findFilter)
	if err != nil {
		fmt.Println("err")
	}
	// 遍历数据
	for cur.TryNext(ctx) {
		// 这种方式是转化成数组后，用key值去取数据，输出对应的值
		result := cur.Current.Lookup("intlist")
		fmt.Println(result)
	}
	cur.Close(ctx)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

按照数组长度查询，结果还可以用Lookup取嵌套文档的键值

// 按数组长度查询
func ArraySize(mongo *mongo.Database, ctx context.Context) {
	// 需要有某个元素同时满足两个条件才可，不可能有元素满足大于20小于10，所以查询会失败
	findFilter := bson.M{"intlist": bson.M{"$size": 11}}
	cur, err := mongo.Collection("test").Find(ctx, findFilter)
	if err != nil {
		fmt.Println("err")
	}
	// 遍历数据
	for cur.TryNext(ctx) {
		// 还可以有多个key，这些key是层次关系的，先获取键object的值，然后再从值里面找键id的值，非常方便我们获取深层嵌套的数据
		result := cur.Current.Lookup("object", "id")
		fmt.Println(result)
	}
	cur.Close(ctx)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

查询不包含元素的数组：

	// 查询不包括0 和7的数组，特别注意，如果文档中就没有intlist字段，也满足条件
	findFilter := bson.M{"intlist": bson.M{"$nin": bson.A{0, 7}}}
1
2

// 数组的查询还可以用点加下标，如.0:对比下标为0的元素是否满足条件：

	// 查询数组的第1个元素是否大于5
	findFilter := bson.M{"intlist.0": bson.M{"$gt": 5}}
1
2

指定仅查询数组的第N个元素：

func ArrayElement(mongo *mongo.Database, ctx context.Context) {
	filter := bson.M{} // 空结构体匹配所有
	// 用slice关键指定查询第N个元素，-1表示查询最后一个元素
	options := options.FindOptions{Projection: bson.M{"intlist": bson.M{"$slice": -1}, "_id": 0}}
	cur, err := mongo.Collection("test").Find(ctx, filter, &options)
	if err != nil {
		fmt.Println("err")
	}
	// 遍历数据
	for cur.TryNext(ctx) {
		result, _ := cur.Current.LookupErr("intlist")
		fmt.Println(result)
	}
	cur.Close(ctx)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16