/ /

Referência de query

opções de pesquisa

Página inicial do Docs

Classificar resultados da pesquisa do MongoDB

Interface

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:

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.
Crie e execute sua query com a opção sort nos campos que você definiu no índice para classificação. Para saber mais, consulte Sintaxe.

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

Ao ordenar campos de array que contêm valores de vários tipos de BSON, o MongoDB Search seleciona um elemento representativo da array para usar na comparação, de acordo com a ordem de comparação e classificação do MongoDB por padrão.

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.
For a descending sort, MongoDB Search uses true, as it is the highest BSON type in the array and MongoDB Search ranks true values above false values.

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.

Para ver um exemplo, consulte Classificar arrays com vários tipos.

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.

Por padrão, o MongoDB Search segue a comparação do MongoDB e a ordem de classificação e considera valores nulos como menores do que todos os outros tipos de BSON suportados. Portanto, os valores nulos aparecem na parte superior dos resultados durante uma classificação ascendente e na parte inferior durante uma classificação descendente.

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.

Coleção de filmes

A definição do índice para a coleção movies especifica o seguinte:

Indexe o campo awards.wins como:
- number tipo para classificação e consulta, incluindo a execução de consultas facet (Operador de pesquisa do MongoDB)
Indexe o campo released como:
- date tipo para classificação e consulta, incluindo a execução de consultas facet (Operador de pesquisa do MongoDB)
Indexe o campo title como:
- token tipo para classificação
- string tipo para query

1 {
2   "mappings": {
3     "dynamic": true,
4     "fields": {
5       "awards": {
6         "dynamic": false,
7         "fields": {
8           "wins": [
9             {
10               "type": "number"
11             }
12           ]
13         },
14         "type": "document"
15       },
16       "released": [
17         {
18           "type": "date"
19         }
20       ],
21       "title": [{
22         "type": "token"
23       }, {
24         "type": "string"
25       }]
26     }
27   }
28 }

Para a definição de índice anterior, o MongoDB Search cria um índice chamado default com mapeamentos estáticos nos campos especificados.

coleção listingsAndReviews

As consultas de exemplo na coleção sample_airbnb.listingsAndReviews usam o índice a seguir. A definição do índice especifica mapeamentos dinâmicos nos campos da coleção:

{
  "mappings": {
    "dynamic": true
  }
}

Coleção de usuários

A coleção users contém os seguintes documentos:

db.users.insertMany([
  {
    "_id": 0,
    "a": UUID("1a324de2-e34b-c87e-f2a1-42ce37ad74ed"),
    "b": "hello",
    "c": ObjectId("507f1f77bcf86cd799439011")
  },
  {
    "_id": 1,
    "a": UUID("3b241101-e2bb-4255-8caf-4136c566a962"),
    "b": "hello",
    "c": true
  },
  {
    "_id": 2,
    "a": UUID("dee11d4e-63c6-4d90-983c-5c9f1e79e96c"),
    "b": "hello",
    "c": "foo"
  },
  {
    "_id": 3,
    "b": "hello",
    "c": UUID("3be11d4e-62cb-4e95-9a3c-5c9f1e56c732")
  },
  {
    "_id": 4,
    "a": UUID("d3c12e1c-c36e-25ed-7c3e-1e7f1e53c752"),
    "b": "hello",
    "c": null
  },
  {
    "_id": 5,
    "a": UUID("d73f181e-cdda-42b4-b844-4d6e172e9bc8"),
    "b": "hello",
    "c": []
  }
  {
    "_id": 6,
    "a": UUID("7eeddf21-b313-4a5c-81c2-c68915daa618"),
    "b": "hello",
  }
])

A definição do índice para a coleção users especifica o seguinte:

Indexe dinamicamente todos os campos, exceto os campos denominados c.
Campo de indexação estaticamente denominado c como os seguintes tipos para classificação:
- token
- uuid
- objectId
- boolean

