Wildcard Indexes通配符索引

Create a Wildcard Index on a Field在字段上创建通配符索引

To index the value of a specific field:要为特定字段的值编制索引，请执行以下操作：

db.collection.createIndex( { "fieldA.$**" : 1 } )

With this wildcard index, MongoDB indexes all values of fieldA. 通过这个通配符索引，MongoDB为fieldA的所有值建立索引。If the field is a nested document or array, the wildcard index recurses into the document/array and stores the value for all fields in the document/array.如果字段是嵌套的文档或数组，则通配符索引将递归到文档/数组中，并存储文档/数组中所有字段的值。

For example, documents in the product_catalog collection may contain a product_attributes field. 例如，product_catalog集合中的文档可能包含product_attributes字段。The product_attributes field can contain arbitrary nested fields, including embedded documents and arrays:product_attributes字段可以包含任意嵌套字段，包括嵌入的文档和数组：

{
  "product_name" : "Spy Coat",
  "product_attributes" : {
    "material" : [ "Tweed", "Wool", "Leather" ],
    "size" : {
      "length" : 72,
      "units" : "inches"
    }
  }
}

{
  "product_name" : "Spy Pen",
  "product_attributes" : {
     "colors" : [ "Blue", "Black" ],
     "secret_feature" : {
       "name" : "laser",
       "power" : "1000",
       "units" : "watts",
     }
  }
}

The following operation creates a wildcard index on the product_attributes field:以下操作在product_attributes字段上创建通配符索引：

db.products_catalog.createIndex( { "product_attributes.$**" : 1 } )

The wildcard index can support arbitrary single-field queries on product_attributes or its embedded fields:通配符索引可以支持对product_attributes或其嵌入字段的任意单字段查询：

db.products_catalog.find( { "product_attributes.size.length" : { $gt : 60 } } )
db.products_catalog.find( { "product_attributes.material" : "Leather" } )
db.products_catalog.find( { "product_attributes.secret_feature.name" : "laser" } )

For an example, see Create a Wildcard Index on a Single Field Path.有关示例，请参阅在单个字段路径上创建通配符索引。

Create a Wildcard Index on All Fields在所有字段上创建通配符索引

To index the value of all fields in a document (excluding _id), specify "$**" as the index key:要对文档中所有字段（不包括_id）的值进行索引，请指定"$**"作为索引键：

db.collection.createIndex( { "$**" : 1 } )

With this wildcard index, MongoDB indexes all fields for each document in the collection. 通过这个通配符索引，MongoDB为集合中每个文档的所有字段建立索引。If a given field is a nested document or array, the wildcard index recurses into the document/array and stores the value for all fields in the document/array.如果给定的字段是嵌套的文档或数组，则通配符索引将递归到文档/数组中，并存储文档/数组中所有字段的值。

For an example, see Create a Wildcard Index on All Field Paths.有关示例，请参阅在所有字段路径上创建通配符索引。

Create a Wildcard Index on Multiple Specific Fields在多个特定字段上创建通配符索引

To index the values of multiple specific fields in a document:要为文档中多个特定字段的值编制索引，请执行以下操作：

db.collection.createIndex(
  { "$**" : 1 },
  { "wildcardProjection" :
    { "fieldA" : 1, "fieldB.fieldC" : 1 }
  }
)

With this wildcard index, MongoDB indexes all values for the specified fields for each document in the collection. 通过这个通配符索引，MongoDB为集合中每个文档的指定字段的所有值建立索引。If a given field is a nested document or array, the wildcard index recurses into the document/array and stores the value for all fields in the document/array.如果给定的字段是嵌套的文档或数组，则通配符索引将递归到文档/数组中，并存储文档/数组中所有字段的值。

For an example, see Include Specific Fields in Wildcard Index Coverage.有关示例，请参阅在通配符索引覆盖范围中包含特定字段。

Create a Wildcard Index that Excludes Multiple Specific Fields创建排除多个特定字段的通配符索引

To index the fields of all fields in a document excluding specific field paths:要为文档中除特定字段路径之外的所有字段的字段编制索引，请执行以下操作：

db.collection.createIndex(
  { "$**" : 1 },
  { "wildcardProjection" :
    { "fieldA" : 0, "fieldB.fieldC" : 0 }
  }
)

