createIndexes (comando de banco de dados)

Definição

createIndexes: Constrói um ou mais índices em uma coleção.
Dica
In mongosh, this command can also be run through the db.collection.createIndex() and db.collection.createIndexes() helper methods.
Helper methods are convenient for mongosh users, but they may not return the same level of information as database commands. In cases where the convenience is not needed or the additional return fields are required, use the database command.

Compatibilidade

Esse comando está disponível em implantações hospedadas nos seguintes ambientes:

MongoDB Atlas: o serviço totalmente gerenciado para implantações do MongoDB na nuvem

Observação

Este comando é aceito em todos os clusters do MongoDB Atlas. Para obter informações sobre o suporte do Atlas a todos os comandos, consulte Comandos não suportados.

MongoDB Enterprise: a versão autogerenciada e baseada em assinatura do MongoDB
MongoDB Community: uma versão com código disponível, de uso gratuito e autogerenciada do MongoDB

Sintaxe

The createIndexes command takes the following form:

db.runCommand(
   {
     createIndexes: <collection>,
     indexes: [
         {
             key: {
                 <key-value_pair>,
                 <key-value_pair>,
                 ...
             },
             name: <index_name>,
             <option1>,
             <option2>,
             ...
         },
         { ... },
         { ... }
     ],
     writeConcern: { <write concern> },
     commitQuorum: <int|string>,
     comment: <any>
   }
 )

Campos de comando

The createIndexes command takes the following fields:

Campo	Tipo	Descrição
`createIndexes`	string	A coleção para a qual criar índices.
`indexes`	array	Especifica os índices a serem criados. Cada documento na array especifica um índice separado.
`writeConcern`	documento	Opcional. Um documento que expressa o write concern. Omitir para usar o write concern padrão.
`commitQuorum`	inteiro ou string	Opcional. O número mínimo de nós do conjunto de réplicas contendo dados (ou seja, quorum para o commit), incluindo o primary, que deve relatar uma construção de índice bem-sucedida antes que o primary marque o `indexes` como pronto. Você pode retomar algumas construções de índice interrompidas quando o quórum para a confirmação estiver definido como o padrão `"votingMembers"`. Consulte `setIndexCommitQuorum`. Nós do conjunto de réplicas em um quorum para o commit devem ter `members[n].buildIndexes` definido como `true`. Se algum nó de votação tiver `members[n].buildIndexes` definido como `false`, você não poderá usar o `"votingMembers"` commit quorum padrão. Configure todos os nós com `members[n].buildIndexes` definido como `true` ou selecione um commit quorum diferente. suporta os seguintes valores: `"votingMembers"` - todos os membros do conjunto de réplicas de votos com dados (Padrão). Um membro "votante" é qualquer membro do conjunto de réplicas em que `members[n].votes` é maior que `0`. `"majority"` - uma maioria simples de membros do conjunto de réplicas com dados. `<int>` - um número específico de membros do conjunto de réplicas com dados. `0` - Desativa o comportamento de votação em quórum. Os membros iniciam a construção do índice simultaneamente, mas não votam nem esperam pelo quorum antes de concluírem a construção do índice. Se você iniciar uma construção de índice com um quorum para o commit de `0`, não poderá modificar posteriormente o quorum de confirmação usando `setIndexCommitQuorum`. Um nome de tag do conjunto de réplicas.
`comment`	any	Opcional. Um comentário fornecido pelo usuário para anexar a este comando. Depois de definido, esse comentário aparece junto com os registros desse comando nos seguintes locais: mensagens de log do mongod, no campo `attr.command.cursor.comment`. Saída do perfil do banco de dados, no campo `command.comment`. Saída de `currentOp`, no campo `command.comment`. Um comentário pode ser qualquer tipo BSON válido (string, inteiro, objeto, array etc).

Cada documento no array indexes contém os seguintes campos:

Campo

Tipo

Descrição

key

documento

Especifica os campos do índice. Para cada campo, especifique um par chave-valor no qual a chave é o nome do campo a ser indexado e o valor é a direção do índice ou o tipo de índice. Se especificar direção, especifique 1 para ascendente ou -1 para descendente.

