“文档” 菜单
文档首页
/
MongoDB 阿特拉斯
/
Atlas Search
/
创建和运行查询
/
创建查询
/
2. 使用操作符和收集器

多个子句

在此页面上

  • 定义
  • 语法
  • 选项
  • 使用
  • 评分行为
  • 举例

定义

compound

compound操作符将两个或多个操作符组合到一个查询中。 compound查询的每个元素称为子句，每个子句由一个或多个子查询组成。 Atlas Search 提供了带有指导的示例复合查询模板。要了解详情，请参阅查看查询指导模板。

语法

compound 通过以下语法实现：

1{
2  $search: {
3    "index": <index name>, // optional, defaults to "default"
4    "compound": {
5      <must | mustNot | should | filter>: [ { <clauses> } ],
6      "score": <options>
7    }
8  }
9}

每个 must、mustNot、should 和 filter 子句都包含一个子句数组。即使数组只包含一个子句，也仍然使用数组语法。请参阅本页的示例。

选项

compound 使用以下词条来构造查询：

must

要将文档包含在结果中必须匹配的子句。返回的分数是子句中所有子查询的分数总和。

映射到 AND 布尔操作符。

mustNot

要将文档包含在结果中必须不能匹配的子句。mustNot 子句对返回文档的分数没有贡献。

映射到 AND NOT 布尔操作符。

should

您希望与结果所包含文档匹配的子句。与不包含 should 子句的文档相比，包含 should 子句匹配项的文档得分更高。返回的分数是子句中所有子查询的分数总和。

如果使用多个 should 子句，则可以使用 minimumShouldMatch 选项指定必须匹配的最低数量 should 子句才能将文档包含在结果中。如果省略，则 minimumShouldMatch 选项默认为 0。

请参阅示例。

映射到 OR 布尔操作符。

如果在复合查询中只使用了 should 子句，compound 操作符会将 should 子句的查询数组视为逻辑 OR。Atlas Search 必须找到至少一个 should 个条件的匹配项才能返回任何结果。当您指定多个 should 子句条件并将 minimumShouldMatch 选项设为 0 时，Atlas Search 会将 minimumShouldMatch 视为已设为 1，并且必须匹配至少一个条件才能返回任何结果。

filter

要将文档包含在结果中必须全部匹配的子句。filter 子句对返回文档的分数没有贡献。

例子

例如，您可以在 $search 阶段用 compound 操作符 filter 条件替换 $match 阶段：

{
  "$match": {
    "role": { "$in": [ "CLIENT", "PROFESSIONAL" ] }
  }
}

您可以用 filter 选项代替：

$search: {
  "compound": {
    "filter": [{
      "queryString": {
        "defaultPath": "role",
        "query": "CLIENT OR PROFESSIONAL"
      }
    }]
  }
}

请参阅另一过滤示例。

score
修改整个 compound 子句的分数。 您可以使用score来提高、替换或以其他方式更改分数。如果不指定score ，则返回的分数是生成匹配项的must和should子句中所有子查询的分数之和。要了解更多信息，请参阅评分行为。

使用

您可以使用任何带有任何顶层操作符（例如自动完成、文本或跨度）的子句来指定查询条件。

评分行为

通过文档在文档上生成匹配项的每个子句获得的分数求和，Atlas Search 对结果集中的文档进行评分。 只有must和should子句参与评分。结果集按分数从最高到最低排序。

下表显示了影响和不影响分数的 compound子句。

子句
影响分数
对分数没有贡献
filter
must
mustNot
should

您可以用 score 选项提高或替换整个复合查询的分数。有关替换整个复合分数的示例，请参阅下面的 复合分数示例 。您还可以用分数来提高或更改每个子句中每个子查询的分数。有关 compound 操作符子句中已更改分数的部分示例，请参阅修改分数。

举例

您可以在 Atlas Search Playground 或 Atlas 集群中尝试以下示例。

样本集合

本页上的示例使用名为 fruit 的集合，其中包含以下文档：

