指定查询

本页

概述

文字值
比较
逻辑
元素
评估
数组
位运算
附加信息

概述

在本指南中，您可以学习如何指定查询以匹配文档的子集。

要匹配文档的子集，请指定包含您的匹配条件的查询过滤器。匹配条件包括您希望在文档中存在的字段和值。查询过滤器包含至少一组匹配条件，以确定要包含在结果集中的文档。

在查询过滤器中，您可以使用文字值或使用查询运算符来匹配字段。查询运算符允许您执行数学或逻辑运算，以定位集合中的文档。

使用文字值的匹配条件采用以下格式

filter := bson.D{{"<field>", "<value>"}}

使用查询运算符的匹配条件采用以下格式

filter := bson.D{{"<field>", bson.D{{"<operator>", "<value>"}}}}

以下部分使用文字值和查询运算符与Find()方法来匹配文档的子集。

示例数据

本节中的示例使用以下Tea结构体作为tea集合中文档的模型

type Tea struct {
	Type   string
	Rating int32
	Vendor []string `bson:"vendor,omitempty" json:"vendor,omitempty"`
}

omitempty结构体标签在为插入的文档省略相应的字段时留空。

要运行本指南中的示例，请使用以下代码片段将示例数据加载到db数据库中tea集合

coll := client.Database("db").Collection("tea")
docs := []interface{}{
	Tea{Type: "Masala", Rating: 10, Vendor: []string{"A", "C"}},
	Tea{Type: "English Breakfast", Rating: 6},
	Tea{Type: "Oolong", Rating: 7, Vendor: []string{"C"}},
	Tea{Type: "Assam", Rating: 5},
	Tea{Type: "Earl Grey", Rating: 8, Vendor: []string{"A", "B"}},
}
result, err := coll.InsertMany(context.TODO(), docs)

提示

不存在的数据库和集合

在执行写操作时，如果所需的数据库和集合不存在，服务器会隐式创建它们。

每个文档描述了一种茶类型、其评分以及携带该品种的供应商。这些项目对应于type、rating和vendor字段。

文字值

文字值查询过滤器返回与匹配条件完全匹配的文档。

提示

如果指定一个空的查询过滤器，CRUD操作将匹配集合中的所有文档。

示例

以下示例匹配类型为“乌龙”的文档

filter := bson.D{{"type", "Oolong"}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
    panic(err)
}
var results []Tea
if err = cursor.All(context.TODO(), &results); err != nil {
    panic(err)
}
for _, result := range results {
    res, _ := bson.MarshalExtJSON(result, false, false)
    fmt.Println(string(res))
}

{"type":"Oolong","rating":7,"vendor":["C"]}

提示

文字值查询返回与$eq比较运算符相同的值。例如，以下查询过滤器产生相同的结果

filter := bson.D{{"type", "Oolong"}}

filter := bson.D{{"type", bson.D{{"$eq", "Oolong"}}}}

比较

比较运算符分析文档中的值与您匹配条件中指定的值。常见的比较运算符包括 $gt 用于“大于”比较，$lte 用于“小于或等于”比较，以及 $ne 用于“不等于”比较。

示例

以下示例匹配评分小于 7 的文档