With this wildcard index, MongoDB indexes all fields for each document in the collection excluding the specified field paths. 有了这个通配符索引，MongoDB为集合中每个文档的所有字段建立索引，不包括指定的字段路径。If a given field is a nested document or array, the wildcard index recurses into the document/array and stores the values for all fields in the document/array.如果给定的字段是嵌套的文档或数组，则通配符索引将递归到文档/数组中，并存储文档/数组中所有字段的值。

For an example, see Omit Specific Fields from Wildcard Index Coverage.有关示例，请参阅从通配符索引覆盖范围中省略特定字段。

Nested Objects嵌套对象

When a wildcard index encounters a nested object, it descends into the object and indexes its contents. 当通配符索引遇到嵌套对象时，它会下降到对象中并对其内容进行索引。For example:例如：

{
  "parentField" : {
    "nestedField" : "nestedValue",
    "nestedArray" : ["nestedElement"]
    "nestedObject" : {
      "deeplyNestedField" : "deeplyNestedValue"
    }
  }
}

A wildcard index which includes parentField descends into the object to traverse and index its contents:包含parentField的通配符索引下降到对象中以遍历和索引其内容：

• For each field which is itself an object (i.e. an embedded document), descend into the object to index its contents.对于每个本身就是对象（即嵌入式文档）的字段，向下进入对象以索引其内容。

• For each field which is an array, traverse the array and index its contents.对于作为数组的每个字段，遍历数组并索引其内容。

• For all other fields, record the primitive (non-object/array) value into the index.对于所有其他字段，将基元（非对象/数组）值记录到索引中。

The wildcard index continues traversing any additional nested objects or arrays until it reaches a primitive value (i.e. a field that is not an object or array). 通配符索引继续遍历任何其他嵌套对象或数组，直到它达到基元值（即不是对象或数组的字段）。It then indexes this primitive value, along with the full path to that field.然后，它对该基元值以及该字段的完整路径进行索引。

Given the sample document, the wildcard index adds the following records to the index:给定示例文档，通配符索引将以下记录添加到索引中：

• "parentField.nestedField" : "nestedValue"

• "parentField.nestedObject.deeplyNestedField" : "deeplyNestedValue"

• "parentField.nestedArray" : "nestedElement"

For more information on wildcard index behavior with nested arrays, see Nested Arrays.有关嵌套数组的通配符索引行为的详细信息，请参阅嵌套数组。

Nested Arrays嵌套数组

When a wildcard index encounters a nested array, it attempts to traverse the array to index its elements. 当通配符索引遇到嵌套数组时，它会尝试遍历数组以对其元素进行索引。If the array is itself an element in a parent array (i.e. an embedded array), the wildcard index instead records the entire array as a value instead of traversing its contents. 如果数组本身是父数组（即嵌入式数组）中的一个元素，则通配符索引会将整个数组记录为一个值，而不是遍历其内容。For example:例如：

{
  "parentArray" : [
    "arrayElementOne",
    [ "embeddedArrayElement" ],
    "nestedObject" : {
      "nestedArray" : [
        "nestedArrayElementOne",
        "nestedArrayElementTwo"
      ]
    }
  ]
}

A wildcard index which includes parentArray descends into the array to traverse and index its contents:包含parentArray的通配符索引下降到数组中，以遍历和索引其内容：

• For each element which is an array (i.e. an embedded array), index the entire array as a value.对于作为数组的每个元素（即嵌入式数组），将整个数组作为一个值进行索引。

• For each element which is an object, descend into the object to traverse and index its contents.对于作为对象的每个元素，向下进入对象以遍历和索引其内容。

• For all other fields, record the primitive (non-object/array) value into the index.对于所有其他字段，将基元（非对象/数组）值记录到索引中。

The wildcard index continues traversing any additional nested objects or arrays until it reaches a primitive value (i.e. a field that is not an object or array). 通配符索引继续遍历任何其他嵌套对象或数组，直到它达到基元值（即不是对象或数组的字段）。It then indexes this primitive value, along with the full path to that field.然后，它对该基元值以及该字段的完整路径进行索引。

Given the sample document, the wildcard index adds the following records to the index:给定示例文档，通配符索引将以下记录添加到索引中：