O MongoDB suporta vários tipos de índice diferentes, incluindo:

Consulte os tipos de índice para obter mais informações.

Índices Curinga suportam cargas de trabalho em que os usuários fazem query nos campos personalizados ou uma grande variedade de campos em uma coleção:

Você pode criar um índice curinga em um campo específico e seus subcaminhos ou em todos os campos de um documento.

Para obter detalhes, consulte Índices Curinga.

name

string

Um nome que identifica exclusivamente o índice.

unique

booleano

Opcional. Cria um índice único para que a coleção não aceite a inserção ou atualização de documentos em que o valor da chave do índice corresponda a um valor existente no índice.

Especifique true para criar um índice único. O valor padrão é false.

A opção está indisponível para índices de hasheados.

partialFilterExpression

documento

Opcional. Se especificado, o índice só faz referência a documentos que correspondam à expressão de filtro. Consulte Índices parciais para obter mais informações.

Uma expressão de filtro pode incluir:

expressões de igualdade (ou seja, field: value ou usando o operador $eq)
$exists: true expressão
$gt, $gte, $lt, $lte expressões
$type expressões
$and operador, operador
$or operador, operador
$in operador, operador
$geoWithin operador, operador
$geoIntersects operador, operador

Se você estiver utilizando o Client-Side Field Level Encryption ou o Queryable Encryption, um partialFilterExpression não poderá fazer referência a um campo criptografado.

Você pode especificar uma opção partialFilterExpression para todos os tipos de índiceMongoDB.

sparse

booleano

Opcional. Se true, o índice referencia apenas documentos com o campo especificado. Esses índices usam menos espaço, mas se comportam de forma diferente em algumas situações (especialmente em tipos). O valor padrão é false. Consulte Analisar índices para obter mais informações.

Os seguintes tipos de índice são escassos por padrão e ignoram esta opção:

Para um índice composto que inclui 2dsphere chave(s) de índice junto com chaves de outros tipos, somente os campos de índice 2dsphere determinam se o índice faz referência a um documento.

O MongoDB fornece a opção de criar índices parciais. Eles oferecem um superconjunto de funcionalidades de índices esparsos e são preferidos.

expireAfterSeconds

inteiro

Opcional. Especifica um valor, em segundos, como um tempo de vida(TTL) para controlar por quanto tempo o MongoDB retém documentos na coleção. Esta opção se aplica somente aos índices TTL. Consulte Expirar dados de coleções configurando TTL para obter mais informações.

Se você usa índices TTL criados antes do MongoDB 5.0 ou se deseja sincronizar dados criados no MongDB 5.0 com um pré-5.0 instalação, consulte Índices configurados usando NaN para evitar problemas de configuração incorreta.

O valor expireAfterSeconds do índice TTL deve estar dentro de 0 e 2147483647 inclusive.

escondida

booleano

Opcional. Uma bandeira que determina se o índice é oculto do planejador de query. Um índice oculto não é avaliado como parte da seleção do plano de query.

O padrão é false.

storageEngine

documento

Opcional. Permite que os usuários configurem o mecanismo de armazenamento por índice ao criar um índice.

A opção storageEngine deve receber o seguinte formulário:

storageEngine: { <storage-engine-name>: <options> }

As opções de configuração do mecanismo de armazenamento especificadas ao criar índices são validadas e registradas no oplog durante a replicação para suportar conjuntos de réplicas com membros que usam mecanismos de armazenamento diferentes.

weights

documento

Opcional. Para índices de texto, um documento que contém pares de peso e campo. O peso é um número inteiro que varia de 1 a 99.999 e denota a importância do campo em relação aos outros campos indexados em termos de pontuação. Você pode especificar pesos para alguns ou todos os campos indexados. Consulte Atribuir pesos aos resultados da pesquisa de texto em implantações autogerenciadas para ajustar as pontuações. O valor padrão é 1.

default_language

string