1 {
2   "mappings": {
3     "dynamic": true,
4     "fields": {
5       "c": [
6        { "type": "token" },
7        { "type": "uuid" },
8        { "type": "objectId" },
9        { "type": "boolean" },
10        { "type": "number" }
11       ]
12     }
13   }
14 }

Para a coleção anterior, o MongoDB Search cria um índice chamado default com os mapeamentos especificados nos campos especificados.

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" }
    }
  }
])

[
  { title: 'A Country Called Home', score: 2.536633253097534 },
  { title: 'A Month in the Country', score: 2.258953094482422 },
  { title: 'A Quiet Place in the Country', score: 2.0360684394836426 },
  { title: 'A Sunday in the Country', score: 2.258953094482422 },
  { title: 'Another Country', score: 3.3635599613189697 }
]

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" }
    }
  }
])

[
  {
    _id: ObjectId('573a13fbf29313caabdedf31'),
    title: 'No Home Movie',
    released: ISODate('2015-08-10T00:00:00.000Z'),
    score: 1
  },
  {
    _id: ObjectId('573a13fbf29313caabdedf30'),
    title: 'Our Loved Ones',
    released: ISODate('2015-08-12T00:00:00.000Z'),
    score: 1
  },
  {
    _id: ObjectId('573a13faf29313caabded406'),
    title: 'The Red Spider',
    released: ISODate('2015-11-20T00:00:00.000Z'),
    score: 1
  },
  {
    _id: ObjectId('573a13faf29313caabded1d6'),
    title: 'The Laundryman',
    released: ISODate('2015-07-11T00:00:00.000Z'),
    score: 1
  },
  {
    _id: ObjectId('573a13faf29313caabdecaf3'),
    title: 'Right Now, Wrong Then',
    released: ISODate('2015-09-01T00:00:00.000Z'),
    score: 1
  }
]

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" }
    }
  }
])

[
  { _id: 3, score: 0.029335692524909973 },
  {
    _id: 0,
    a: UUID('1a324de2-e34b-c87e-f2a1-42ce37ad74ed'),
    score: 0.029335692524909973
  },
  {
    _id: 1,
    a: UUID('3b241101-e2bb-4255-8caf-4136c566a962'),
    score: 0.029335692524909973
  },
  {
    _id: 6,
    a: UUID('7eeddf21-b313-4a5c-81c2-c68915daa618'),
    score: 0.029335692524909973
  },
  {
    _id: 4,
    a: UUID('d3c12e1c-c36e-25ed-7c3e-1e7f1e53c752'),
    score: 0.029335692524909973
  },
  {
    _id: 5,
    a: UUID('d73f181e-cdda-42b4-b844-4d6e172e9bc8'),
    score: 0.029335692524909973
  },
  {
    _id: 2,
    a: UUID('dee11d4e-63c6-4d90-983c-5c9f1e79e96c'),
    score: 0.029335692524909973
  }
]

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.

Classificação crescente (padrão)

Durante uma classificação ascendente, o MongoDB Search retorna documentos com valores nulos ou ausentes na parte superior dos resultados por padrão, conforme mostrado no exemplo a seguir:

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

[
  { _id: 4, c: null, score: 0.029335692524909973 },
  { _id: 5, c: [], score: 0.029335692524909973 },
  { _id: 6, score: 0.029335692524909973 },
  { _id: 2, c: 'foo', score: 0.029335692524909973 },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.029335692524909973
  },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.029335692524909973
  },
  { _id: 1, c: true, score: 0.029335692524909973 }
]

Classificação decrescente (padrão)

Durante uma classificação decrescente, o MongoDB Search retorna documentos com valores nulos ou ausentes na parte inferior dos resultados por padrão, conforme mostrado no exemplo a seguir:

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

[
  { _id: 1, c: true, score: 0.025981096550822258 },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  { _id: 2, c: 'foo', score: 0.025981096550822258 },
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 }
]

Observação

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