1{
2  "_id" : 1,
3  "type" : "apple",
4  "description" : "Apples come in several varieties, including Fuji, Granny Smith, and Honeycrisp.",
5  "category" : "nonorganic",
6  "in_stock" : false
7},
8{
9  "_id" : 2,
10  "type" : "banana",
11  "description" : "Bananas are usually sold in bunches of five or six.",
12  "category" : "nonorganic",
13  "in_stock" : true
14},
15{
16  "_id" : 3,
17  "type" : "pear",
18  "description" : "Bosc and Bartlett are the most common varieties of pears.",
19  "category" : "organic",
20  "in_stock" : true
21}

样本索引

fruit集合具有带动态映射的默认索引，该索引会自动为集合中的所有字段编制索引并使用默认的标准分析器。 standard分析器将所有单词转为小写并忽略常见的停用词（ "the", "a", "and",等）。

样本查询

以下查询演示了 Atlas Search 查询中的$search compound操作符。

must 和mustNot 示例

以下示例使用 must 和 mustNot 子句的组合来构建查询。must 子句使用文本操作符在 description 字段中搜索术语 varieties。要匹配文档，它必须满足 must 子句。mustNot 子句对 description 字段中的术语 apples 执行搜索操作。要匹配文档，它必须不满足 mustNot 子句。

1db.fruit.aggregate([
2  {
3    "$search": {
4      "compound": {
5        "must": [{
6          "text": {
7            "query": "varieties",
8            "path": "description"
9          }
10        }],
11        "mustNot": [{
12          "text": {
13            "query": "apples",
14            "path": "description"
15          }
16        }]
17      }
18    }
19  }
20])

上述查询返回的文档包含 _id: 3，因为其 description 字段包含单词 varieties，而不包含 apples。

➤ 尝试 Atlas Search Playground 中的示例。

must 和should 示例

以下查询使用 must 指定必须满足的搜索条件，使用 should 指定优先搜索包含单词 Fuji 的文档。

minimumShouldMatch 示例

在包含多个 should 子句的查询中，可以使用 miniumumShouldMatch 选项来指定必须匹配才能返回结果的最小子句数。

下面的查询有一个 must 子句和两个 should 子句，minimumShouldMatch 值为 1。文档必须在 description 字段中包含术语 varieties，必须在描述字段中包含 Fuji 或 Golden Delicious，才能被包含在结果集中。

1db.fruit.aggregate([
2  {
3    $search: {
4      "compound": {
5        "must": [{
6          "text": {
7             "query": "varieties",
8             "path": "description"
9          }
10        }],
11        "should": [{
12          "text": {
13            "query": "Fuji",
14            "path": "description"
15          }
16        },
17        {
18          "text": {
19            "query": "Golden Delicious",
20            "path": "description"
21          }
22        }],
23        "minimumShouldMatch": 1
24      }
25    }
26  }
27])

带有 _id: 1 的文档匹配 must 子句和两个 should 子句中的第一个。

➤ 尝试 Atlas Search Playground 中的示例。

filter 举例

filter 其行为与must相同，但返回文档的分数中不考虑filter子句，因此不会影响返回文档的顺序。

嵌套示例

以下示例使用嵌套的 compound 子句构造查询。对于此示例，fruit 集合具有针对 type、category 和 in_stock 字段的索引，且其文本字段使用默认分析器。此查询要求文档仅满足以下 should 子句之一：

  • 在 type 字段中包含单词 apple。

  • 在 category 字段中包含 organic 一词，并在 in_stock 字段中使用值 true。

1db.fruit.aggregate([
2  {
3    $search: {
4      "compound": {
5        "should": [
6          {
7            "text": {
8              "query": "apple",
9              "path": "type"
10            }
11          },
12          {
13            "compound": {
14              "must": [
15                {
16                  "text": {
17                    "query": "organic",
18                    "path": "category"
19                  }
20                },
21                {
22                  "equals": {
23                    "value": true,
24                    "path": "in_stock"
25                  }
26                }
27              ]
28            }
29          }
30        ],
31        "minimumShouldMatch": 1
32      }
33    }
34  }
35])

结果中的文档满足所有包含要求：

  • _id: 3 的文档与嵌套在第二个 should 子句中的 must 子句匹配。

  • _id: 1 的文档与第一个 should 子句匹配。

➤ 尝试 Atlas Search Playground 中的示例。

← 自动补全
嵌入式文档 →

在此页面上