Menu Docs
Página inicial do Docs
/
Manual do banco de dados
/
Indexes
/
Tipos
/
Curinga
/
Referência

Restrições de índice curinga

Esta página descreve as limitações dos índices curinga, como propriedades incompatíveis e padrões de query não suportados.

Restrições do Índice Curinga Composto

Os índices compostos de curingas têm as seguintes restrições:

  • Um índice curinga composto pode ter somente um termo curinga.

    Por exemplo, você não pode especificar o seguinte índice:

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

  • Os termos não curinga em um compound wildcard index devem ser termos de chave única. Os termos de índice de várias chaves não são permitidos.

  • A opção wildcardProjection só é válida quando o campo curinga for $**. Não é possível usar wildcardProjection ao especificar um caminho do campo para o termo do índice curinga .

    Esta é uma definição válida:

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

    Esta é uma definição inválida:

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

  • O campo _id é omitido por padrão. Se você precisar do campo _id :

    • Especifique um índice curinga como $**

    • Use uma wildcardProjection

    • Especifique o campo _id

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

  • Você não pode incluir o mesmo campo nos campos curinga e campos regulares. Você pode utilizar um wildcardProjection para excluir campos do padrão curinga.

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

Propriedades de índice incompatíveis

Não é possível especificar as seguintes propriedades para um índice curinga:

Tipos de índice incompatíveis

Você não pode criar os seguintes tipos de índice utilizando sintaxe curinga ($.**):

Observação

Desambiguação

Os índices curinga são distintos e incompatíveis com Criar um índice de texto curinga em sistemas autogerenciados. Os índices curinga não suportam consultas usando o operador $text .

Chave de fragmento

Não é possível usar um índice curinga de chave de shard.

Padrões de query não suportados

Os índices curinga não podem suportar os seguintes padrões de query:

O campo de array não é igual a null

Se um determinado campo for uma array em qualquer documento da coleção, os índices curinga não poderão suportar queries para documentos em que esse campo não seja igual a null.

Por exemplo, considere uma coleção inventory com um índice curinga em product_attributes. O índice curinga não pode suportar as seguintes queries se product_attributes.tags for uma array em qualquer documento da coleção:

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

Correspondências de igualdade em documentos e arrays

Os índices curinga armazenam entradas para o conteúdo de um documento ou array, não o documento ou array em si. Portanto, os índices curinga não podem suportar correspondências exatas de igualdade em documentos ou arrays.

Por exemplo, considere uma collection inventory com um índice curinga em product_attributes. O índice curinga não pode suportar as seguintes queries:

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

Observação

Os índices curinga podem suportar consultas onde o campo é igual a um documento vazio {}.

Da mesma forma, os índices curinga não suportam correspondências exatas de desigualdade em documentos e arrays. Por exemplo, um índice curinga em product_attributes não pode suportar as seguintes queries:

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

O campo não existe

Os índices curinga são esparsos e não indexam campos vazios. Portanto, os índices curinga não podem suportar queries para documentos onde um campo não existe.

Por exemplo, considere uma collection inventory com um índice curinga em product_attributes. O índice curinga não pode suportar as seguintes queries:

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

Predicados de query de vários campos

Os índices curinga podem suportar no máximo um campo de predicado de query. Isso significa que:

  • O MongoDB não pode usar um índice curinga para oferecer suporte a uma parte de um predicado de query e um índice curinga para oferecer suporte a outra.

  • O MongoDB não pode usar vários índices curinga para oferecer suporte a diferentes predicados na mesma query.

  • Caso um único índice curinga possa suportar vários campos de consulta, o MongoDB só pode usar o índice curinga para suportar um dos campos de consulta. O MongoDB escolhe qual campo suportar com o índice curinga automaticamente com base em caminhos de índice curinga relevantes.

Por exemplo, considere uma collection inventory com um índice curinga em product_attributes. O índice curinga não pode suportar todos os predicados na seguinte query:

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

Em vez disso, o MongoDB utiliza o índice curinga para suportar apenas um dos predicados da query. O MongoDB escolhe qual predicado suportar com base em caminhos de índice curinga relevantes. Os predicados de query não suportados são mostrados no rejectedPlans dos resultados da explicação.

Observação

Comportamento $or

O MongoDB pode usar o mesmo índice curinga para suportar cada argumento independente dos operadores de query $or ou agregação $or .

Consultas com Classificação

O MongoDB pode usar um índice curinga para satisfazer sort() somente se todas as condições a seguir forem verdadeiras:

  • O planejador de query seleciona o índice curinga para satisfazer o predicado da query.

  • O sort() especifica somente o campo de predicado da query.

  • O campo especificado nunca é uma matriz.

Se as condições acima não forem atendidas, o MongoDB não poderá usar o índice curinga para a classificação. O MongoDB não suporta operações do sort() que exigem um índice diferente do predicado da query.

Considere o seguinte índice curinga na collection products:

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

A seguinte operação faz queries para um campo único product_attributes.price e classifica neste mesmo campo:

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

Supondo que o price especificado nunca seja uma array, o MongoDB pode usar o índice curinga product_attributes.$** para satisfazer tanto find() quanto sort().

Voltar

Assinatura

Próximo

Geoespacial

Nesta página