Opcional. Para índices de texto, o idioma que determina a lista de palavras de interrupção e as regras para o stemmer e o tokenizador. Consulte Pesquisa de texto em implantação autogerenciada para as linguagens disponíveis e Especificar linguagem para índices de texto no MongoDB autogerenciado para mais informações e exemplos. O valor padrão é english.

language_override

string

Opcional. Para índices de texto, o nome do campo, nos documentos da coleção, que contém o idioma de substituição do documento. O valor padrão é language. Consulte Especificar idioma para índices de texto no MongoDB autogerenciado para obter um exemplo.

textIndexVersion

inteiro

Opcional. O número da versão do índice text. Os usuários podem usar essa opção para substituir o número da versão padrão.

Para ver as versões disponíveis, consulte Versões de índice de texto em implantações autogerenciadas.

2dsphereIndexVersion

inteiro

Opcional. O número da versão do índice 2dsphere. Os usuários podem usar essa opção para substituir o número da versão padrão.

Para as versões disponíveis, consulte Índices do 2dsphere.

bits

inteiro

Opcional. Para índices 2d, o número de precisão do valor geohash armazenado dos dados de localização.

O valor de bits varia de 1 a 32, inclusive. O valor padrão é 26.

min

número

Opcional. Para índices 2d, o limite inferior inclusivo para os valores de longitude e latitude. O valor padrão é -180.0.

max

número

Opcional. Para índices 2d, o limite de inclusão superior para os valores de longitude e latitude. O valor padrão é 180.0.

collation

documento

Opcional. Especifica o agrupamento do índice.

A colocação permite que os usuários especifiquem regras específicas do idioma para comparação de strings, como regras para letras maiúsculas e marcas de acento.

Se você especificou um agrupamento no nível da coleção, então:

Se você não especificar um agrupamento ao criar o índice, o MongoDB criará o índice com o agrupamento padrão da coleção.
Se você especificar um agrupamento ao criar o índice, o MongoDB criará o índice com o agrupamento especificado.

A opção de agrupamento tem a seguinte sintaxe:

collation: {
   locale: <string>,
   caseLevel: <boolean>,
   caseFirst: <string>,
   strength: <int>,
   numericOrdering: <boolean>,
   alternate: <string>,
   maxVariable: <string>,
   backwards: <boolean>
}

Ao especificar agrupamento, o campo locale é obrigatório; todos os outros campos de agrupamento são opcionais. Para obter descrições dos campos, consulte Documento de agrupamento.

wildcardProjection

documento

Opcional.

Permite que os usuários incluam ou excluam caminho do campo específicos de um índice curinga usando o padrão de chave { "$**" : 1}. Essa opção só é válida se você criar um índice curinga em todos os campos do documento. Você não pode especificar essa opção ao criar um índice curinga em um caminho de campo específico e seus subcampos, por exemplo { "path.to.field.$**" : 1 }

A opção wildcardProjection tem o seguinte formato:

wildcardProjection: {
  "path.to.field.a" : <value>,
  "path.to.field.b" : <value>
}

O <value> pode ser um dos seguintes:

1 ou true para incluir o campo no índice curinga.
0 ou false para excluir o campo do índice curinga.

Os índices curinga omitem o campo _id por padrão. Para incluir o campo _id no índice curinga, você deve explicitamente incluí-lo no documento wildcardProjection :

{
  "wildcardProjection" : {
    "_id" : 1,
    "<field>" : 0|1
  }
}

Todas as declarações no documento wildcardProjection devem ser declarações de inclusão ou de exclusão. Você também pode incluir o campo _id com declarações de exclusão. Esta é a única exceção à regra.

mongosh provides the methods db.collection.createIndex() and db.collection.createIndexes() as wrappers for the createIndexes command.

Considerações

O MongoDB não permite a criação de índices da versão 0.

Nomes de índice

The createIndexes command and mongosh helpers db.collection.createIndex() and db.collection.createIndexes() report an error if you create an index with one name, and then try to create the same index again but with another name.

{
   "ok" : 0,
   "errmsg" : "Index with name: x_1 already exists with a different name",
   "code" : 85,
   "codeName" : "IndexOptionsConflict"
}

