Para agentes de IA: um índice de documentação está disponível em https://www.mongodb.com/pt-br/docs/llms.txt — as versões de markdown de todas as páginas estão disponíveis anexando .md a qualquer caminho de URL.
Menu Docs
Página inicial do Docs
/ /
opções de pesquisa
Página inicial do Docs
/ /
Referência de query
/
opções de pesquisa
Página inicial do Docs
/
Desenvolvimento
/
Pesquisa
/
Queries e índices
/
Referência de query
/
opções de pesquisa

Classificar resultados da pesquisa do MongoDB

Visão geral

A Pesquisa do MongoDB permite classificar os resultados em ordem crescente ou decrescente nos campos definidos no índice do MongoDB Search. Você pode classificar pelos seguintes tipos de campo usando a opção sort:

  • boolean

  • date

  • number (valores inteiros, float e double)

  • objectId

  • uuid

  • string (indexado como o tipo de token)

Você também pode classificar pela pontuação dos documentos nos resultados e por valores nulos.

sort Compatibilidade de opções

O Atlas oferece suporte a queries de classificação não fragmentadas e fragmentadas em todas as versões principais e secundárias do MongoDB 7.0 e versões posteriores.

sort Limitações de opção

  • Você não pode classificar em campos do tipo embeddedDocuments.

  • Você não pode utilizar a opção sort com o operador obsoleto knnBeta.

Uso

Para classificar os resultados do MongoDB Search, você deve fazer o seguinte:

  1. Crie um índice do MongoDB Search nos campos para classificar os resultados.

    Para classificar em campos boolean, date, number, UUID, e objectId , use mapeamentos dinâmicos ou estáticos. Para classificar campos de string, você deve usar mapeamentos estáticos para indexar o campo como o tipo token.

  2. Create and run your query with the sort option against the fields you defined in the index for sorting. To learn more, see Syntax.

Comportamento

Classificar por campo booleano, de data, numérico, UUID, ObjectId ou string

The sort option takes a document that specifies the fields to sort by and the respective sort order. MongoDB Search follows the MongoDB comparison order for the supported data types. It treats UUID values like BinData. To learn more, see non-existent fields.

Você pode especificar a seguinte ordem de classificação para classificar seus resultados:

1

Classificar em ordem crescente.

Quando você classifica em ordem crescente, o MongoDB Search retorna documentos com valores ausentes antes de documentos com valores.

-1

Classificar em ordem decrescente.

Classificar por pontuação e um campo único

You can also sort by score in ascending or descending order. The sort option takes a document that specifies the $meta expression, which requires the searchScore value.

Exemplo

Suponha que seu aplicativo permita que os usuários pulem para a última página dos resultados da pesquisa. O exemplo a seguir classifica os resultados por pontuação em ordem crescente para que o documento com a pontuação mais baixa seja exibido na parte superior dos resultados:

sort: {score: {$meta: "searchScore", order: 1}}

Você pode usar sort para também garantir que os resultados tenham uma ordem determinada quando vários documentos nos resultados tiverem pontuações idênticas. Por exemplo, se você classificar os resultados por um campo exclusivo, como um campo de data chamado lastUpdated, conforme mostrado no exemplo a seguir, o MongoDB Search retornará resultados com pontuações idênticas em uma ordem determinada:

Exemplo

sort: {score: {$meta: "searchScore"}, lastUpdated: 1}

No entanto, se você não especificar um campo exclusivo para classificar os resultados, o MongoDB Search retornará os resultados classificados por pontuação em ordem decrescente. A Pesquisa do MongoDB retorna resultados com pontuações ou valores idênticos em uma ordem arbitrária. O exemplo a seguir não classifica os resultados por um campo exclusivo.

Exemplo

sort: {score: {$meta: "searchScore"}}

Para saber mais, consulte Pontuação dos documentos nos resultados.

arrays de classificação

O MongoDB Search nivela as arrays para classificação.

Exemplo

Considere a seguinte array:

[4, [1, [8,5], 9], 2]

A Pesquisa do MongoDB nivela a array anterior semelhante ao seguinte:

4, 1, 8, 5, 9, 2

Para uma classificação ascendente, o MongoDB Search usa 1 para comparar a array com outros valores. Para uma classificação decrescente, a Pesquisa MongoDB usa 9 para comparar a array com outros valores.