• "parentArray" : "arrayElementOne"

• "parentArray" : ["embeddedArrayElement"]

• "parentArray.nestedObject.nestedArray" : "nestedArrayElementOne"

• "parentArray.nestedObject.nestedArray" : "nestedArrayElementTwo"

Note that the records for parentField.nestedArray do not include the array position for each element. 请注意，parentField.nestedArray的记录不包括每个元素的数组位置。Wildcard indexes ignore array element positions when recording the element into the index. Wildcard indexes can still support queries that include explicit array indices. 将数组元素记录到索引中时，通配符索引将忽略数组元素的位置。通配符索引仍然可以支持包含显式数组索引的查询。See Queries with Explicit Array Indices for more information.有关详细信息，请参阅具有显式数组索引的查询。

Index Display索引显示

Starting in MongoDB 6.3, 6.0.5, and 5.0.16, the wildcardProjection field stores the index projection in its submitted form. Earlier versions of the server may have stored the projection in a normalized form.从MongoDB 6.3、6.0.5和5.0.16开始，wildcardProjection字段以提交的形式存储索引投影。早期版本的服务器可能以规范化的形式存储了投影。

The server uses the index the same way, but you may notice a difference in the output of the listIndexes and db.collection.getIndexes() commands.服务器以相同的方式使用索引，但您可能会注意到listIndexes和db.collection.getIndexes()命令的输出有所不同。

Covered Queries涵盖的查询

Wildcard indexes can support a covered query only if all of the following are true:只有当以下所有条件都为true时，通配符索引才能支持覆盖查询：

• The query planner selects the wildcard index for satisfying the query predicate.查询计划器选择通配符索引以满足查询谓词。

• The query predicate specifies exactly one field covered by the wildcard index.查询谓词只指定通配符索引所覆盖的一个字段。

• The projection explicitly excludes _id and includes only the query field.投影显式地排除了_id，并且只包括查询字段。

• The specified query field is never an array.指定的查询字段从来都不是数组。

Consider the following wildcard index on the employees collection:请考虑对employees集合使用以下通配符索引：

db.employees.createIndex( { "$**" : 1 } )

The following operation queries for a single field lastName and projects out all other fields from the resulting document:以下操作查询单个字段lastName，并从生成的文档中投射出所有其他字段：

db.employees.find(
  { "lastName" : "Doe" },
  { "_id" : 0, "lastName" : 1 }
)

Assuming that the specified lastName is never an array, MongoDB can use the $** wildcard index for supporting a covered query.假设指定的lastName从来都不是数组，MongoDB可以使用$**通配符索引来支持覆盖的查询。

Multi-Field Query Predicates多字段查询谓词

Wildcard indexes can support at most one query predicate field. That is:通配符索引最多可以支持一个查询谓词字段。即：

• MongoDB cannot use a non-wildcard index to satisfy one part of a query predicate and a wildcard index to satisfy another.MongoDB不能使用非通配符索引来满足查询谓词的一部分，也不能使用通配符索引来实现另一部分。

• MongoDB cannot use one wildcard index to satisfy one part of a query predicate and another wildcard index to satisfy another.MongoDB不能使用一个通配符索引来满足查询谓词的一部分，而不能使用另一个通配符指数来满足另一部分。

• Even if a single wildcard index could support multiple query fields, MongoDB can use the wildcard index to support only one of the query fields. All remaining fields are resolved without an index.即使单个通配符索引可以支持多个查询字段，MongoDB也可以使用通配符索引只支持其中一个查询字段。解析所有剩余字段时不使用索引。

However, MongoDB may use the same wildcard index for satisfying each independent argument of the query $or or aggregation $or operators.然而，MongoDB可能使用相同的通配符索引来满足查询$or或聚合$or运算符的每个独立参数。

Queries with Sort带排序的查询

MongoDB can use a wildcard index for satisfying the sort() only if all of the following are true:只有当以下所有条件都为true时，MongoDB才能使用通配符索引来满足sort()：

• The query planner selects the wildcard index for satisfying the query predicate.查询计划器选择通配符索引以满足查询谓词。

• The sort() specifies only the query predicate field.sort()只指定查询谓词字段。