Em versões anteriores, o MongoDB não recriava o índice, mas retornava um objeto de resposta com valor ok de 1 e uma observação de que o índice não foi recriado. Por exemplo:

{
   "numIndexesBefore" : 2,
   "numIndexesAfter" : 2,
   "note" : "all indexes already exist",
   "ok" : 1
}

Conjuntos de Réplicas e Clusters Compartilhados

Observação

Exige featureCompatibilityVersion 4.4+

Cada mongod no conjunto de réplica ou agrupamento fragmentado deve ter featureCompatibilityVersion configurado para pelo menos 4.4 para iniciar construções de índice simultaneamente entre membros do conjunto de réplicas.

Construir índices em um conjunto de réplicas ou cluster particionado é feito simultaneamente em todos os membros do conjunto de réplicas que contêm dados. Para clusters fragmentados, a construção de índices ocorre somente em fragmentos que contêm dados para a coleção que está sendo indexada. O primário requer um número mínimo de membros de dados voting (ou seja, quórum para a confirmação), incluindo ele próprio, que deve concluir a construção antes de marcar o índice como pronto para uso. Consulte Construções de Índice em Ambientes Replicados para obter mais informações.

Para iniciar uma construção de índice com um commit quorum não padrão, especifique o commitQuorum.

Use o comando setIndexCommitQuorum para modificar o quórum para a confirmação de uma compilação de índice em andamento.

Tipos de agrupamento e índice

Os índices a seguir oferecem suporte apenas à comparação binária simples e não oferecem suporte ao agrupamento:

Text indexes
2d indexes

Dica

Para criar um índice text ou 2d em uma collection que tem um agrupamento não simples, você deve especificar explicitamente {collation: {locale: "simple"} } ao criar o índice.

Stable API

Ao usar a API estável V1:

Você não pode especificar nenhum dos seguintes campos na array indexes:
- background
- bucketSize
- sparse
- storageEngine
Não é possível criar índices de texto.
Os tipos de índice não suportados acima são ignorados pelo planejador de query no modo strict. Por exemplo, tentar usar um índice sparse com cursor.hint() resultará no seguinte erro BadValue :
planner returned error :: caused by :: hint provided does not correspond to an existing index

Comportamento

Concurrency

For featureCompatibilityVersion "4.2", createIndexes uses an optimized build process that obtains and holds an exclusive lock on the specified collection at the start and end of the index build. All subsequent operations on the collection must wait until createIndexes releases the exclusive lock. createIndexes allows interleaving read and write operations during the majority of the index build.

Para featureCompatibilityVersion, "4.0" o utilizacreateIndexes o4 pré-.2 processo de compilação do índice que, por padrão, obtém um bloqueio exclusivo no banco de dados pai por toda a duração do processo de compilação. O4 2 processo de construção pré-. bloqueia todas as operações no banco de dados e todas as suas coleções até que a operação seja concluída. Osbackground índices não aceitam um bloqueio exclusivo.

For more information on the locking behavior of createIndexes, see Index Builds on Populated Collections.

Importante

If a data-bearing voting node becomes unreachable and the commitQuorum is set to the default votingMembers, index builds can hang until that node comes back online.

Limite de uso da memória

createIndexes permite criar um ou mais índices em uma collection. usa uma combinação de memória e arquivos temporários no disco para criar índices. O limite de memória padrãocreateIndexes é 200 megabytes por comando, compartilhados igualmente entre todos os índices construídos nesse comando. Por exemplo, se você createIndexes construir 10 índices com um comando, o MongoDB alocará cada createIndexes índice 20 megabytes para o processo de construção de índice ao utilizar o limite de memória padrão 200 do. Quando você atinge o limite de memória, o MongoDB cria arquivos temporários no _tmp subdiretório dentro de para concluir a --dbpath compilação.

Ajuste o limite de memória com o parâmetromaxIndexBuildMemoryUsageMegabytes. O aumento desse parâmetro só é necessário em casos raros, como quando você executa muitas compilações simultâneas de índice com um único comandocreateIndexesou quando indexa um conjunto de dados maior que 500GB.