Classificação crescente (noData: mais baixo)

Se você especificar o campo noData como lowest durante uma classificação ascendente, o MongoDB Search retornará documentos com valores nulos ou ausentes na parte superior dos resultados, conforme mostrado no exemplo a seguir.

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

[
  { _id: 4, c: null, score: 0.029335692524909973 },
  { _id: 5, c: [], score: 0.029335692524909973 },
  { _id: 6, score: 0.029335692524909973 },
  { _id: 2, c: 'foo', score: 0.029335692524909973 },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.029335692524909973
  },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.029335692524909973
  },
  { _id: 1, c: true, score: 0.029335692524909973 }
]

Classificação decrescente (noData: mais baixo)

Se você especificar o campo noData como lowest durante uma classificação decrescente, o MongoDB Search retornará documentos com valores nulos ou ausentes na parte inferior dos resultados, conforme mostrado no exemplo a seguir.

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

[
  { _id: 1, c: true, score: 0.025981096550822258 },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  { _id: 2, c: 'foo', score: 0.025981096550822258 },
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 }
]

Classificação crescente (sem dados: mais alto)

Se você especificar o campo noData como highest durante uma classificação ascendente, o MongoDB Search retornará documentos com valores nulos ou ausentes na parte inferior dos resultados, conforme mostrado no exemplo a seguir.

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

[
  { _id: 2, c: 'foo', score: 0.025981096550822258 },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  { _id: 1, c: true, score: 0.025981096550822258 },
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 }
]

Classificação decrescente (noData: mais alto)

Se você especificar o campo noData como highest durante uma classificação decrescente, o MongoDB Search retornará documentos com valores nulos ou ausentes na parte superior dos resultados, conforme mostrado no exemplo a seguir.

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

[
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 },
  { _id: 1, c: true, score: 0.025981096550822258 },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  { _id: 2, c: 'foo', score: 0.025981096550822258 }
]

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.

Classificação crescente (padrão)

For an ascending sort, MongoDB Search uses the element with the lowest BSON type to represent the multi-typed array. By default, MongoDB Search considers null or missing values as the lowest BSON value. Therefore, MongoDB Search uses null to represent the multi-typed array for the document with _id: 7 and returns this document at the top of the results along with other null and missing values.

Para saber mais, consulte Classificar por Valores Nulos e Omitidos e Classificar Matrizes com Vários Tipos.

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

[
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 }
  { _id: 7, c: [ false, null, 15 ], score: 0.025981096550822258 },
  { _id: 2, c: 'foo', score: 0.025981096550822258 },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  { _id: 1, c: true, score: 0.025981096550822258 }
]

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

Classificação decrescente (padrão)

For a descending sort, MongoDB Search uses the element with the highest BSON type to represent the multi-typed array. MongoDB Search uses false to represent the multi-typed array for the document with _id: 7, as this is the highest BSON type in the array. Since MongoDB Search also ranks true values above false values, MongoDB Search returns this document after the document with _id: 1.

Para saber mais, consulte Classificar por Valores Nulos e Omitidos e Classificar Matrizes com Vários Tipos.

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

[
  { _id: 1, c: true, score: 0.025981096550822258 },
  { _id: 7, c: [ false, null, 15 ], score: 0.025981096550822258 },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  { _id: 2, c: 'foo', score: 0.025981096550822258 }
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 },
]

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.

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

Classificação crescente (sem dados: mais alto)

For an ascending sort, MongoDB Search uses the element with the lowest BSON type to represent the multi-typed array. The query specifies noData: highest to consider null or missing values as the highest BSON value, so MongoDB Search uses 15 to represent the multi-typed array for the document with _id: 7 since numbers are the next lowest BSON type in the array.

Para saber mais, consulte Classificar por Valores Nulos e Omitidos e Classificar Matrizes com Vários Tipos.

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