• The specified field is never an array.指定的字段从来都不是数组。

If the above conditions are not met, MongoDB cannot use the wildcard index for the sort. 如果不满足上述条件，MongoDB将无法使用通配符索引进行排序。MongoDB does not support sort() operations that require a different index from that of the query predicate. MongoDB不支持sort()操作，这些操作需要与查询谓词不同的索引。For more information, see Index Intersection and Sort.有关详细信息，请参阅索引交点和排序。

Consider the following wildcard index on the products collection:请考虑products集合上的以下通配符索引：

db.products.createIndex( { "product_attributes.$**" : 1 } )

The following operation queries for a single field product_attributes.price and sorts on that same field:以下操作查询单个字段product_attributes.price并对同一字段进行排序：

db.products.find(
  { "product_attributes.price" : { $gt : 10.00 } },
).sort(
  { "product_attributes.price" : 1 }
)

Assuming that the specified price is never an array, MongoDB can use the product_attributes.$** wildcard index for satisfying both the find() and sort().假设指定的price从来都不是数组，MongoDB可以使用product_attributes.$**通配符索引，用于同时满足find()和sort()。

Unsupported Query Patterns不支持的查询模式

Wildcard indexes cannot support the following query patterns:通配符索引无法支持以下查询模式：

• Queries that check if a field does not exist检查字段是否不存在的查询

• Queries that check if a field is or is not equal to a document or an array检查字段是否等于文档或数组的查询

• Queries that check if a field is equal to null检查字段是否等于null的查询

For details, see Unsupported Query and Aggregation Patterns.有关详细信息，请参阅不支持的查询和聚合模式。

Queries with Explicit Array Indices具有显式数组索引的查询

MongoDB wildcard indexes do not record the array position of any given element in an array during indexing. However, MongoDB may still select the wildcard index to answer a query which includes a field path with one or more explicit array indices (for example, parentArray.0.nestedArray.0). MongoDB通配符索引在索引过程中不会记录数组中任何给定元素的数组位置。但是，MongoDB仍然可以选择通配符索引来回答包含一个或多个显式数组索引（例如parentArray.0.nestedArray.0）的字段路径的查询。Due to the increasing complexity of defining index bounds for each consecutive nested array, MongoDB does not consider the wildcard index to answer a given field path in the query if that path contains more than 8 explicit array indices. 由于为每个连续嵌套数组定义索引边界的复杂性不断增加，如果查询中的给定字段路径包含8个以上的显式数组索引，MongoDB不会考虑使用通配符索引来回答该路径。MongoDB can still consider the wildcard index to answer other field paths in the query.MongoDB仍然可以考虑通配符索引来回答查询中的其他字段路径。

For example:例如：

{
  "parentObject" : {
    "nestedArray" : [
       "elementOne",
       {
         "deeplyNestedArray" : [ "elementTwo" ]
       }
     ]
  }
}

MongoDB can select a wildcard index which includes parentObject to satisfy the following queries:MongoDB可以选择一个包含parentObject的通配符索引来满足以下查询：

• "parentObject.nestedArray.0" : "elementOne"

• "parentObject.nestedArray.1.deeplyNestedArray.0" : "elementTwo"

If a given field path in the query predicate specifies more than 8 explicit array indices, MongoDB does not consider the wildcard index for answering that field path. 如果查询谓词中给定的字段路径指定了8个以上的显式数组索引，MongoDB不会考虑通配符索引来回答该字段路径。MongoDB instead either selects another eligible index to answer the query, or performs a collection scan.相反，MongoDB要么选择另一个符合条件的索引来回答查询，要么执行集合扫描。

Note that wildcard indexes themselves do not have any limits on the depth to which they traverse a document while indexing it; the limitation only applies to queries which explicitly specify exact array indices. 请注意，通配符索引本身对索引文档时遍历文档的深度没有任何限制；该限制仅适用于明确指定精确数组索引的查询。By issuing the same queries without the explicit array indices, MongoDB may select the wildcard index to answer the query:通过在没有显式数组索引的情况下发出相同的查询，MongoDB可以选择通配符索引来回答查询：

• "parentObject.nestedArray" : "elementOne"

• "parentObject.nestedArray.deeplyNestedArray" : "elementTwo"