Indexes

Cobertura e desempenho da query

Quando você executa uma query no MongoDB, seu comando pode incluir vários elementos:

• Critérios de query que especificam campos e valores que você está procurando

• Opções que afetam a execução da query, como a read concern

• Critérios de projeção para especificar os campos retornos MongoDB (opcional)

• Classificar critérios para especificar a ordem dos documentos devolvidos do MongoDB (opcional)

Quando todos os campos especificados na query, projeção e classificação encontram-se no mesmo índice, o MongoDB gera resultados diretamente do índice, também chamado de query coberta.

name_1_age_-1

Para ver mais informações sobre como garantir que seu índice cubra seus critérios de query e projeção, consulte os artigos do manual do MongoDB sobre cobertura de query.

Considerações operacionais

Para melhorar o desempenho da query, crie índices em campos que aparecem com frequência nas queries e operações do seu aplicativo que retornam resultados ordenados. Cada índice adicionado consome espaço em disco e memória quando ativo, portanto, recomendamos que você rastreie a memória do índice e o uso do disco para o planejamento da capacidade. Além disso, quando uma operação de gravação atualiza um campo indexado, MongoDB atualiza o índice relacionado.

Como o MongoDB oferece suporte a esquemas dinâmicos, os aplicativos podem executar a query dos campos cujos nomes não podem ser conhecidos antecipadamente ou são arbitrários. O MongoDB 4.2 introduziu índices curinga para ajudar a suportar essas queries. Os índices curinga não são projetados para substituir o planejamento de índice baseado em carga de trabalho.

Para obter mais informações sobre como projetar seu modelo de dados e escolher os índices apropriados para seu aplicativo, consulte Modelagem de dados e índices do MongoDB Server.

Campo único e índices compostos

String resultCreateIndex = collection.createIndex(Indexes.ascending("title"));
System.out.println(String.format("Index created: %s", resultCreateIndex));

Bson filter = eq("title", "Batman");
Bson sort = Sorts.ascending("title");
Bson projection = fields(include("title"), excludeId());
FindIterable<Document> cursor = collection.find(filter).sort(sort).projection(projection);

String resultCreateIndex = collection.createIndex(Indexes.ascending("type", "rated"));
System.out.println(String.format("Index created: %s", resultCreateIndex));

Bson filter = and(eq("type", "movie"), eq("rated", "G"));
Bson sort = Sorts.ascending("type", "rated");
Bson projection = fields(include("type", "rated"), excludeId());
FindIterable<Document> cursor = collection.find(filter).sort(sort).projection(projection);

Índices de várias teclas (índices em campos de array)

Os índices de várias chaves são índices que melhoram o desempenho de queries que especificam um campo com um índice que contém um valor de array. Você pode definir um índice de múltiplas chaves utilizando a mesma sintaxe de um único campo ou índice composto.

O exemplo a seguir cria um índice composto de várias chaves nos campos rated, genres (uma array de Strings) e title :

String resultCreateIndex = collection.createIndex(Indexes.ascending("rated", "genres", "title"));
System.out.println(String.format("Index created: %s", resultCreateIndex));

A seguir, um exemplo de uma query coberta pelo índice criado no trecho de código anterior:

Bson filter = and(eq("genres", "Animation"), eq("rated", "G"));
Bson sort = Sorts.ascending("title");
Bson projection = fields(include("title", "rated"), excludeId());
FindIterable<Document> cursor = collection.find(filter).sort(sort).projection(projection);

Os índices multicamadas se comportam de forma diferente de outros índices em termos de cobertura de consulta, computação vinculada a índice e comportamento de classificação. Para saber mais sobre índices de várias chaves, incluindo uma discussão sobre seu comportamento e limitações, consulte a página Índices de várias chaves no manual do MongoDB.

Atlas Search e índices de Vector Search

Você pode gerenciar programaticamente seus índices do Atlas Search e Atlas Vector Search usando o driver Java .

O recurso Atlas Search permite realizar pesquisas de texto completo em collections hospedadas no MongoDB Atlas. Para saber mais sobre o MongoDB Atlas Search, consulte a documentação dos índices do Atlas Search.

O Atlas Vector Search permite realizar pesquisas semânticas em incorporações vetoriais armazenadas no MongoDB Atlas. Para saber mais sobre o Atlas Vector Search, consulte a seção doAtlas Vector Search no guia do Aggregates Builder.

Você pode chamar os seguintes métodos em uma coleção para gerenciar seus índices Atlas Search e Vector Search :

