Make the MongoDB docs better! We value your opinion. Share your feedback for a chance to win $100.
Click here >
Docs Menu
Docs Home
/ /
Comodín
Docs Home
/ /
Tipos
/
Comodín
Docs Home
/
Desarrollo
/
Indexes
/
Tipos
/
Comodín

Restricciones del índice comodín

Esta página describe las limitaciones de los índice comodín, como propiedades incompatibles y patrones de query no compatibles.

Restricciones del índice comodín compuesto

Los índices comodín compuestos tienen las siguientes restricciones:

  • Un índice comodín compuesto solo puede tener un término comodín.

    Por ejemplo, no puedes especificar el siguiente índice:

    { userID: 1, "object1.$**": 1, "object2.$**": 1 }

  • Los términos que no son comodines en un índice comodín deben ser términos clave únicos. No se permiten los términos de índice Multikey.

  • Solo puedes especificar el wildcardProjection opción cuando el campo comodín es $**. No se puede usar wildcardProjection cuando se especifica una ruta de campo para el término de índice comodín.

    Esta es una definición válida:

    {
       key: { "$**": 1 },
       name: "index_all_with_projection",
       wildcardProjection: {
          "someFields.name": 1,
          "otherFields.values": 1
       }
    }

    Esta es una definición no válida:

    {
       key: { "someFields.$**": 1 },
       name: "invalid_index",
       wildcardProjection: {
          "someFields.name": 1,
          "otherFields.values": 1
       }
    }

  • El campo _id se omite por defecto. Si necesita el campo _id:

    • Especifique un índice comodín como $**.

    • Incluye el campo _id en el wildcardProjection con _id: 1.

    db.studentGrades.createIndex(
       {
          "$**": 1,
       },
       {
          wildcardProjection: {
             _id: 1,
             exams: 1,
             extraCredit: 1
          }
       }
    )

  • No se puede incluir el mismo campo en los campos comodín y en los campos regulares. Para excluir campos del patrón wildcard, utiliza un wildcardProjection con reglas de exclusión.

    db.studentGrades.createIndex(
       {
          exams: 1,
          "$**": 1,
          homeworks: 1
       },
       {
          wildcardProjection: {
             exams: 0,
             homeworks: 0
          }
       }
    )

Reglas de validación de wildcardProjection

A partir de MongoDB 8.3 (y 8.2.4, 8.0.18, 7.0.29), se aplican reglas de validación más estrictas a wildcardProjection en índices comodín compuestos para evitar configuraciones no válidas.

Los índices existentes que no cumplen los nuevos requisitos de validación siguen funcionando, pero no puedes crear nuevos índices que no cumplan estos requisitos.

Cuando uses wildcardProjection con índices comodín compuestos, se aplican las siguientes reglas:

Norma
Ejemplo válido
Ejemplo no válido

Si especificas un wildcardProjection, no puede estar vacío.

{ productId: 1, "$**": 1 },
{
  wildcardProjection: {
    attributes: 1
  }
}
{ productId: 1, "$**": 1 },
{
  wildcardProjection: { }
}

Solo puedes combinar inclusiones y exclusiones en un wildcardProjection si el campo incluido o excluido es _id. Puedes excluir _id en proyecciones de inclusión o incluir _id en proyecciones de exclusión.

{ "$**": 1, category: 1 },
{
  wildcardProjection: {
    _id: 0,
    attributes: 1
  }
}
{ "$**": 1, category: 1 },
{
  wildcardProjection: {
    _id: 1,
    metadata: 0
  }
}
{ "$**": 1, category: 1 },
{
  wildcardProjection: {
    _id: 0,
    price: 0,
    stock: 1
  }
}

Los campos incluidos en el wildcardProjection no deben superponerse con ningún campo de índice comodín.

{ userId: 1, "$**": 1 },
{
  wildcardProjection: {
    preferences: 1
  }
}
{ userId: 1, "$**": 1 },
{
  wildcardProjection: {
    userId: 1
  }
}

Solo puedes especificar una exclusión solo _idsi el campo de índice regular también es _id.

{ _id: 1, "$**": 1 },
{
  wildcardProjection: {
    _id: 0
  }
}
{ productId: 1, "$**": 1 },
{
  wildcardProjection: {
    _id: 0
  }
}

Si el wildcardProjection es una exclusión, debe excluir todos los campos regulares del índice.

{
  userId: 1,
  category: 1,
  "$**": 1
},
{
  wildcardProjection: {
    userId: 0,
    category: 0
  }
}
{
  userId: 1,
  category: 1,
  "$**": 1
},
{
  wildcardProjection: {
    userId: 0
  }
}

Propiedades de índice incompatibles

No puedes especificar las siguientes propiedades para un índice comodín:

Tipos de índices incompatibles