Ao comparar com elementos dentro de uma array:

  • Para uma classificação ascendente, o MongoDB Search compara os menores elementos da array ou executa uma comparação menor que (<).

    Exemplo

    A Pesquisa do MongoDB classifica os resultados na seguinte ordem se você classificar por números em ordem crescente:

    -20
    [-3, 12] // <- -3 comes before 5.
    5
    [6, 18]  // <- 6 comes after 5.
    13
    14

  • Para uma classificação decrescente, o MongoDB Search compara os maiores elementos da array ou executa uma comparação maior que (>).

    Exemplo

    A Pesquisa do MongoDB classifica os resultados na seguinte ordem se você classificar por números em ordem decrescente:

    [6, 18]  // <- 18 comes before 14.
    14
    13
    [-3, 12] // <- 12 comes after 13.
    5
    -20

Classificar arrays com vários tipos

When sorting over array fields that contain values of multiple BSON types, MongoDB Search selects a representative element from the array to use for comparison according to the MongoDB comparison and sort order by default.

  • Para uma classificação ascendente, o MongoDB Search usa o elemento com o menor tipo de BSON.

  • Para uma classificação decrescente, o MongoDB Search usa o elemento com o tipo de BSON mais alto.

Se houver vários valores do mesmo tipo BSON na array, o comportamento padrão de ordenação para o tipo selecionado se aplica.

Exemplo

Considere a seguinte array:

[ 'foo', null, 15, true, false ]

  • Para uma classificação ascendente, o MongoDB Search usa null, pois é o tipo de BSON mais baixo suportado.

  • Para uma classificação decrescente, o MongoDB Search usa true, pois é o tipo BSON mais alto na array, e o MongoDB Search classifica os valores true acima dos valores false.

No entanto, se você definir noData: highest em sua sintaxe sort, o MongoDB Search considerará valores nulos e ausentes como o tipo de BSON mais alto. Para a array de exemplo , o seguinte comportamento se aplica:

  • Para uma classificação ascendente, o MongoDB Search usa 15, pois agora é o tipo BSON mais baixo na array.

  • Para uma classificação decrescente, o MongoDB Search usa null, pois agora é o tipo BSON mais alto na array.

Para saber mais, consulte Classificar por Valores Nulos e Omitidos.

For an example, see Sort on Multi-Typed Arrays.

Classificar por Valores Nulos e Omitidos

A Pesquisa do MongoDB trata os valores nulos como iguais a valores ausentes e vazios, e a ordem dos documentos com esses valores não é determinística na classificação.

By default, MongoDB Search follows the MongoDB comparison and sort order and considers null values as lower than all other supported BSON types. Therefore, null values appear at the top of the results during an ascending sort and at the bottom during a descending sort.

To configure where null values appear in the results, specify the noData field in your sort syntax. The noData field takes the following values:

  • lowest (padrão): define valores nulos como o tipo de BSON mais baixo durante a classificação. Classifica valores nulos na parte superior dos resultados durante uma classificação ascendente e na parte inferior durante uma classificação descendente.

  • highest: define valores nulos como o tipo BSON mais alto durante a classificação. Classifica valores nulos na parte inferior dos resultados durante uma classificação ascendente e na parte superior durante uma classificação descendente.

Observação

O mesmo comportamento se aplica ao classificar arrays com vários tipos que contêm valores nulos ou ausentes.

Para obter exemplos, consulte Classificar por valores nulos e Classificar em arrays de vários tipos.

Classificar em campos de array de documentos incorporados

Para classificar os documentos-pai por um campo de documento incorporado, faça o seguinte:

  • Indexe os pais do campo filho do documento incorporado como o tipo de documento .

  • Indexe o campo secundário com valores de string dentro do documento incorporado como o tipo de token . Para campos secundários com valores numéricos e de data, habilite o mapeamento dinâmico para indexar esses campos automaticamente.

A Pesquisa do MongoDB classifica apenas em documentos principais. Não classifica os campos filhos em uma array de documentos. Para obter um exemplo, consulte Exemplo de classificação.

Considerações

Consistência

Os índices do MongoDB Search acabam sendo consistentes, e os valores retornados nos resultados podem ser diferentes dos valores usados na classificação.

Desempenho

This feature optimizes queries that use $search with $limit as a subsequent stage. If MongoDB Search needs to sort all documents in the collection, the response might be slow.

Pontuação