• createSearchIndex() (válido somente para índices do Atlas Search )

• createSearchIndexes()

• listSearchIndexes()

• updateSearchIndex()

• dropSearchIndex()

As seções a seguir fornecem exemplos de código que demonstram como usar cada um dos métodos anteriores.

Document searchIdx = new Document("mappings",
        new Document("dynamic", true));
collection.createSearchIndex("myIndex", searchIdx);

SearchIndexModel searchIdxMdl = new SearchIndexModel(
    "searchIdx",
    new Document("analyzer", "lucene.standard").append(
        "mappings", new Document("dynamic", true)),
    SearchIndexType.search()
);
SearchIndexModel vectorSearchIdxMdl = new SearchIndexModel(
    "vsIdx",
    new Document(
        "fields",
        Arrays.asList(
            new Document("type", "vector")
                .append("path", "embeddings")
                .append("numDimensions", 1536)
                .append("similarity", "dotProduct")
        )
    ),
    SearchIndexType.vectorSearch()
);
collection.createSearchIndexes(
    Arrays.asList(searchIdxMdl, vectorSearchIdxMdl)
);

try (MongoCursor<Document> resultsCursor = collection.listSearchIndexes().iterator()) {
    while (resultsCursor.hasNext()) {
        System.out.println(resultsCursor.next());
    }
}

collection.updateSearchIndex("myIndex",
        new Document("analyzer", "lucene.simple").append(
                "mappings",
                new Document("dynamic", false)
                        .append("fields",
                                new Document("title",
                                        new Document("type", "string")))
        )
);

collection.dropSearchIndex("myIndex");

Text Indexes

Os índices de texto suportam queries de pesquisa de texto no conteúdo de string. Esses índices podem incluir qualquer campo cujo valor seja uma string ou uma array de elementos de string. O MongoDB suporta pesquisa de texto para vários idiomas. Você pode especificar o idioma padrão como uma opção ao criar o índice.

try {
    String resultCreateIndex = collection.createIndex(Indexes.text("plot"));
    System.out.println(String.format("Index created: %s", resultCreateIndex));
// Prints a message if a text index already exists with a different configuration 
} catch (MongoCommandException e) {
    if (e.getErrorCodeName().equals("IndexOptionsConflict"))
        System.out.println("there's an existing text index with different options");
}

Bson filter = text("java coffee shop");
Bson projection = fields(include("fullplot"), excludeId());
FindIterable<Document> cursor = collection.find(filter).projection(projection);

collection.createIndex(Indexes.compoundIndex(Indexes.text("title"), Indexes.text("genre")));

Índices geoespaciais

O MongoDB suporta queries de dados de coordenadas geoespaciais utilizando índices 2dsphere. Com um índice do 2dsphere, você pode executar query de inclusão, interseção e proximidade nos dados geoespaciais. Para obter mais informações sobre query de dados geoespaciais, consulte a página Queries em dados geoespaciais.

Para criar um índice do 2dsphere , você deve especificar um campo que contém somente Objetos GeoJSON. Para mais detalhes sobre este tipo, consulte a página manual do MongoDB Server em Objetos GeoJSON.

O campo location.geo no seguinte documento de amostra da coleção theaters no banco de dados sample_mflix é um objeto de ponto GeoJSON que descreve as coordenadas do teatro:

{
   "_id" : ObjectId("59a47286cfa9a3a73e51e75c"),
   "theaterId" : 104,
   "location" : {
      "address" : {
         "street1" : "5000 W 147th St",
         "city" : "Hawthorne",
         "state" : "CA",
         "zipcode" : "90250"
      },
      "geo" : {
         "type" : "Point",
         "coordinates" : [
            -118.36559,
            33.897167
         ]
      }
   }
}

O seguinte exemplo cria um índice 2dsphere no campo location.geo:

try {
    String resultCreateIndex = collection.createIndex(Indexes.geo2dsphere("location.geo"));
    System.out.println(String.format("Index created: %s", resultCreateIndex));
// Prints a message if a geospatial index already exists with a different configuration 
} catch (MongoCommandException e) {
    if (e.getErrorCodeName().equals("IndexOptionsConflict"))
        System.out.println("there's an existing geospatial index with different options");
}

O seguinte é um exemplo de uma consulta geoespacial utilizando "location.geo" índice.

// Stores the coordinates of the NY MongoDB headquarters
Point refPoint = new Point(new Position(-73.98456, 40.7612));
// Retrieves documents that represent locations up to 1000 meters from the specified point directly from the geospatial index
// Creates a filter to match a document 
Bson filter = near("location.geo", refPoint, 1000.0, 0.0);
FindIterable<Document> cursor = collection.find(filter);