Cada comandocreateIndexestem um limite demaxIndexBuildMemoryUsageMegabytes. Ao usar omaxNumActiveUserIndexBuildspadrão de 3, o uso total de memória para todas as compilações de índice simultâneas pode chegar a até 3 vezes o valor demaxIndexBuildMemoryUsageMegabytes.

Opções de índice

Non-Hidden Option

A opção oculta pode ser alterada sem que seja necessário descartar e recriar o índice. Consulte Opção oculta.

Alterando opções de índice

Collation options on an existing index can be updated. To change other index options, drop the existing index with db.collection.dropIndex() then run createIndexes with the new options.

Opção de agrupamento

Você pode criar vários índices na(s) mesma(s) chave(s) com diferentes agrupamentos. Para criar indexes com o mesmo padrão de chave, mas com agrupamentos diferentes, você deve fornecer nomes de índice exclusivos.

Se você especificou um agrupamento no nível da coleção, então:

Se você não especificar um agrupamento ao criar o índice, o MongoDB criará o índice com o agrupamento padrão da coleção.
Se você especificar um agrupamento ao criar o índice, o MongoDB criará o índice com o agrupamento especificado.

Dica

Ao especificar um agrupamento strength de 1 ou 2, você pode criar um índice que não diferencia maiúsculas de minúsculas. O índice com um agrupamento strength de 1 não diferencia letras diacríticas e maiúsculas de minúsculas.

Para usar um índice para comparações de strings, uma operação também deve especificar o mesmo agrupamento. Ou seja, um índice com ordenação não pode suportar uma operação que executa comparações de strings nos campos indexados se a operação especificar uma ordenação diferente.

Aviso

As chaves de índice com reconhecimento de agrupamento podem ser maiores do que as chaves de índice para índices sem agrupamento porque os índices configurados com agrupamento usam chaves de agrupamento ICU para obter a ordem de classificação.

Opção oculta

To change the hidden option for existing indexes, you can use the following mongosh methods:

Por exemplo,

Para alterar a opção hidden para um índice para true, utilize o método db.collection.hideIndex():
db.restaurants.hideIndex( { borough: 1, ratings: 1 } );
Para alterar a opção hidden para um índice para false, utilize o método db.collection.unhideIndex():
db.restaurants.unhideIndex( { borough: 1, city: 1 } );

Dica

Hidden Indexes

Índices curinga

Os índices curinga omitem o campo _id por padrão. Para incluir o campo _id no índice curinga, você deve explicitamente incluí-lo no documento wildcardProjection :
{ "wildcardProjection" : { "_id" : 1, "<field>" : 0|1 } }
Todas as declarações no documento wildcardProjection devem ser declarações de inclusão ou de exclusão. Você também pode incluir o campo _id com declarações de exclusão. Esta é a única exceção à regra.
Os índices curinga não suportam:
Os índices curinga são índices esparsos . Eles não oferecem suporte a queries quando um campo indexado não existe. Um índice curinga indexará o documento se o campo curinga tiver um valor null.

A partir do MongoDB 7.0, os índices curinga suportam ordem crescente (1) e decrescente (-1). As versões anteriores suportavam apenas ordem crescente.

Para saber mais, consulte:

Transações

Você pode criar coleção e índices dentro de uma transação distribuída se a transação não for uma transação de gravação cross-fragmento.

To use createIndexes in a transaction, the transaction must use read concern "local". If you specify a read concern level other than "local", the transaction fails.

Dica

Crie coleções e índices em uma transação

Quorum para o Commit Comparado com Write Concern

Há diferenças importantes entre quoruns para o commit e write concerns:

Construções de índice usam quóruns para a confirmação.
As operações de gravação usam write concerns.

Cada nó portador de dados em um cluster é um membro votante.

O quorum para o commit especifica quantos membros votantes com dados, ou quais membros votantes, incluindo o primário, devem estar preparados para confirmar uma construção de índice simultânea. antes que o primário execute o commit.