[
  { _id: 7, c: [ false, null, 15 ], score: 0.025981096550822258 },
  { _id: 2, c: 'foo', score: 0.025981096550822258 },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  { _id: 1, c: true, score: 0.025981096550822258 },
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 }
]

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.

Classificação decrescente (noData: mais alto)

For a descending sort, MongoDB Search uses the element with the highest BSON type to represent the multi-typed array. Since the query specifies the noData field as highest to set null or missing values as the highest BSON value, MongoDB Search uses null to represent the multi-typed array for the document with _id: 7 and returns this document at the top of the results along with other null and missing values.

Para saber mais, consulte Classificar por Valores Nulos e Omitidos e Classificar Matrizes com Vários Tipos.

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

[
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 },
  { _id: 7, c: [ false, null, 15 ], score: 0.025981096550822258 },
  { _id: 1, c: true, score: 0.025981096550822258 },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  { _id: 2, c: 'foo', score: 0.025981096550822258 }
]

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

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.

1 db.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 ])

1 [
2   {
3     name: 'BBC OPORTO 4X2',
4     property_type: 'Apartment',
5     address: { country: 'Portugal', location: { is_location_exact: true } }
6   },
7   {
8     name: 'Heroísmo IV',
9     property_type: 'Apartment',
10     address: { country: 'Portugal', location: { is_location_exact: true } }
11   },
12   {
13     name: 'Spacious and well located apartment',
14     property_type: 'Apartment',
15     address: { country: 'Portugal', location: { is_location_exact: true } }
16   },
17   {
18     name: 'Renovated Classic Design Studio with Sun Room',
19     property_type: 'Apartment',
20     address: { country: 'Portugal', location: { is_location_exact: true } }
21   },
22   {
23     name: "O'Porto Studio | Historic Center",
24     property_type: 'Loft',
25     address: { country: 'Portugal', location: { is_location_exact: true } }
26   }
27 ]

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" }
    }
  }
])

[
  {
    title: 'Shall We Dance?',
    released: ISODate("1997-07-11T00:00:00.000Z"),
    awards: { wins: 57 },
    score: 4.9811458587646484
  },
  {
    title: 'Shall We Dance?',
    released: ISODate("1997-07-11T00:00:00.000Z"),
    awards: { wins: 57 },
    score: 4.9811458587646484
  },
  {
    title: 'War Dance',
    released: ISODate("2008-11-01T00:00:00.000Z"),
    awards: { wins: 11 },
    score: 5.466421127319336
  },
  {
    title: 'Dance with the Devil',
    released: ISODate("1997-10-31T00:00:00.000Z"),
    awards: { wins: 6 },
    score: 4.615056037902832
  },
  {
    title: 'Save the Last Dance',
    released: ISODate("2001-01-12T00:00:00.000Z"),
    awards: { wins: 6 },
    score: 4.615056037902832
  },
  {
    title: 'Dance with a Stranger',
    released: ISODate("1985-08-09T00:00:00.000Z"),
    awards: { wins: 4 },
    score: 3.615056037902832
  },
  {
    title: 'The Baby Dance',
    released: ISODate("1998-08-23T00:00:00.000Z"),
    awards: { wins: 4 },
    score: 4.981145858764648
  },
  {
    title: 'Three-Step Dance',
    released: ISODate("2004-02-19T00:00:00.000Z"),
    awards: { wins: 4 },
    score: 4.981145858764648
  },
  {
    title: "Cats Don't Dance",
    released: ISODate("1997-03-26T00:00:00.000Z"),
    awards: { wins: 3 },
    score: 4.981145858764648
  },
  {
    title: 'Dance Me Outside',
    released: ISODate("1995-03-10T00:00:00.000Z"),
    awards: { wins: 3 },
    score: 4.981145858764648
  }
]

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]
      }
    }
  }
])