O MongoDB também suporta índices 2d para calcular distâncias em um plano euclidiano e para trabalhar com a sintaxe dos "legacy coordinate pairs" usada no MongoDB 2.2 e anteriores. Para obter mais informações, consulte a página de queries geoespaciais no manual do MongoDB Server.

Unique Indexes

Índices únicos garantem que os campos indexados não armazenem valores duplicados. Por padrão, o MongoDB cria um índice único no campo _id durante a criação de uma collection. Para criar um índice único, especifique o campo ou a combinação de campos em que você deseja evitar a duplicação e defina a opção unique para true.

O exemplo seguinte cria um índice descendente único no campo theaterId:

try {
    IndexOptions indexOptions = new IndexOptions().unique(true);
    String resultCreateIndex = collection.createIndex(Indexes.descending("theaterId"), indexOptions);
    System.out.println(String.format("Index created: %s", resultCreateIndex));
// Prints a message if the "theaterID" field contains duplicate values
} catch (DuplicateKeyException e) {
    System.out.printf("duplicate field values encountered, couldn't create index: \t%s\n", e);
}

E11000 duplicate key error index

Para obter mais informações, consulte a página Índices únicos no manual do MongoDB Server.

Índices curinga

Os índices curinga permitem queries em campos desconhecidos ou arbitrários. Esses índices podem ser benéficos se você estiver usando um esquema dinâmico.

O exemplo seguinte cria um índice curinga ascendente em todos os valores do campo location, incluindo valores aninhados em subdocumentos e arrays:

String resultCreateIndex = collection.createIndex(Indexes.ascending("location.$**")); 
System.out.println(String.format("Index created: %s", resultCreateIndex));

Para obter mais informações, consulte a página Índices curinga no manual do MongoDB Server.

Índices aglomerados

Os índices de cluster instruem a collection a armazenar documentos ordenados por um valor de chave. Para criar um índice de cluster, especifique a opção de índice de cluster com o campo _id como a chave e o campo único como true ao criar a collection.

O exemplo seguinte cria um índice agrupado no campo _id na coleção vendors:

MongoDatabase database = mongoClient.getDatabase("tea");
ClusteredIndexOptions clusteredIndexOptions = new ClusteredIndexOptions(new Document("_id", 1), true);
CreateCollectionOptions createCollectionOptions = new CreateCollectionOptions().clusteredIndexOptions(clusteredIndexOptions);
database.createCollection("vendors", createCollectionOptions);

Consulte as seções manuais do servidor MongoDB para obter mais informações:

• Índices clusterizados

• Clustered Collections

Remover um Índice usando um Documento de Especificação do Índice

Passe um documento de especificação de índice para o método dropIndex() para remover um índice de uma coleção. Um documento de especificação de índice é uma instância do Bson que especifica o tipo de índice em um campo especificado.

O seguinte trecho remove um índice ascendente no campo title em uma coleção:

collection.dropIndex(Indexes.ascending("title"));

Remover um índice usando um campo de nome

Passe o campo name do índice para o método dropIndex() para remover um índice de uma coleção.

Para localizar o nome do seu índice, utilize o método listIndexes() para visualizar o valor dos campos name em seus índices.

O trecho a seguir recupera e imprime todos os índices em uma coleção:

collection.listIndexes().forEach(doc -> System.out.println(doc.toJson()));

Se você chamar listIndex() em uma coleção que contém um índice de texto, a saída poderá se assemelhar ao seguinte:

{ "v": 2, "key": {"_id": 1}, "name": "_id_" }
{ "v": 2, "key": {"_fts": "text", "_ftsx": 1}, "name": "title_text", "weights": {"title": 1},
"default_language": "english", "language_override": "language", "textIndexVersion": 3 }

Essa saída nos informa que os nomes dos índices existentes são "_id" e "title_text".

O trecho a seguir remove o índice "title_text" da coleção:

collection.dropIndex("title_text");

Remover um índice usando um caractere curinga

A partir do MongoDB 4.2, você pode soltar todos os índices ligando para o método dropIndexes() em sua coleção:

collection.dropIndexes();

Para versões anteriores do MongoDB, passe "*" como parâmetro para sua chamada para dropIndex() em sua coleção:

collection.dropIndex("*");

Para obter mais informações sobre os métodos nesta seção, consulte a seguinte documentação da API:

• dropIndex()

• dropIndexes()