Docs 菜单
Docs 主页
/
语言
/
Go
/
Go 驱动程序
/
Fundamentals
/
增删改查操作
/
读取操作

指定查询

在此页面上

  • Overview
  • 字面值
  • 对比
  • 逻辑
  • 元素
  • 求值
  • 阵列
  • Bitwise
  • 更多信息

Overview

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

要匹配文档子集，请指定包含匹配条件的查询筛选器。匹配条件由您希望在文档中显示的字段和值组成。查询筛选器至少包含一组匹配条件，用于确定结果集中包含哪些文档。

在查询筛选条件中，您可以匹配带有字面值或查询操作符的字段。查询操作符允许您执行数学或逻辑运算来查找集合中的文档。

将条件与字面值匹配使用以下格式：

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 操作则会匹配集合中的所有文档。

例子

以下示例匹配 type 为“Oolong”的文档：

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。

例子

以下示例匹配 rating 小于 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（其中，所有匹配条件均须为 true）和 $or（其中，至少一个匹配条件必须为 true）。

例子

以下示例匹配 rating 大于 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，前者字段值必须与指定的正则表达式匹配，后者字段值必须包含指定的字符串。

例子

以下示例匹配 type 以字母“E”开头的文档：

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"]}

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

阵列

数组操作符检查数组字段中元素的值或数量。

例子

以下示例可与 vendor 包含“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"]}

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

Bitwise

按位操作符将数值字段从以 10 为基数（十进制）的数字转换为以 2 为基数（二进制）的数字。它们检查文档中的值是否具有与匹配条件中的值相同的位设置。

例子

以下示例匹配 rating 具有与 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 文档：

后退

读取操作

来年

计算文档