[
  {
    docs: [
      {
        title: 'Cold in July',
        released: ISODate("2014-12-31T00:00:00.000Z"),
        awards: { wins: 1 }
      },
      {
        title: 'The Gambler',
        released: ISODate("2014-12-31T00:00:00.000Z"),
        awards: { wins: 7 }
      },
      {
        title: 'Force Majeure',
        released: ISODate("2014-12-30T00:00:00.000Z"),
        awards: { wins: 31 }
      },
      {
        title: 'LFO',
        released: ISODate("2014-12-27T00:00:00.000Z"),
        awards: { wins: 3 }
      },
      {
        title: 'Peace After Marriage',
        released: ISODate('2014-12-26T00:00:00.000Z'),
        awards: { wins: 5 }
      }
    ],
    meta: {
      count: { lowerBound: Long("4821") },
        facet: {
          releasedFacet: {
            buckets: [
              {
                _id: ISODate("2010-01-01T00:00:00.000Z"),
                count: Long("857")
              },
              {
                _id: ISODate("2011-01-01T00:00:00.000Z"),
                count: Long("909")
              },
              {
                _id: ISODate("2012-01-01T00:00:00.000Z"),
                count: Long("903")
              },
              {
                _id: ISODate("2013-01-01T00:00:00.000Z"),
                count: Long("1063")
              },
              {
                _id: ISODate("2014-01-01T00:00:00.000Z"),
                count: Long("1089")
              }
            ]
          },
          awardsFacet: {
            buckets: [
              { _id: 1, count: Long("2330") },
              { _id: 5, count: Long("604") },
              { _id: 10, count: Long("233") }
            ]
          }
        }
      }
    }
  }
]

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.

Classificação Ascendente

A seguinte consulta utiliza o estágio $search para executar as seguintes ações:

Procure filmes que tenham o termo story no título.
Classifique os resultados por pontuação em ordem crescente.

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

Omitir todos os campos exceto title nos resultados.
Adicione um campo denominado score.

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

[
  {
    title: 'Do You Believe in Miracles? The Story of the 1980 U.S. Hockey Team',
    score: 0.8674521446228027
  },
  {
    title: 'Once in a Lifetime: The Extraordinary Story of the New York Cosmos',
    score: 0.9212141036987305
  },
  {
    title: 'The Source: The Story of the Beats and the Beat Generation',
    score: 0.9820802211761475
  },
  {
    title: 'If These Knishes Could Talk: The Story of the NY Accent',
    score: 0.9820802211761475
  },
  {
    title: 'Dream Deceivers: The Story Behind James Vance vs. Judas Priest',
    score: 1.051558256149292
  }
]

Classificação Padrão (Descendente)

A seguinte consulta utiliza o estágio $search para executar as seguintes ações:

Procure filmes que tenham o termo summer no título.
Classifique os resultados por pontuação em ordem decrescente e, para resultados com pontuações idênticas, classifique arbitrariamente.

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

Omitir todos os campos, exceto _id e title nos resultados.
Adicione um campo denominado score.

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

[
  {
    _id: ObjectId("573a1398f29313caabcea21e"),
    title: 'Summer',
    score: 3.5844719409942627
  },
  {
    _id: ObjectId("573a13a6f29313caabd18eca"),
    title: 'Summer Things',
    score: 3.000213623046875
  },
  {
    _id: ObjectId("573a13b8f29313caabd4c1d0"),
    title: 'Summer Palace',
    score: 3.000213623046875
  },
  {
    _id: ObjectId("573a1394f29313caabcde8e8"),
    title: 'Summer Stock',
    score: 3.000213623046875
  },
  {
    _id: ObjectId("573a13acf29313caabd284fa"),
    title: 'Wolf Summer',
    score: 3.000213623046875
  }
]

Classificar por Campo Único

A seguinte consulta utiliza o estágio $search para executar as seguintes ações:

Procure filmes que tenham o termo prince no título.
Classifique os resultados primeiro por pontuação e, em seguida, pelo valor do campo released em ordem crescente para resultados com pontuações idênticas.

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