A write concern é o nível de reconhecimento de que a gravação se propagou para o número especificado de instâncias.

Changed in version 8.0:

O quorum de confirmação especifica quantos nós devem estar prontos para concluir a construção de índice antes que o primário faça a confirmação da construção de índice. Em contraste, quando o primário tiver confirmado a construção de índice, a write concern especifica quantos nós devem replicar a entrada do oplog de construção de índice antes que o comando retorne sucesso.

Em versões anteriores, quando o primário confirmava a criação do índice, a preocupação de gravação especificava quantos nós deveriam finalizar a criação do índice antes que o comando retornasse sucesso.

Exemplo

O seguinte comando constrói dois índices na coleção inventory do banco de dados products:

db.getSiblingDB("products").runCommand(
  {
    createIndexes: "inventory",
    indexes: [
        {
            key: {
                item: 1,
                manufacturer: 1,
                model: 1
            },
            name: "item_manufacturer_model",
            unique: true
        },
        {
            key: {
                item: 1,
                supplier: 1,
                model: 1
            },
            name: "item_supplier_model",
            unique: true
        }
    ],
    writeConcern: { w: "majority" }
  }
)

Quando a criação de índices for concluída, o MongoDB gera um documento de resultados que inclui um status de "ok" : 1.

Criar um Índice Curinga

Observação

Para obter a documentação completa sobre índices Curinga, consulte Índices Curinga.

As seguintes listas listam exemplos de criação de índice coringa:

Criar um Índice Curinga em um Caminho de Campo Único
Crie um Índice Curinga em Todos os Caminhos de Campo
Crie um índice curinga em vários caminhos do campo específicos
Crie um índice curinga que exclua vários caminhos de campo específicos

Criar um Índice Curinga em um Caminho de Campo Único

Considere uma coleção products_catalog onde os documentos podem conter um campo product_attributes. O campo product_attributes pode conter campos aninhados arbitrários, incluindo documentos incorporados e arrays:

db.products_catalog.insertMany( [
  {
    _id : ObjectId("5c1d358bf383fbee028aea0b"),
    product_name: "Blaster Gauntlet",
    product_attributes: {
      price: {
        cost: 299.99,
        currency: "USD"
      }
    }
  },
  {
    _id: ObjectId("5c1d358bf383fbee028aea0c"),
    product_name: "Super Suit",
    product_attributes: {
      superFlight: true,
      resistance: [ "Bludgeoning", "Piercing", "Slashing" ]
    }
  }
] )

A seguinte operação cria um índice curinga no campo product_attributes :

use inventory
db.runCommand(
  {
    createIndexes: "products_catalog",
    indexes: [
      {
        key: { "product_attributes.$**" : 1 },
        name: "wildcardIndex"
      }
    ]
  }
)

Com este índice curinga, MongoDB indexa todos os valores escalares de product_attributes. Se um campo for um documento ou array aninhado, o índice curinga recorrerá ao documento/array e indexará todos os campos escalares no documento/array.

O índice curinga pode suportar queries arbitrárias de campo único no product_attributes ou um de seus campos aninhados:

db.products_catalog.find( { "product_attributes.superFlight" : true } )
db.products_catalog.find( { "product_attributes.maxSpeed" : { $gt : 20 } } )
db.products_catalog.find( { "product_attributes.elements" : { $eq: "water" } } )

Observação

A sintaxe do índice curinga específico do caminho é incompatível com a opção wildcardProjection. Consulte a documentação do parâmetro para obter mais informações.

Crie um Índice Curinga em Todos os Caminhos de Campo

db.products_catalog.insertMany( [
  {
    _id : ObjectId("5c1d358bf383fbee028aea0b"),
    product_name: "Blaster Gauntlet",
    product_attributes: {
      price: {
        cost: 299.99,
        currency: "USD"
      }
    }
  },
  {
    _id: ObjectId("5c1d358bf383fbee028aea0c"),
    product_name: "Super Suit",
    product_attributes: {
      superFlight: true,
      resistance: [ "Bludgeoning", "Piercing", "Slashing" ]
    }
  }
] )

