compound 演算子

must and mustNot Example

次の例では、must 句と mustNot 句の組み合わせを使用してクエリを構築します。must 句はテキスト演算子を使用して、description フィールド内の varieties というタームを検索します。ドキュメントが一致するには、must 句を満たす必要があります。mustNot 句は、description フィールド内の apples というタームの検索操作を実行します。ドキュメントが一致するには、mustNot 句を満たさない必要があります。

1
db.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
])

上記のクエリでは、description フィールドに varieties という単語が含まれ、apples が含まれていないため、_id: 3 を含むドキュメントが返されます。

➤ MongoDB Search Playground でこれを試してみてください。

must and should Example

次のクエリでは、must を使用して満たす必要のある検索条件を指定し、should を使用して Fuji という単語を含むドキュメントの優先設定を指定します。

1
db.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
    }
19
  },
20
  {
21
    "$project": {
22
      "score": { "$meta": "searchScore" }
23
    }
24
  }
25
])

{ "_id" : 1, "score" : 0.6425117254257202 }
{ "_id" : 3, "score" : 0.21649497747421265 }

1
db.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
        "score": { "constant": { "value": 3 } }
18
      }
19
    }
20
  },
21
  {
22
    "$project": {
23
      "score": { "$meta": "searchScore" }
24
    }
25
  }
26
])

[ { _id: 1, score: 3 }, { _id: 3, score: 3 } ]

minimumShouldMatch の例

複数の should 句を含むクエリでは、miniumumShouldMatch オプションを使用して、結果を返すために一致する必要がある句の最小数を指定できます。

次のクエリには must 句が 1 つと should 句が 2 つあり、minimumShouldMatch の値は 1 です。結果セットに含めるには、ドキュメントの description フィールドに varieties というタームが含まれている必要があり、説明フィールドに Fuji または Golden Delicious のいずれかが含まれている必要があります。

1
db.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
])

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
}

_id: 1 の一致を含むドキュメントは、must 句と 2 つの should 句のうちの最初の句と一致します。

➤ MongoDB Search Playground でこれを試してみてください。

filter 例

filter filter 句は返されたドキュメントのスコアには考慮されないため、返されるドキュメントの順序に影響しないことを除いて must と同じように動作します。

1
db.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": "banana",
14
            "path": "description"
15
          }
16
        }],
17
        "filter": [{
18
          "text": {
19
            "query": "granny",
20
            "path": "description"
21
          }
22
        }]
23
      }
24
    }
25
  }
26
])

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
}

1
db.fruit.aggregate([
2
  {
3
    "$search": {
4
      "compound": {
5
        "filter": [{
6
          "text": {
7
            "query": ["apples", "bananas"],
8
            "path": "description"
9
          }
10
        }],
11
        "should": [{
12
          "text": {
13
            "query": "varieties",
14
            "path": "description"
15
          }
16
        }]
17
      }
18
    }
19
  },
20
  {
21
    "$project": {
22
      "description": 1,
23
      "score": { "$meta": "searchScore" }
24
    }
25
  }
26
])

1
[
2
  {
3
    _id: 1,
4
    description: 'Apples come in several varieties, including Fuji, Granny Smith, and Honeycrisp. The most popular varieties are McIntosh, Gala, and Granny Smith.',
5
    score: 0.36074575781822205
6
  },
7
  {
8
    _id: 2,
9
    description: 'Bananas are usually sold in bunches of five or six.',
10
    score: 0
11
  }
12
]

ネストされた例

次の例では、ネストされた compound 句を使用してクエリを構築します。この例では、fruit コレクションには type、 category、および in_stock のフィールドにインデックスがあり、そのテキスト フィールドではデフォルトのアナライザが使用されます。クエリでは、ドキュメントが次の should 句のいずれか 1 つだけを満たす必要があります。

• type フィールドに apple という単語を含めます。

• category フィールドに organic というタームが含まれ、in_stock フィールドに true という値が含まれます。

1
db.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
])

1
{
2
  "_id" : 3,
3
  "type" : "pear",
4
  "description" : "Bosc and Bartlett are the most common varieties of pears.",
5
  "category" : "organic",
6
  "in_stock" : true
7
}
8
{
9
  "_id" : 1,
10
  "type" : "apple",
11
  "description" : "Apples come in several varieties, including Fuji, Granny Smith, and Honeycrisp.",
12
  "category" : "nonorganic",
13
  "in_stock" : false
14
}

結果に含まれるドキュメントは、含まれるためのすべての要件を満たしています。

• _id: 3 のあるドキュメントは、2 番目の should 句内にネストされている must 句と一致します。

• _id: 1 のあるドキュメントは最初の should 句に一致します。

➤ MongoDB Search Playground でこれを試してみてください。

メタデータの例

次のクエリはメタデータを検索し、$searchMetaパイプラインステージ、または$searchステージの$$SEARCHMETA変数のいずれかを使用して、fruitコレクションのカテゴリの数を返します。

db.fruit.aggregate([
  {
    "$searchMeta": {
      "facet": {
        "operator": {
          "compound": {
            "must": [{
              "text": {
                "query": "varieties",
                "path": "description"
              }
            }],
            "should": [{
              "text": {
                "query": "Fuji",
                "path": "description"
              }
            }]
          }
        },
        "facets": {
          "categoryFacet": {
            "type": "string",
            "path": "category"
          }
        }
      }
    }
  }
])

[
  {
    count: { lowerBound: Long('2') },
    facet: {
      categoryFacet: {
        buckets: [
          { _id: 'nonorganic', count: Long('1') },
          { _id: 'organic', count: Long('1') }
        ]
      }
    }
  }
]

db.fruit.aggregate([
  {
    "$search": {
      "facet": {
        "operator": {
          "compound": {
            "must": [{
              "text": {
                "query": "varieties",
                "path": "description"
              }
            }],
            "should": [{
              "text": {
                "query": "Fuji",
                "path": "description"
              }
            }]
          }
        },
        "facets": {
          "categoryFacet": {
            "type": "string",
            "path": "category"
          }
        }
      }
    }
  },
  { "$limit": 2 },
  {
    "$facet": {
      "docs": [
        { "$project":
          {
            "type": 1,
            "description": 1
          }
        }
      ],
      "meta": [
        {"$replaceWith": "$$SEARCH_META"},
        {"$limit": 1}
      ]
    }
  },
  {
    "$set": {
      "meta": {
        "$arrayElemAt": ["$meta", 0]
      }
    }
  }
])

[
  {
    docs: [
      {
        _id: 1,
        type: 'apple',
        description: 'Apples come in several varieties, including Fuji, Granny Smith, and Honeycrisp.'
      },
      {
        _id: 3,
        type: 'pear',
        description: 'Bosc and Bartlett are the most common varieties of pears.'
      }
    ],
    meta: {
      count: { lowerBound: Long('2') },
      facet: {
        categoryFacet: {
          buckets: [
            { _id: 'nonorganic', count: Long('1') },
            { _id: 'organic', count: Long('1') }
          ]
        }
      }
    }
  }
]