Omitir todos os campos, exceto title e released nos resultados.
Adicione um campo denominado score.

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

[
  {
    title: 'Prince',
    released: ISODate("2015-08-14T00:00:00.000Z"),
    score: 4.168826103210449
  },
  {
    title: 'Prince Avalanche',
    released: ISODate("2013-09-19T00:00:00.000Z"),
    score: 3.4893198013305664
  },
  {
    title: 'The Prince',
    released: ISODate("2014-08-22T00:00:00.000Z"),
    score: 3.4893198013305664
  },
  {
    title: 'Prince of Foxes',
    released: ISODate("1949-12-23T00:00:00.000Z"),
    score: 3.0002830028533936
 },
  {
    title: 'The Oil Prince',
    released: ISODate("1966-01-01T00:00:00.000Z"),
    score: 3.0002830028533936
  }
]

Voltar

detalhes da pontuação

realçar

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	}

1	{
2	"mappings": {
3	"dynamic": true,
4	"fields": {
5	"awards": {
6	"dynamic": false,
7	"fields": {
8	"wins": [
9	{
10	"type": "number"
11	}
12	]
13	},
14	"type": "document"
15	},
16	"released": [
17	{
18	"type": "date"
19	}
20	],
21	"title": [{
22	"type": "token"
23	}, {
24	"type": "string"
25	}]
26	}
27	}
28	}

1	db.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	])

1	[
2	{
3	name: 'BBC OPORTO 4X2',
4	property_type: 'Apartment',
5	address: { country: 'Portugal', location: { is_location_exact: true } }
6	},
7	{
8	name: 'Heroísmo IV',
9	property_type: 'Apartment',
10	address: { country: 'Portugal', location: { is_location_exact: true } }
11	},
12	{
13	name: 'Spacious and well located apartment',
14	property_type: 'Apartment',
15	address: { country: 'Portugal', location: { is_location_exact: true } }
16	},
17	{
18	name: 'Renovated Classic Design Studio with Sun Room',
19	property_type: 'Apartment',
20	address: { country: 'Portugal', location: { is_location_exact: true } }
21	},
22	{
23	name: "O'Porto Studio \| Historic Center",
24	property_type: 'Loft',
25	address: { country: 'Portugal', location: { is_location_exact: true } }
26	}
27	]

Classificar resultados da pesquisa do MongoDB

Visão geral

sort Compatibilidade de opções

sort Limitações de opção

Uso

Comportamento

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

Classificar por pontuação e um campo único

Exemplo

Exemplo

Exemplo

arrays de classificação

Exemplo

Exemplo

Exemplo

Classificar arrays com vários tipos

Exemplo

Classificar por Valores Nulos e Omitidos

Observação

Classificar em campos de array de documentos incorporados

Considerações

Consistência

Desempenho

Pontuação

Sintaxe

Exemplos

Definição de Índice

Coleção de filmes

coleção listingsAndReviews

Coleção de usuários

Pesquisa e classificação de data

Observação

Pesquisa e classificação de números

Pesquisa e classificação de strings

Exemplo básico

Exemplo de pesquisa e classificação composta com curingas

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

Ordenar por ObjectId

Ordenar por UUID

Ordenar por valores nulos

Classificação crescente (padrão)

Classificação decrescente (padrão)

Observação

Classificação crescente (noData: mais baixo)

Classificação decrescente (noData: mais baixo)

Classificação crescente (sem dados: mais alto)

Classificação decrescente (noData: mais alto)

Classificar em arrays de vários tipos

Observação

Classificação crescente (padrão)

Classificação decrescente (padrão)

Classificação crescente (sem dados: mais alto)

Classificação decrescente (noData: mais alto)

Ordenar por booleano

Pesquisa e classificação composta

Pesquisa e classificação de facets

Classificar por pontuação

Classificação Ascendente

Classificação Padrão (Descendente)

Classificar por Campo Único

`sort` Compatibilidade de opções

`sort` Limitações de opção