filter := bson.D{{"rating", bson.D{{"$lt", 7}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []Tea
if err = cursor.All(context.TODO(), &results); err != nil {
    panic(err)
}
for _, result := range results {
    res, _ := bson.MarshalExtJSON(result, false, false)
    fmt.Println(string(res))
}

{"type":"English Breakfast","rating":6}
{"type":"Assam","rating":5}

有关比较运算符的完整列表，请参阅比较查询运算符页面。

逻辑

逻辑运算符至少需要两个匹配条件。它们检查文档是否满足所有、至少一个或没有任何指定的条件。常见的逻辑运算符包括 $and，其中所有匹配条件都必须为真，以及 $or，其中至少有一个匹配条件必须为真。

示例

以下示例匹配评分大于 7 且小于或等于 10 的文档。

filter := bson.D{
   {"$and",
      bson.A{
         bson.D{{"rating", bson.D{{"$gt", 7}}}},
         bson.D{{"rating", bson.D{{"$lte", 10}}}},
      },
   },
}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []Tea
if err = cursor.All(context.TODO(), &results); err != nil {
    panic(err)
}
for _, result := range results {
    res, _ := bson.MarshalExtJSON(result, false, false)
    fmt.Println(string(res))
}

{"type":"Masala","rating":10,"vendor":["A","C"]}
{"type":"Earl Grey","rating":8,"vendor":["A","B"]}

有关逻辑运算符的完整列表，请参阅逻辑查询运算符页面。

提示

在文本查询中类似于 $eq 比较运算符的多个匹配条件返回与 $and 逻辑运算符相同的结果。例如，以下查询结果相同

filter := bson.D{{"type", "Oolong"}, {"rating", 7}}

filter := bson.D{
  {"$and",
    bson.A{
      bson.D{{"type", "Oolong"}},
      bson.D{{"rating", 7}},
    }},
}

元素

元素运算符检查指定字段的是否存在或类型。

示例

以下示例匹配不存在 vendor 字段的文档。

filter := bson.D{{"vendor", bson.D{{"$exists", false}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []Tea
if err = cursor.All(context.TODO(), &results); err != nil {
    panic(err)
}
for _, result := range results {
    res, _ := bson.MarshalExtJSON(result, false, false)
    fmt.Println(string(res))
}

{"type":"English Breakfast","rating":6}
{"type":"Assam","rating":5}

要查看元素运算符的完整列表，请参阅元素查询运算符页面。

评估

评估运算符根据您在匹配条件中指定的值分析文档中的值。常见的评估运算符包括 $regex，其中字段的值必须匹配指定的正则表达式，以及 $text，其中字段的值必须包含指定的字符串。

示例

以下示例匹配以字母 "E" 开头的 type 文档。

filter := bson.D{{"type", bson.D{{"$regex", "^E"}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []Tea
if err = cursor.All(context.TODO(), &results); err != nil {
    panic(err)
}
for _, result := range results {
    res, _ := bson.MarshalExtJSON(result, false, false)
    fmt.Println(string(res))
}

{"type":"English Breakfast","rating":6}
{"type":"Earl Grey","rating":8,"vendor":["A","B"]}

要查看评估运算符的完整列表，请参阅评估查询运算符页面。

数组

数组运算符检查数组字段的值或元素的数量。

示例

以下示例匹配包含 "C" 的 供应商 的文档。

filter := bson.D{{"vendor", bson.D{{"$all", bson.A{"C"}}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []Tea
if err = cursor.All(context.TODO(), &results); err != nil {
    panic(err)
}
for _, result := range results {
    res, _ := bson.MarshalExtJSON(result, false, false)
    fmt.Println(string(res))
}

{"type":"Masala","rating":10,"vendor":["A","C"]}
{"type":"Oolong","rating":7,"vendor":["C"]}

有关数组运算符的完整列表，请参阅数组查询运算符页面。

位运算

位运算符将数值字段从十进制（基数-10）转换为对应的二进制（基数-2）。它们检查文档中的值是否与匹配条件中的值具有相同的位。

示例

以下示例匹配具有与 6（即 "00000110"）相同的位的 评分 的文档。

filter := bson.D{{"rating", bson.D{{"$bitsAllSet", 6}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []Tea
if err = cursor.All(context.TODO(), &results); err != nil {
    panic(err)
}
for _, result := range results {
    res, _ := bson.MarshalExtJSON(result, false, false)
    fmt.Println(string(res))
}

{"type":"English Breakfast","rating":6}
{"type":"Oolong","rating":7,"vendor":["C"]}

有关位运算符的完整列表，请参阅位查询运算符页面。

附加信息

有关指定地理查询的信息，请参阅《地理数据》指南地理数据。

API 文档

要了解更多关于本指南中使用的方法或类型的信息，请参阅以下API文档

后退

读取

计算文档数量