O MongoDB Search retorna pontuações para todos os documentos nos resultados. No entanto, você pode ver documentos com pontuação mais alta após documentos com pontuação mais baixa porque a ordem dos documentos nos resultados é baseada nos critérios de classificação, a menos que você classifique explicitamente por pontuação.

Sintaxe

sort tem a seguinte sintaxe:

1{
2  "$search": {
3    "index": "<index name>", // optional, defaults to "default"
4    "<operator>": { // such as "text", "compound", or "phrase"
5      <operator-specification>
6    },
7    "sort": {
8      score: {$meta: "searchScore"}, // optional field
9      "<field-to-sort>": <sort-order>, // 1 or -1, or a document
10      ...
11    }
12  }
13}
Parâmetro
Descrição

score

Optional. Determines whether to sort by the search score. To learn more, see Sort by Score And a Unique Field.

<field-to-sort>

Obrigatório. O nome do campo pelo qual classificar.

<sort-order>

Obrigatório. Determina a ordem de classificação. Use 1 para ordem crescente e -1 para ordem decrescente.

If you want to specify the noData field, use a document with the following syntax:

"<field-to-sort>": {
  order: 1 | -1, // required field
  noData: "lowest" | "highest" // optional field
},
...

Exemplos

Os exemplos a seguir usam o sample_mflix.movies, sample_airbnb.listingsAndReview ou uma coleção personalizada chamada users.

Definição de Índice

As consultas de exemplo nesta página usam o sample_mflix.movies, o sample_airbnb.listingsAndReviewou uma coleção personalizada. Se você criar os seguintes índices nessas coleções, poderá executar as consultas de amostra em relação aos campos indexados.

Pesquisa e classificação de data

A seguinte query mostra como executar uma query de operador composto e classificar os resultados por campo de data. Ela usa os seguintes operadores:

  • operador curinga para procurar títulos de filmes que comecem com Summer.

  • operador próximo para pesquisar filmes que foram lançados em e cerca de cinco meses antes ou depois de 18 de abril de 2014.

    Observação

    Quando você utiliza pivot em um campo de data, sua unidade de medida é em milissegundos. O MongoDB Search calcula uma pontuação para cada documento com base na proximidade do campo de data da data especificada. Para saber mais, veja próximo.

A consulta utiliza os seguintes estágios de pipeline:

  • $search estágio para pesquisar os campos title e released e, em seguida, classificar os resultados pelo campo released em ordem decrescente.

  • $limit stage to limit the output to 5 results.

  • $project estágio para:

    • Excluir todos os campos, exceto title e released.

    • Adicione um campo denominado score.

Pesquisa e classificação de números

A seguinte query mostra como classificar os resultados por um campo numérico. Ela usa o operador de faixa para procurar filmes que ganharam 10 ou mais prêmios e, em seguida, classifica os resultados pelo valor do campo numérico em ordem decrescente.

A consulta utiliza os seguintes estágios de pipeline:

  • Estágio $search para pesquisar o campo awards.wins e classificar os resultados em ordem decrescente.

  • $limit stage to limit the output to 5 results.

  • $project stage to exclude all fields except title and awards.wins.

Pesquisa e classificação de strings

Exemplo básico

A query a seguir no namespace sample_mflix.movies usa o estágio $search para fazer o seguinte:

  • Procure filmes que tenham o termo country no título.

  • Classifique os resultados em ordem crescente usando a opção sort.

The query uses the $limit stage to limit the output to 5 documents. It also uses the $project stage to do the following:

  • Omitir todos os campos exceto title nos resultados.

  • Adicione um campo denominado score.

