Construct a Query Path

For the complete MongoDB documentation index, see www.mongodb.com/docs/llms.txt

Construct a Query Path

Overview

The path parameter is used by the MongoDB Search [operators](https://www.mongodb.com/docs/search/query/operators-collectors/overview.md#std-label-fts-operators to specify the field or fields to be searched. It may contain:

  • A string

  • An array of strings

  • A [multi analyzer](https://www.mongodb.com/docs/search/indexes/analyzers/multi.md#std-label-ref-multi-analyzers specification

  • An array containing a combination of strings and multi analyzer specifications

Note:

Not all operators can use all the different types of paths. See the documentation for each individual operator for details on what types of path it supports.

Usage

To search only a single indexed field, use a quoted string in the path parameter. The following example searches a field named description.

"path": "description"

To search multiple indexed fields, use an array of quoted strings in the path parameter. Documents which match on any of the specified fields are included in the result set. The following example searches the description and type fields.

"path": [ "description", "type" ]

Note:

The multi path option is available only to fields of type [string.](https://www.mongodb.com/docs/search/indexes/field-types/string-type.md#std-label-bson-data-types-string

If your [index definition](https://www.mongodb.com/docs/search/indexes/define-field-mappings.md#std-label-index-config-example contains a field with multiple analyzers, you can specify which one to use. The path parameter can take an object with the following fields:

Field Description
value The name of the field to search.
multi The name of the alternate analyzer specified in a multi object in an index definition. To learn more, see [Multi Analyzer.](https://www.mongodb.com/docs/search/indexes/analyzers/multi.md#std-label-ref-multi-analyzers
wildcard The object containing the wildcard character * to match any character in the name of the field to search, including nested fields. A wildcard path: Must be defined as an object.; Cannot contain the value or multi option.; Cannot contain multiple consecutive wildcard characters such as **. Wildcard path is only accepted by the following operators: [phrase](https://www.mongodb.com/docs/search/query/operators-collectors/phrase.md#std-label-phrase-ref; [regex](https://www.mongodb.com/docs/search/query/operators-collectors/regex.md#std-label-regex-ref; [text](https://www.mongodb.com/docs/search/query/operators-collectors/text.md#std-label-text-ref; [wildcard](https://www.mongodb.com/docs/search/query/operators-collectors/wildcard.md#std-label-wildcard-ref Wildcard path is also accepted for [highlighting.](https://www.mongodb.com/docs/search/query/highlighting.md#std-label-highlight-ref

In the following index definition, fields named names and notes use the [standard](https://www.mongodb.com/docs/search/indexes/analyzers/standard.md#std-label-ref-standard-analyzer analyzer. A field named comments uses standard as its default analyzer, and it also specifies a multi named mySecondaryAnalyzer which uses the [lucene.whitespace](https://www.mongodb.com/docs/search/indexes/analyzers/whitespace.md#std-label-ref-whitespace-analyzer analyzer.

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "names": {
        "type": "string",
        "analyzer": "lucene.standard"
      },
      "notes": {
        "type": "string",
        "analyzer": "lucene.standard"
      },
      "comments": {
        "type": "string",
        "analyzer": "lucene.standard",
        "multi": {
          "mySecondaryAnalyzer": {
            "analyzer": "lucene.whitespace",
            "type": "string"
          }
        }
      }
    }
  }
}

The following path example searches the comments field using the multi named mySecondaryAnalyzer in the index definition.

"path": { "value": "comments", "multi": "mySecondaryAnalyzer" }

To search a combination of indexed fields and fields with multiple analyzers, use an array. The following example searches the names and notes fields with the default analyzer, and the comments field using the multi named mySecondaryAnalyzer in the index definition.

"path": [ "names", "notes", { "value": "comments", "multi": "mySecondaryAnalyzer" } ]

The following path example searches all the fields that contain the letter n followed by any characters, and the comments field using the multi named mySecondaryAnalyzer in the index definition.

"path": [{ "wildcard": "n*" }, { "value": "comments", "multi": "mySecondaryAnalyzer" }]

Examples

The following examples use a collection named cars which has the following documents:

{
  "_id" : 1,
  "type" : "sedan",
  "make" : "Toyota",
  "description" : "Blue four-door sedan, lots of trunk space. Three
  to four passengers."
}
{
  "_id" : 2,
  "type" : "coupe",
  "make" : "BMW",
  "description" : "Red two-door convertible, driver's-side airbag."
}
{
  "_id" : 3,
  "type" : "SUV",
  "make" : "Ford",
  "description" : "Black four-door SUV, three rows of seats."
}

[Static field mappings](https://www.mongodb.com/docs/search/indexes/define-field-mappings.md#std-label-static-dynamic-mappings allow you to specify how individual fields within a collection should be indexed and searched.

The index definition for the cars collection is as follows:

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "make": {
        "type": "string",
        "analyzer": "lucene.standard"
      },
      "description": {
        "type": "string",
        "analyzer": "lucene.standard",
        "multi": {
          "simpleAnalyzer": {
            "analyzer": "lucene.simple",
            "type": "string"
          }
        }
      }
    }
  }
}

The preceding index definition specifies that the make field is indexed with the [standard analyzer](https://www.mongodb.com/docs/search/indexes/analyzers/standard.md#std-label-ref-standard-analyzer. The description field uses the standard analyzer by default, but it can also use the [simple analyzer](https://www.mongodb.com/docs/search/indexes/analyzers/simple.md#std-label-ref-simple-analyzer by specifying simpleAnalyzer with the multi parameter.

The following example searches for the string Ford in the make field:

db.cars.aggregate([
  {
    $search: {
      "text": {
        "query": "Ford",
        "path": "make"
      }
    }
  }
])

The preceding example returns the document with _id: 3.

The following example uses an array of fields in the path parameter to search for the string blue in either the make or the description field.

db.cars.aggregate([
  {
    $search: {
      "text": {
        "query": "blue",
        "path": [ "make", "description" ]
      }
    }
  }
])

The preceding query returns the following result:

{
  "_id" : 1,
  "type" : "sedan",
  "make" : "Toyota",
  "description" : "Blue four-door sedan, lots of trunk space. Three to four
  passengers."
}

Simple Analyzer Example

The following example uses the multi named simpleAnalyzer in the index definition, which uses the [simple analyzer.](https://www.mongodb.com/docs/search/indexes/analyzers/simple.md#std-label-ref-simple-analyzer

The query searches the description field for the string driver.

db.cars.aggregate([
  {
    $search: {
      "text": {
        "query": "driver",
        "path": { "value": "description", "multi": "simpleAnalyzer" }
      }
    }
  }
])

The preceding query returns the following result:

{
  "_id" : 2,
  "type" : "coupe",
  "make" : "BMW",
  "description" : "Red two-door convertible, driver's-side airbag."
}

The [simple analyzer](https://www.mongodb.com/docs/search/indexes/analyzers/simple.md#std-label-ref-simple-analyzer indexes driver's side airbag as [driver s side airbag], so it matches on driver.

By contrast, the default [standard analyzer](https://www.mongodb.com/docs/search/indexes/analyzers/standard.md#std-label-ref-standard-analyzer indexes driver's side airbag as [driver's side airbag], so it would match on driver's or side but not driver.

Whitespace Analyzer Example

Suppose the multi object in the index definition for the cars collection is the following:

"multi": {
  "simpleAnalyzer": {
    "analyzer": "lucene.whitespace",
    "type": "string"
  }
}

The following example uses the multi named simpleAnalyzer in the index definition, which uses the [whitespace analyzer.](https://www.mongodb.com/docs/search/indexes/analyzers/whitespace.md#std-label-ref-whitespace-analyzer

db.cars.aggregate([
  {
    $search: {
      "text": {
        "query": "Three",
        "path": { "value": "description", "multi": "simpleAnalyzer" }
      }
    }
  }
])

The preceding query returns the following result:

{
  "_id" : 1,
  "type" : "sedan",
  "make" : "Toyota",
  "description" : "Blue four-door sedan, lots of trunk space. Three to
  four passengers."
}

For the above query on the term Three, MongoDB Search only returns documents matching the term Three and not three becuase the [whitespace analyzer](https://www.mongodb.com/docs/search/indexes/analyzers/simple.md#std-label-ref-simple-analyzer is case-sensitive. By contrast, the default [standard analyzer](https://www.mongodb.com/docs/search/indexes/analyzers/standard.md#std-label-ref-standard-analyzer is not case-sensitive and returns all documents matching the term in the query in the order that they are listed in the collection.

Now, consider the following query:

db.cars.aggregate([
  {
    $search: {
      "compound": {
        "should": [
          {
            "text": {
              "path": "description",
              "query": "Three"
            }
          },
          {
            "text": {
              "query": "Three",
              "path": { "value" : "description", "multi" : "simpleAnalyzer" },
              score: { boost: { value: 2 }}
            }
          }
        ]
      }
    }
  },
  {
    $project: {
      "_id": 0,
      "type": 1,
      "description": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])

The preceding query returns the following results:

{
  "type" : "sedan",
  "description" : "Blue four-door sedan, lots of trunk space. Three to four passengers seats.",
  "score" : 1.1092689037322998
}
{
  "type" : "SUV",
  "description" : "Black four-door SUV, three rows of seats.",
  "score" : 0.17812025547027588
}

For the above query, MongoDB Search returns documents with both Three and three. However, the score of the result with Three is higher because while the document with three was matched using the default [standard analyzer](https://www.mongodb.com/docs/search/indexes/analyzers/standard.md#std-label-ref-standard-analyzer, the document with Three was matched by both the specified simpleAnalyzer and the default [standard analyzer.](https://www.mongodb.com/docs/search/indexes/analyzers/standard.md#std-label-ref-standard-analyzer

The following example uses a collection called posts with the following documents:

 {
  "_id": 1,
  "username": "pinto",
  "post": {
    "date": "12-03-2018",
    "forum": "Tofu Recipes",
    "body": "Spicy Garlic Tofu cooks up crispy in 10 minutes or less.
             Serve with broccoli and rice for a delicious vegetarian meal."
  }
}
{
  "_id": 2,
  "username": "paloma",
  "post": {
    "date": "12-08-2018",
    "forum": "Tofu Recipes",
    "body": "Crispy Tofu in Shiitake Broth has flavors of citrus and
             umami. Great as an appetizer or entree."
  }
}

[Dynamic field mappings](https://www.mongodb.com/docs/search/indexes/define-field-mappings.md#std-label-static-dynamic-mappings allow you to index all fields in a collection as needed.

The index definition for the posts collection is as follows:

{
  "mappings": {
    "dynamic": true
  }
}

The following [compound operator](https://www.mongodb.com/docs/search/query/operators-collectors/compound.md#std-label-compound-ref query searches the field post.body for the string broccoli, and also specifies that the field must not contain the string cauliflower.

db.posts.aggregate([
  {
    $search: {
      "compound": {
        "must": {
          "text": {
            "query": "broccoli",
            "path": "post.body"
          }
        },
        "mustNot": {
          "text": {
            "query": "cauliflower",
            "path": "post.body"
          }
        }
      }
    }
  }
])

The preceding query returns the document with _id: 1, in which the posts.body field contains the string broccoli.

The following example uses a collection named cars, which has the following documents:

{
  "_id" : 1,
  "type" : "sedan",
  "make" : "Toyota",
  "description" : "Four-door sedan, lots of trunk space. Three to four passengers.",
  "warehouse" : [
    {
      "inventory" : 3,
      "color" : "red"
    }
  ]
}
{
  "_id" : 2,
  "type" : "coupe",
  "make" : "BMW",
  "description" : "Two-door convertible, driver's-side airbag.",
  "warehouse" : [
    {
      "inventory" : 5,
      "color" : "black"
    }
  ]
}
{
  "_id" : 3,
  "type" : "SUV",
  "make" : "Ford",
  "description" : "Four-door SUV, three rows of seats.",
  "warehouse" : [
    {
      "inventory" : 7,
      "color" : "white"
    },
    {
      "inventory" : 3,
      "color" : "red"
    }
  ]
}

The index definition for the cars collection is as follows:

{
  "mappings": {
    "dynamic": true
  }
}

The following queries search the fields specified using the wildcard character * for the string red.

All Fields Search Example

The following [query](https://www.mongodb.com/docs/search/query/operators-collectors/phrase.md#std-label-phrase-ref searches all fields for the string red.

db.cars.aggregate([
  {
    "$search": {
      "phrase": {
        "path": { "wildcard": "*" },
        "query": "red"
      }
    }
  }
])

The query returns the following results:

{
  "_id" : 1,
  "type" : "sedan",
  "make" : "Toyota",
  "description" : "Four-door sedan, lots of trunk space. Three to four passengers.",
  "warehouse" : [
    { "inventory" : 3, "color" : "red" }
  ]
}
{
  "_id" : 3,
  "type" : "SUV",
  "make" : "Ford",
  "description" : "Four-door SUV, three rows of seats.",
  "warehouse" : [
    { "inventory" : 7, "color" : "white" },
    { "inventory" : 3, "color" : "red" }
  ]
}

Nested Field Search Example

The following [query](https://www.mongodb.com/docs/search/query/operators-collectors/text.md#std-label-text-ref searches the fields nested within the warehouse field for the string red.

db.cars.aggregate([
  {
    "$search": {
      "text": {
        "path": { "wildcard": "warehouse.*" },
        "query": "red"
      }
    }
  }
])

The query returns the following results:

{
  "_id" : 1,
  "type" : "sedan",
  "make" : "Toyota",
  "description" : "Four-door sedan, lots of trunk space. Three to four passengers.",
  "warehouse" : [
    { "inventory" : 3, "color" : "red" }
  ]
}
{
  "_id" : 3,
  "type" : "SUV",
  "make" : "Ford",
  "description" : "Four-door SUV, three rows of seats.",
  "warehouse" : [
    { "inventory" : 7, "color" : "white" },
    { "inventory" : 3, "color" : "red" }
  ]
}