A seguinte operação cria um índice curinga em todos os campos escalares (excluindo o campo _id):

use inventory
db.runCommand(
  {
    createIndexes: "products_catalog",
    indexes: [
      {
        key: { "$**" : 1 },
        name: "wildcardIndex"
      }
    ]
  }
)

Com esse índice curinga, o MongoDB indexa todos os campos escalares para cada documento na coleção. Se um determinado campo for um documento ou array aninhada, o índice curinga recorrerá ao documento/array e indexará todos os campos escalares no documento/array.

O índice criado pode suportar queries em qualquer campo arbitrário dentro de documentos na coleção:

db.products_catalog.find( { "product_price" : { $lt : 25 } } )
db.products_catalog.find( { "product_attributes.elements" : { $eq: "water" } } )

Observação

Os índices curinga omitem o campo _id por padrão. Para incluir o campo _id no índice curinga, você deve explicitamente incluí-lo no documento wildcardProjection. Consulte a documentação do parâmetro para obter mais informações.

Crie um índice curinga em vários caminhos do campo específicos

db.products_catalog.insertMany( [
  {
    _id : ObjectId("5c1d358bf383fbee028aea0b"),
    product_name: "Blaster Gauntlet",
    product_attributes: {
      price: {
        cost: 299.99,
        currency: "USD"
      }
    }
  },
  {
    _id: ObjectId("5c1d358bf383fbee028aea0c"),
    product_name: "Super Suit",
    product_attributes: {
      superFlight: true,
      resistance: [ "Bludgeoning", "Piercing", "Slashing" ]
    }
  }
] )

A seguinte operação cria um índice curinga e usa a opção wildcardProjection para incluir somente valores escalares dos campos product_attributes.elements e product_attributes.resistance no índice.

use inventory
db.runCommand(
  {
    createIndexes: "products_catalog",
    indexes: [
      {
        key: { "$**" : 1 },
        "wildcardProjection" : {
          "product_attributes.elements" : 1,
          "product_attributes.resistance" : 1
        },
        name: "wildcardIndex"
      }
    ]
  }
)

Enquanto o padrão de chave "$**" abrange todos os campos do documento, o campo wildcardProjection limita o índice apenas aos campos incluídos e seus campos aninhados.

Se um campo for um documento ou array aninhado, o índice curinga recorrerá ao documento/array e indexará todos os campos escalares no documento/array.

O índice criado pode suportar queries em qualquer campo escalar incluído no wildcardProjection:

db.products_catalog.find( { "product_attributes.elements" : { $eq: "Water" } } )
db.products_catalog.find( { "product_attributes.resistance" : "Bludgeoning" } )

Observação

Os índices wildcard não suportam a combinação de instruções de inclusão e exclusão no documento wildcardProjection , exceto quando se inclui explicitamente o campo _id. Para obter mais informações sobre wildcardProjection, consulte a documentação do parâmetro.

Crie um índice curinga que exclua vários caminhos de campo específicos

db.products_catalog.insertMany( [
  {
    _id : ObjectId("5c1d358bf383fbee028aea0b"),
    product_name: "Blaster Gauntlet",
    product_attributes: {
      price: {
        cost: 299.99,
        currency: "USD"
      }
    }
  },
  {
    _id: ObjectId("5c1d358bf383fbee028aea0c"),
    product_name: "Super Suit",
    product_attributes: {
      superFlight: true,
      resistance: [ "Bludgeoning", "Piercing", "Slashing" ]
    }
  }
] )

A seguinte operação cria um índice curinga e utiliza o documento wildcardProjection para indexar todos os campos escalares para cada documento na coleção, excluindo os campos product_attributes.elements e product_attributes.resistance:

use inventory
db.runCommand(
  {
    createIndexes: "products_catalog",
    indexes: [
      {
        key: { "$**" : 1 },
        "wildcardProjection" : {
           "product_attributes.elements" : 0,
           "product_attributes.resistance" : 0
        },
        name: "wildcardIndex"
      }
    ]
  }
)

