Índices comodín compuestos

Buscar utilizando el patrón de atributo

La patrón de atributo es una técnica útil para buscar documentos que comparten características comunes.

Desafortunadamente, es costoso crear muchos índices individuales para cubrir todas las queries posibles. Un índice comodín es una buena alternativa a la creación de un gran número de índices individuales porque un único índice comodín puede cubrir eficientemente muchas potential queries.

Considera un esquema como:

{
     tenantId: <Number>,
     tenantRegion: <Number>,
     customFields: {
                     addr: <String>,
                     name: <String>,
                     blockId: <Number>,
                     ...
     }
    dateOpened: <Date>
 }

Es posible que desee query aspectos del customFields campo para inquilinos que tienen un tenantId en particular. Se podría crear una serie de índices individuales:

{ tenantId: 1, "customFields.addr": 1 }
{ tenantId: 1, "customFields.name": 1 }
{ tenantId: 1, "customFields.blockId": 1 }
...

Este enfoque es difícil de mantener y es probable que alcance el número máximo de índices por colección (64).

Utiliza un índice comodín compuesto en su lugar. El índice comodín compuesto es más fácil de escribir, más fácil de mantener y es poco probable que alcance el límite de colección de 64 índices.

Este ejemplo crea un índice comodín compuesto en la colección salesData:

db.runCommand(
   {
       createIndexes: "salesData",
       indexes: [
          {
             key: {
                tenantId: 1,
                "customFields.$**": 1
             },
             name: "tenant_customFields"
          }
       ]
   }
)

El comodín, "customFields.$**", especifica todos los subcampos en el campo customFields. El otro término del índice, tenantId, no es una especificación comodín; es una especificación de campo estándar.

Consideraciones generales para índices comodín

• Los índices comodín omiten el campo _id por defecto. Para incluir el campo _id en un índice comodín, se debe incluir explícitamente en el documento wildcardProjection.

  db.salesData.createIndex(
     { "$**" : 1 },
     { "wildcardProjection" :
        { "_id": 1, "customers.lastName": 1, "customers.FirstName": 1, }
     }
  )

• Puedes crear más de un índice comodín en una colección.

• Un índice comodín puede cubrir los mismos campos que otros índices en la colección.

• Los índices de comodín son dispersos. Solo incluyen entradas para documentos que contienen el campo indexado.

  El documento no se indexa si todos los campos del índice de comodín compuesto faltan.

Consideraciones sobre el índice comodín compuesto

• Los índices comodín compuestos son índices dispersos.

• Los documentos se incluyen en el índice si carecen del campo comodín pero tienen uno de los campos compuestos.

• Los campos del índice, incluidos los campos comodín, se pueden ordenar en orden ascendente (1) o descendente (-1).

Filtrar campos con una wildcardProjection

Puedes utilizar un wildcardProjection para especificar campos individuales.

db.runCommand(
   {
       createIndexes: "salesData",
       indexes: [
          {
             key: {
                tenantId: 1,
                "$**": 1
             },
             name: "tenant_customFields_projection",
             wildcardProjection: {
                "customFields.addr": 1,
                "customFields.name": 1
             }
          }
       ]
   }
)

El término de índice comodín, "$**", especifica todos los campos en la colección. El wildcardProjection limita el índice a los campos especificados, "customFields.addr" y "customFields.name".

Solo puedes usar un wildcardProjection cuando el término comodín es $**.

Utiliza un método asistente para crear un índice comodín

MongoDB proporciona asistentes de shell para la mayoría de los comandos de base de datos. Estos métodos de shell ofrecen una sintaxis simplificada y son funcionalmente equivalentes a los comandos de base de datos.

El asistente de shell para el primer ejemplo es:

db.salesData.createIndex(
   { tenantId: 1, "customFields.$**": 1 },
   {
      name: "tenant_customFields_shellHelper"
   }
)

El asistente de shell para el segundo ejemplo es:

db.salesData.createIndex(
  { tenantId: 1, "$**": 1 },
  { "wildcardProjection": {
        "customFields.addr": 1,
        "customFields.name": 1
     },
     name: "tenant_customFields_projection_helper"
  }
)

Si desea comparar los comandos de shell y los comandos de base de datos, debe eliminar los índices entre invocaciones de comandos. No puede crear el mismo índice dos veces, incluso con diferentes nombres.

Para descartar un índice, inserta el nombre del índice y ejecuta db.collection.dropIndex().

db.salesData.dropIndex( "tenant_customFields" )

El comando anterior elimina el índice "tenant_customFields" de la base de datos salesData.

Crea un índice comodín compuesto parcial

Para crear un índice parcial de comodín compuesto, puedes usar la opción partialFilterExpression para especificar una expresión de filtro de modo que el índice solo incluya documentos que coincidan con la condición del filtro. partialFilterExpression puede cubrir campos que estén incluidos o no en el índice.

El siguiente ejemplo crea un índice comodín compuesto parcial en el campo tenantId y en todos los subcampos del campo customFields, solo en documentos con un tenantRegion de 1.

db.runCommand(
   {
      createIndexes: "salesData",
      indexes: [
         {
            key: {
               tenantId: 1,
               "customFields.$**": 1
            },
            name: "tenant_customFields_partial",
            partialFilterExpression: { tenantRegion: 1 }
         }
      ]
   }
)