db.movies.aggregate([
  {
    "$search": {
      "text": {
        "path": "title",
        "query": "country"
      },
      "sort": {
        "title": 1
      }
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])

Exemplo de pesquisa e classificação composta com curingas

A seguinte consulta mostra como consultar e classificar os resultados por um campo de cadeia de caracteres. Procura títulos que começam com Prance ou Prince e classifica os resultados pelo campo title em ordem crescente.

A consulta utiliza os seguintes estágios de pipeline:

  • $search para pesquisar o campo title utilizando a cláusula should com o operador wildcard para pesquisar títulos que começam com Prance e Prince. A consulta também especifica que os resultados devem ser classificados pelo campo title em ordem crescente.

  • $limit stage to limit the output to 5 results.

  • $project estágio para:

    • Excluir todos os campos, exceto title.

    • Adicione um campo denominado score.

Exemplo de classificação sem distinção entre maiúsculas e minúsculas

A seguinte query mostra como classificar os resultados independentemente das letras maiúsculas e minúsculas. Ele usa o operador text para pesquisar filmes que tenham o termo train no campo title e, em seguida, classifica os resultados pelo valor do campo title em ordem crescente.

The query specifies a $limit stage to limit the documents in the results to 5 and a $project stage to do the following:

  • Inclua somente os campos _id, title e awards nos resultados.

  • Adicione um campo chamado pontuação nos resultados.

Ordenar por ObjectId

A consulta a seguir usa o operador de intervalo para pesquisar o campo released na coleção sample_mflix.movies para filmes lançados entre 2015-01-01 e 2015-12-31. Ele classifica os resultados pelo campo _id , que contém o valor do tipo ObjectId, em ordem decrescente.

db.movies.aggregate([
  {
    "$search": {
      "range": {
        "path": "released",
        "gt": ISODate("2015-01-01T00:00:00.000Z"),
        "lt": ISODate("2015-12-31T00:00:00.000Z")
      },
      "sort": {
        "_id": -1
      }
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 1,
      "title": 1,
      "released": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])

Ordenar por UUID

A query a seguir pesquisa o termo hello no campo b na coleção users. A query ordena os resultados pelo campo a, que contém dados polimórficos (para demonstrar a ordem de classificação), em ordem crescente.

db.users.aggregate([
  {
    "$search": {
      "text": {
        "path": "b",
        "query": "hello"
      },
      "sort": {
        "a": 1
      }
    }
  },
  {
    "$project": {
      "_id": 1,
      "a": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])

Ordenar por valores nulos

Considere as seguintes queries que pesquisam b o campo para a string hello na users collection usando o operador de texto. Em seguida, a query classifica os resultados por campo c, que contém valores nulos ou ausentes para alguns documentos na collection.

Para saber mais, consulte Classificar por Valores Nulos e Omitidos.

Observação

A configuração noData: lowest é igual ao padrão.

A ordem dos documentos com "_id": 4, "_id": 5 e "_id": 6 é aleatória porque o MongoDB Search trata os valores nulos e ausentes como iguais ao classificar.

Classificar em arrays de vários tipos

Consider the following queries on the users collection given an additional document with a multi-typed array in field c:

db.users.insertOne({
  "_id": 7,
  "a": UUID("03e32aa9-1cbd-43b8-b9d6-18b171a03cc7"),
  "b": "hello",
  "c": [ false, null, 15 ]
})

As queries a seguir pesquisam b o campo para a string hello usando o operador de texto e classificam os resultados por c campo.

Observação

A noData: lowest configuração em sua sintaxe de classificação é igual ao padrão.

As queries a seguir especificam noData: highest para definir valores nulos como o tipo BSON mais alto durante a ordenação.

Ordenar por booleano

A query a seguir pesquisa a coleção de propriedades sample_airbnb.listingsAndReviews em Portugal e classifica os resultados em ordem decrescente pelo campo boolean is_location_exact.

The query uses the $limit stage to limit the output to 5 documents. It also uses the $project stage to omit all fields except name, property_type, address.country, and address.location.is_location_exact in the results.

1db.listingsAndReviews.aggregate([
2  {
3    "$search": {
4      "text": {
5        "path": "address.country",
6        "query": "Portugal"
7      },
8      "sort": {
9        "address.location.is_location_exact": -1,
10      }
11    }
12  },
13  {
14    "$limit": 5
15  },
16  {
17    "$project": {
18      "_id": 0,
19      "name": 1,
20      "property_type": 1,
21      "address.country": 1,
22      "address.location.is_location_exact": 1
23    }
24  }
25])

Nos resultados anteriores, o valor de is_location_exact é true para os documentos porque, em uma classificação decrescente, o MongoDB Search classifica true valores acima de false valores. Se você fizer uma classificação ascendente alterando o valor na linha 9 da query anterior para 1, o MongoDB Search classificará os documentos com valores false maiores que true valores e retornará os seguintes documentos:

[
  {
    name: 'Ribeira Charming Duplex',
    property_type: 'House',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  },
  {
    name: 'Be Happy in Porto',
    property_type: 'Loft',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  },
  {
    name: 'Downtown Oporto Inn (room cleaning)',
    property_type: 'Hostel',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  },
  {
    name: 'A Casa Alegre é um apartamento T1.',
    property_type: 'Apartment',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  },
  {
    name: 'FloresRooms 3T',
    property_type: 'Apartment',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  }
]

Pesquisa e classificação composta

A seguinte query utiliza o estágio $search para fazer o seguinte:

  • Procure por filmes que tenham o termo dance no título, com preferência por filmes que ganharam 2 ou mais prêmios e foram lançados após 01 de janeiro de 1990.

  • Classifique os resultados pelo número de prêmios em ordem decrescente, depois pelo título do filme em ordem crescente e, em seguida, pela data de lançamento em ordem decrescente.

The query uses the $limit stage to limit the output to 10 documents. It also uses the $project stage to do the following:

  • Omitir todos os campos exceto title, released e awards.wins nos resultados.

  • Adicione um campo denominado score.

db.movies.aggregate([
  {
    "$search": {
      "compound": {
        "must": [{
          "text": {
            "path": "title",
            "query": "dance"
          }
        }],
        "should": [{
          "range": {
            "path": "awards.wins",
            "gte": 2
          }
        }, {
          "range": {
            "path": "released",
            "gte": ISODate("1990-01-01T00:00:00.000Z")
          }
        }]
      },
      "sort": {
        "awards.wins": -1,
        "title": 1,
        "released": -1
      }
    }
  },
  {
    "$limit": 10
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "released": 1,
      "awards.wins": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])

Pesquisa e classificação de facets

A seguinte query utiliza o estágio $search para fazer o seguinte:

  • Pesquise filmes lançados entre 01 de janeiro de 2010 e 01 de janeiro de 2015 usando o operador de intervalo .

  • Conte o número de filmes que ganharam os prêmios 1, 5, 10 e 15.

  • Obtenha uma contagem do número de filmes lançados em 2010-01-01, 2011-01-01, 2012-01-01, 2013-01-01, 2014-01-01 e 2015-01-01.

  • Classifique os resultados em ordem decrescente da data de lançamento usando a opção sort.

The query uses the $limit stage to do the following:

  • Limite a saída para 5 documentos no campo docs saída.

  • Limite a saída ao documento 1 no campo de saída meta.

It uses the $project stage to omit all fields except the awards.wins, released, and title fields.

It also uses the $replaceWith stage to include the metadata results stored in the $$SEARCH_META variable in the meta output field and the $set stage to add the meta field to the results.

db.movies.aggregate([
  {
    "$search": {
      "facet": {
        "operator": {
          "range": {
            "path": "released",
            "gt": ISODate("2010-01-01T00:00:00.000Z"),
            "lt": ISODate("2015-01-01T00:00:00.000Z")
          }
        },
        "facets": {
          "awardsFacet": {
            "type": "number",
            "path": "awards.wins",
            "boundaries" : [1,5,10,15]
          },
          "releasedFacet" : {
            "type" : "date",
            "path" : "released",
            "boundaries" : [ISODate("2010-01-01T00:00:00.000Z"), ISODate("2011-01-01T00:00:00.000Z"), ISODate("2012-01-01T00:00:00.000Z"), ISODate("2013-01-01T00:00:00.000Z"), ISODate("2014-01-01T00:00:00.000Z"), ISODate("2015-01-01T00:00:00.000Z")]
          }
        }
      },
      "sort": {
        "released": -1
      }
    }
  },
  {
    "$facet": {
      "docs": [
        { "$limit": 5 },
        { "$project":
          {
            "_id": 0,
            "title": 1,
            "released": 1,
            "awards.wins": 1
          }
        }
      ],
      "meta": [
        {"$replaceWith": "$$SEARCH_META"},
        {"$limit": 1}
      ]
    }
  },
  {
    "$set": {
      "meta": {
        "$arrayElemAt": ["$meta", 0]
      }
    }
  }
])

Classificar por pontuação

Os exemplos a seguir demonstram como classificar os resultados pela pontuação dos documentos nos resultados. Os exemplos demonstram como executar as seguintes ações:

  • Recupere os documentos de pontuação mais baixa primeiro classificando os resultados em ordem crescente.

  • Classifique os resultados por pontuação em ordem decrescente e, para resultados com pontuações idênticas, classifique arbitrariamente.

  • Classifique os resultados por pontuação e para resultados com pontuações idênticas, classifique utilizando um campo exclusivo.

Voltar
detalhes da pontuação
Próximo
realçar
Avalie esta página

Nesta página