No puedes crear los siguientes tipos de índices usando la sintaxis de comodín ($.**):

Nota

Desambiguación

Los índices comodín son distintos e incompatibles con Crear un índice de texto comodín en implementaciones autogestionadas. Los índices comodín no pueden admitir consultas que utilicen el operador $text.

clave de partición

No puede utilizar un índice comodín como un índice de clave de partición.

Patrones de query no compatibles

Los índices comodín no pueden soportar los siguientes patrones de query:

El campo del arreglo no es igual a null

Si un determinado campo es un arreglo en cualquier documento de la colección, los índices comodín no pueden admitir consultas para documentos donde ese campo no sea igual a null.

Por ejemplo, considere una colección inventory con un índice comodín en product_attributes. El índice comodín no puede admitir las siguientes consultas si product_attributes.tags es un arreglo en cualquier documento de la colección:

db.inventory.find( { $ne : [ "product_attributes.tags", null ] } )
db.inventory.aggregate( [
   {
      $match : { $ne : [ "product_attributes.tags", null ] }
   }
] )

Coincidencias exactas en documentos y arreglos

Los índices comodín almacenan entradas para el contenido de un documento o arreglo, no para el documento o arreglo en sí. Por lo tanto, los índices comodín no pueden admitir coincidencias exactas en documentos o arreglos.

Por ejemplo, considere una colección inventory con un índice comodín en product_attributes. El índice comodín no puede admitir las siguientes consultas:

db.inventory.find(
   {
      "product_attributes" : { "price" : 29.99 }
   }
)
db.inventory.find(
   {
      "product_attributes.tags" : [ "waterproof", "fireproof" ]
   }
)

Nota

Los índices comodín pueden admitir queries en las que el campo es igual a un documento vacío {}.

De manera similar, los índices comodín no pueden soportar coincidencias exactas de desigualdad en documentos y arreglos. Por ejemplo, un índice comodín en product_attributes no puede soportar las siguientes queries:

db.inventory.aggregate( [
   {
      $match : {
         $ne : [ "product_attributes", { "price" : 29.99 } ]
      }
   }
] )
db.inventory.aggregate( [
   {
      $match : {
         $ne : [ "product_attributes.tags", [ "waterproof", "fireproof" ] ]
      }
   }
] )

El campo no existe

Los índices comodín son escasos y no indexan campos vacíos. Por lo tanto, los índices comodín no pueden soportar consultas para documentos donde un campo no existe.

Por ejemplo, considere una colección inventory con un índice comodín en product_attributes. El índice comodín no puede admitir las siguientes consultas:

db.inventory.find(
   {
      "product_attributes" : { $exists : false }
   }
)
db.inventory.aggregate( [
  {
     $match : {
        "product_attributes" : { $exists : false }
     }
  }
] )

Predicados de Query Multicampo

En el caso de que un solo índice comodín pueda soportar múltiples campos de consulta, MongoDB solo puede utilizar el índice comodín para soportar uno de los campos de consulta.

Por ejemplo, considera una colección inventory con un índice comodín en product_attributes. El índice comodín no puede soportar todo los predicados en la siguiente query:

db.inventory.find(
   {
      "product_attributes.price": { $gt: 20 },
      "product_attributes.material": "silk",
      "product_attributes.size": "large"
   }
)

En su lugar, MongoDB utiliza el índice comodín para soportar solo uno de los predicados de consulta. MongoDB elige automáticamente qué predicado soportar según las rutas relevantes del índice comodín. Los predicados de la consulta no soportados se muestran en la rejectedPlans de los resultados explain.

Esto también es cierto para los índices comodín compuestos. El término comodín de un índice compuesto solo puede soportar un predicado de query, aunque los términos que no sean comodines pueden soportar los predicados restantes.

Nota

Comportamiento $or

MongoDB puede usar el mismo índice comodín para soportar cada argumento independiente de los operadores de query $or o de agregación $or.

Las query con ordenación

MongoDB puede usar un índice comodín para satisfacer el sort() solo si se cumplen todas las siguientes condiciones:

  • El planificador de consultas selecciona el índice comodín para satisfacer el predicado de la consulta.

  • El sort() especifica solo el campo del predicado de la query.

  • El campo especificado nunca es un arreglo.

Si no se cumplen las condiciones anteriores, MongoDB no podrá utilizar el índice comodín para la ordenación. MongoDB no admite sort() operaciones que requieran un índice diferente al del predicado de query.

Observa el siguiente índice comodín de la colección products:

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

La siguiente operación query un solo campo product_attributes.price y ordena sobre ese mismo campo:

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

Suponiendo que el price especificado nunca sea un arreglo, MongoDB puede usar el índice comodín product_attributes.$** para satisfacer tanto el find() como el sort().

Volver

Firma

Next

Geoespacial

En esta página