Enquanto o padrão de chave "$**" abrange todos os campos no documento, o campo wildcardProjection exclui os campos especificados do índice.

Se um campo for um documento ou array aninhado, o índice curinga recorrerá ao documento/array e indexará todos os campos escalares no documento/array.

O índice criado pode suportar queries em qualquer campo escalar exceto aquelas excluídas por wildcardProjection:

db.products_catalog.find( { "product_attributes.maxSpeed" : { $gt: 25 } } )
db.products_catalog.find( { "product_attributes.superStrength" : true } )

Observação

Criar Índice com Commit Quorum

Observação

Exige featureCompatibilityVersion 4.4+

To set the commit quorum, use createIndexes to specify the commitQuorum value.

commitQuorum especifica quantos nós votantes portadores de dados, ou quais nós votantes, incluindo o primário, devem estar preparados para confirmar a construção do índice antes que o primário execute o commit. O commit quorum padrão é votingMembers, o que significa todos os nós portadores de dados.

The following operation creates an index with a commit quorum of "majority", or a simple majority of data-bearing members:

db.getSiblingDB("examples").runCommand(
  {
    createIndexes: "invoices",
    indexes: [
      {
        key: { "invoices" : 1 },
        "name" : "invoiceIndex"
      }
    ],
    "commitQuorum" : "majority"
  }
)

A construção do índice de notas primário ficou pronta somente após a maioria simples dos membros votantes portadores de dados " votarem em" para confirmar a criação do índice. Para obter mais informações sobre a criação de índices e o processo de votação, consulte Construções de índices em ambientes replicados.

Saída

The createIndexes command returns a document that indicates the success of the operation. The document contains some but not all of the following fields, depending on outcome:

createIndexes.createdCollectionAutomatically: Se true, a collection não existiu e foi criada no processo de criação do índice.

createIndexes.numIndexesBefore: O número de índices no início do comando.

createIndexes.numIndexesAfter: O número de índices no final do comando.

createIndexes.ok: Um valor de 1 indica que os índices estão em vigor. Um valor de 0 indica um erro.

createIndexes.note: Este note será retornado se já existir um índice ou índices existentes. Isso indica que o índice não foi criado ou alterado.

createIndexes.errmsg: Retorna informações sobre quaisquer erros.

createIndexes.code: O código de erro que representa o tipo de erro.

Exemplo de saída

O seguinte bloco de código ilustra um exemplo da saída createIndexes em um cluster fragmentado. Em um cluster fragmentado, createIndexes gera um documento incorporado raw que contém um documento para cada fragmento em que o índice é criado. As chaves do documento incorporado raw são concatenações do ID do fragmento, do nome do host e da porta dos nós individuais que compõem o fragmento.

{
  raw: {
    'atlas-2m11gv-shard-1/atlas-2m11gv-shard-01-00.cpfgx.mongodb.net:27017,atlas-2m11gv-shard-01-01.cpfgx.mongodb.net:27017,atlas-2m11gv-shard-01-02.cpfgx.mongodb.net:27017': {
      numIndexesBefore: 3,
      numIndexesAfter: 5,
      createdCollectionAutomatically: false,
      commitQuorum: 'votingMembers',
      ok: 1
    },
    'atlas-2m11gv-shard-0/atlas-2m11gv-shard-00-00.cpfgx.mongodb.net:27017,atlas-2m11gv-shard-00-01.cpfgx.mongodb.net:27017,atlas-2m11gv-shard-00-02.cpfgx.mongodb.net:27017': {
      numIndexesBefore: 3,
      numIndexesAfter: 5,
      createdCollectionAutomatically: false,
      commitQuorum: 'votingMembers',
      ok: 1
    }
  },
  ok: 1,
  '$clusterTime': {
    clusterTime: Timestamp({ t: 1743624296, i: 7 }),
    signature: {
      hash: Binary.createFromBase64('22j0GK8SIK806T+0OdCY6qYHocM=', 0),
      keyId: Long('7438621020069560323')
    }
  },
  operationTime: Timestamp({ t: 1743624296, i: 7 })
}

Voltar

criar

operação atual