Para agentes de IA: hay un índice de documentación disponible en https://www.mongodb.com/es/docs/llms.txt — versiones en markdown de todas las páginas están disponibles agregando .md a cualquier ruta URL.
Docs Menu
Docs Home
/ /
opciones de búsqueda
Docs Home
/ /
Referencia de query
/
opciones de búsqueda
Docs Home
/
Desarrollo
/
Buscar
/
Query e índices
/
Referencia de query
/
opciones de búsqueda

ordene los resultados de MongoDB Search

Overview

MongoDB Search permite ordenar los resultados en orden ascendente o descendente en los campos definidos en el índice de MongoDB Search. Se pueden ordenar por los siguientes tipos de campo usando la opción sort:

  • boolean

  • date

  • number (valores enteros, de punto flotante y double)

  • objectId

  • uuid

  • string (indexado como el tipo de token)

También puede ordenar por la puntuación de los documentos en los resultados y por los valores nulos.

sort Compatibilidad de Opciones

Atlas es compatible tanto con las consultas de ordenación particionadas como no particionadas en todas las versiones principales y secundarias de MongoDB 7.0 y versiones posteriores.

sort Limitaciones de opciones

  • No puedes ordenar por campos del tipo embeddedDocuments.

  • No puedes usar la opción sort con el operador obsoleto knnBeta.

Uso

Para ordenar sus resultados de búsqueda de MongoDB, debe hacer lo siguiente:

  1. Crea un índice de MongoDB Search en los campos por los que deseas ordenar los resultados.

    Para ordenar en los campos boolean, date, number, UUID y objectId, utiliza mapeos dinámicos o estáticos. Para ordenar campos de string, debes usar mapeos estáticos para indexar el campo como el tipo token.

  2. Crea y ejecuta tu query con la opción sort en los campos que definiste en el índice para ordenar. Para aprender más, consulta Sintaxis.

Comportamiento

Ordena por campo booleano, de fecha, numérico, UUID, ObjectId o de string

La opción sort toma un documento que especifica los campos por los que ordenar y el respectivo orden de clasificación. MongoDB Search sigue el orden de comparación de MongoDB para los tipos de datos compatibles. Tratando los valores UUID como BinData. Para obtener más información, consulte campos no existentes.

Puedes especificar el siguiente orden de clasificación para ordenar tus resultados por:

1

Ordena en orden ascendente.

Cuando ordenas en orden ascendente, MongoDB Search devuelve documentos con valores faltantes antes que documentos con valores presentes.

-1

Ordenar en orden descendente.

Ordenar por puntuación y un campo único

También puedes ordenar por puntuación en orden ascendente o descendente. La opción sort toma un documento que especifica la expresión $meta, que requiere el valor searchScore.

Ejemplo

Supongamos que su aplicación permite a los usuarios saltar a la última página de los resultados de búsqueda. El siguiente ejemplo ordena los resultados por puntuación de forma ascendente, de modo que el documento con la puntuación más baja aparezca en la parte superior de los resultados:

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

Puedes utilizar sort para garantizar que los resultados tengan un orden determinado cuando varios documentos en los resultados tengan puntuaciones idénticas. Por ejemplo, si clasifica los resultados por un campo único, como un campo de fecha llamado lastUpdated como se muestra en el siguiente ejemplo, MongoDB Search devuelve resultados con puntuaciones idénticas en un orden determinado:

Ejemplo

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

Sin embargo, si no especificas un campo único por el cual ordenar los resultados, MongoDB Search devuelve los resultados ordenados por puntaje en orden descendente. MongoDB Search devuelve resultados con puntajes o valores idénticos en un orden arbitrario. El siguiente ejemplo no ordena los resultados por un campo único.

Ejemplo

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

Para obtener más información, consulta Puntuación de los documentos en los resultados.

Ordenar arreglos

MongoDB Search aplana los arreglos para realizar ordenamientos.

Ejemplo

Considera el siguiente arreglo:

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

MongoDB Search aplana el arreglo anterior de manera similar a lo siguiente:

4, 1, 8, 5, 9, 2

Para una ordenación ascendente, MongoDB Search utiliza 1 para comparar el arreglo con otros valores. Para una ordenación descendente, MongoDB Search utiliza 9 para comparar el arreglo con otros valores.

Cuando se compara con elementos dentro de un arreglo:

  • Para una clasificación ascendente, MongoDB Search compara los elementos más pequeños del arreglo o realiza una comparación menor que (<).

    Ejemplo

    MongoDB Search ordena los resultados en el siguiente orden si ordenas por números en orden ascendente:

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

  • Para un ordenamiento descendente, MongoDB Search compara los elementos más grandes del arreglo o realiza una comparación mayor a (>).

    Ejemplo

    MongoDB Search ordena los resultados en el siguiente orden si los ordenas por números en orden descendente:

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

Ordenar arreglos con múltiples tipos

Al ordenar sobre campos de arreglo que contienen valores de múltiples tipos de BSON, MongoDB Search selecciona un elemento representativo del arreglo para utilizar en la comparación según el orden de comparación y ordenamiento de MongoDB por defecto.

  • Para una ordenación ascendente, MongoDB Search utiliza el elemento con el tipo BSON más bajo.

  • Para una clasificación descendente, MongoDB Search utiliza el elemento con el tipo BSON más alto.

Si hay varios valores del mismo tipo BSON en el arreglo, se aplica el comportamiento estándar de ordenación para el tipo seleccionado.

Ejemplo

Considera el siguiente arreglo:

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

  • Para un orden ascendente, MongoDB Search utiliza,null ya que es el tipo BSON más bajo admitido.

  • Para una ordenación descendente, MongoDB Search utiliza true, ya que es el tipo de BSON más alto en el arreglo y MongoDB Search clasifica los valores true por encima de los valores false.

Sin embargo, si estableces noData: highest en tu sintaxis sort, MongoDB Search considera que los valores null y ausentes son del tipo BSON más alto. Para el arreglo de ejemplo, se aplica el siguiente comportamiento:

  • Para una ordenación ascendente, MongoDB Search utiliza 15, ya que ahora es el tipo BSON más bajo en el arreglo.

  • Para una ordenación descendente, MongoDB Search utiliza null, ya que ahora es el tipo de BSON más alto en el arreglo.

Para aprender más información, consulta Ordenar por nulo y valores faltantes.

Para obtener un ejemplo, consulta Ordenar en arreglos de varios tipos.

Ordenar por valores nulos y faltantes

MongoDB Search trata los valores nulos como iguales a los valores ausentes y vacíos, y el orden de los documentos con estos valores es no determinista al ordenar.

De forma predeterminada, MongoDB Search sigue el orden de comparación y ordenación de MongoDB y considera que los valores null son menores que todos los demás tipos BSON compatibles. Por lo tanto, los valores nulos aparecen en la parte superior de los resultados durante una ordenación ascendente y en la parte inferior durante una ordenación descendente.

Para configurar dónde aparecen los valores nulos en los resultados, especifique el campo noData en su sort sintaxis. El campo noData acepta los siguientes valores:

  • lowest (por defecto): establece los valores nulos como el BSON más bajo tipo durante la ordenación. Ordena los valores nulos en la parte superior de los resultados durante una ordenación ascendente y en la parte inferior durante una ordenación descendente.

  • highestDefine los valores nulos como el tipo BSON más alto durante la clasificación. Ordena los valores nulos al final de los resultados durante una ordenación ascendente y al principio durante una ordenación descendente.

Nota

El mismo comportamiento se aplica al ordenar en arreglos con múltiples tipos que contienen valores nulos o faltantes.

Para obtener ejemplos, consulte Ordenar por valores nulos y Ordenar en arreglos de varios tipos.

Ordenar en campos de arreglos de documentos incrustados

Para ordenar los documentos parent por un campo de documento incrustado, debes realizar lo siguiente:

  • Indexa los padres del campo de documento incrustado como el tipo documento.

  • Indexa el campo secundario con valores de string dentro del documento incrustado como el tipo de token. Para los campos secundarios con valores numéricos y de fecha, habilita la asignación dinámica para indexar esos campos automáticamente.

MongoDB Search ordena solo en documentos principales. No ordena los campos hijo dentro de un arreglo de documentos. Para ver un ejemplo, consulta el Ejemplo de Ordenación

Considerations

coherencia

Los índices de MongoDB Search son finalmente coherentes y los valores devueltos en los resultados pueden ser diferentes de los valores utilizados en la clasificación.

Rendimiento

Esta funcionalidad optimiza las queries que utilizan $search con $limit como una etapa siguiente. Si MongoDB Search necesita ordenar todos los documentos de la colección, la respuesta podría ser lenta.

Puntuación

MongoDB Search devuelve puntuaciones para todos los documentos en los resultados. Sin embargo, puedes ver documentos con puntajes más altos después de documentos con menores puntajes porque el orden de los documentos en los resultados se basa en los criterios de ordenamiento a menos que se clasifique explícitamente por puntaje.

Sintaxis

sort tiene la siguiente sintaxis:

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}
Parameter
Descripción

score

opcional. Determina si se debe ordenar por la puntuación de búsqueda. Para aprender más información, consulta Ordenar por puntuación y un campo único.

<field-to-sort>

Obligatorio. El nombre del campo por el que se debe ordenar.

<sort-order>

Requerido. Determina el orden de clasificación. Use 1 para orden ascendente y -1 para orden descendente.

Si deseas especificar el campo noData, utiliza un documento con la siguiente sintaxis:

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

Ejemplos

En los ejemplos siguientes se usa sample_mflix.movies, sample_airbnb.listingsAndReview o una colección personalizada denominada users.

Definición del índice

Las queries de ejemplo en esta página utilizan el sample_mflix.movies, el sample_airbnb.listingsAndReviewo una colección personalizada. Si se crean los siguientes índices en estas colecciones, se podrán ejecutar las queries de muestra en los campos indexados.

colección de películas

La definición del índice para la colección movies especifica lo siguiente:

  • Índice del campo awards.wins como:

  • Índice del campo released como:

  • Índice del campo title como:

    • token tipo de clasificación

    • string tipo para hacer queries

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 la definición del índice anterior, MongoDB Search crea un índice llamado default con mapeos estáticos en los campos especificados.

colección listingsAndReviews

Las queries de ejemplo sobre la colección sample_airbnb.listingsAndReviews utilizan el siguiente índice. La definición del índice especifica las asignaciones dinámicas de los campos de la colección:

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

colección de usuarios

La colección users contiene los siguientes 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",
  }
])

La definición del índice para la colección users especifica lo siguiente:

  • Indexar dinámicamente todos los campos excepto los llamados c.

  • Índice estático del campo llamado c como los siguientes tipos para la clasificación:

    • 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 la colección anterior, MongoDB Search crea un índice llamado default con los mapeos especificados en los campos especificados.

Búsqueda y ordenación de fechas

La siguiente query muestra cómo ejecutar una query de operador compuesto y ordenar los resultados por un campo de fecha. Utiliza los siguientes operadores:

  • comodín operador para buscar títulos de películas que empiecen con Summer.

  • operador near para buscar películas que se estrenaron y alrededor de cinco meses antes o después del 18 de abril de 2014.

    Nota

    Cuando utilizas pivot en un campo de fecha, su unidad de medida es en milisegundos. MongoDB Search calcula una puntuación para cada documento en función de la proximidad del campo de fecha a la fecha especificada. Para aprender más, consulte near.

La consulta utiliza las siguientes etapas del pipeline:

  • $search etapa para buscar los campos title y released y luego ordenar los resultados por el campo released en orden descendente.

  • $limit etapa para limitar la salida a 5 resultados.

  • $project preparar para:

    • Exceptuar todos los campos excepto title y released.

    • Agrega un campo denominado score.

Búsqueda y ordenación por número

La siguiente query muestra cómo ordenar los resultados por un campo numérico. Utiliza el operador rango para buscar películas que hayan ganado 10 o más premios y, después, ordenar los resultados por el valor del campo numérico en orden descendente.

La consulta utiliza las siguientes etapas del pipeline:

  • $search etapa para buscar en el campo awards.wins y ordenar los resultados en orden descendente.

  • $limit etapa para limitar la salida a 5 resultados.

  • Etapa $project para excluir todos los campos excepto title y awards.wins.

String Search and Sort

Ejemplo básico

La siguiente query en el sample_mflix.movies namespace utiliza la etapa $search para realizar lo siguiente:

  • Busca películas que tengan el término country en el título.

  • Ordenar los resultados en orden ascendente utilizando la opción sort.

La query utiliza la etapa $limit para limitar la salida a 5 documentos. También utiliza la etapa $project para hacer lo siguiente:

  • Omite todos los campos excepto title en los resultados.

  • Agrega un 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 }
]

Ejemplo de búsqueda compuesta con comodines y ordenamiento

La siguiente query muestra cómo query y clasificar los resultados por un campo de string. Busca títulos que comiencen con Prance o Prince y ordena los resultados por el campo title en orden ascendente.

La consulta utiliza las siguientes etapas del pipeline:

  • $search para buscar en el campo title usando la cláusula should con el operador comodín para buscar títulos que comiencen con Prance y Prince. La consulta también especifica que los resultados deben ordenarse por el campo title en orden ascendente.

  • $limit etapa para limitar la salida a 5 resultados.

  • $project preparar para:

    • Excluye todos los campos excepto title.

    • Agrega un campo denominado score.

Ejemplo de ordenamiento ignorando mayúsculas y minúsculas

La siguiente query muestra cómo ordenar los resultados independientemente de las mayúsculas y minúsculas. Utiliza el operador texto para buscar películas que contengan el término train en el campo title y luego ordena los resultados por el valor del campo title en orden ascendente.

La query especifica una etapa $limit para limitar los documentos en los resultados a 5 y una etapa $project para hacer lo siguiente:

  • Incluye solo los campos _id, title y awards en los resultados.

  • Agrega un campo llamado puntuación en los resultados.

Ordenar por ObjectId

La siguiente query utiliza el operador de rango para buscar en el campo released en la colección sample_mflix.movies películas lanzadas entre 2015-01-01 y 2015-12-31. Ordena los resultados por el campo _id, que contiene valores de tipo ObjectId, en orden descendente.

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

La siguiente query busca el término hello en el campo b en la colección users. La query ordena los resultados por el campo a, que contiene datos polimórficos (para demostrar el orden de clasificación), en orden ascendente.

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

Considera las siguientes consultas que buscan el campo b para la string hello en la colección users usando el operador de texto. La query luego ordena los resultados por el campo c, que contiene valores nulos o ausentes para algunos documentos de la colección.

Para aprender más información, consulta Ordenar por nulo y valores faltantes.

Orden ascendente (por defecto)

Durante un orden ascendente, MongoDB Search devuelve los documentos con valores nulos o faltantes en la parte superior de los resultados por defecto, como se muestra en el siguiente ejemplo:

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

Orden descendente (por defecto)

Durante una clasificación descendente, MongoDB Search devuelve documentos con valores nulos o faltantes al final de los resultados por defecto, como se muestra en el siguiente ejemplo:

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

Nota

La configuración noData: lowest es la misma que la por defecto.

Orden ascendente (noData: más bajo)

Si especificas el campo noData como lowest durante un orden ascendente, MongoDB Search devuelve documentos con valores nulos o ausentes en la parte superior de los resultados, como se muestra en el siguiente ejemplo.

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

Orden descendente (noData: más bajo)

Si especificas el campo noData como lowest durante una ordenación descendente, MongoDB Search devuelve documentos con valores nulos o ausentes en la parte inferior de los resultados, como se muestra en el siguiente ejemplo.

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

Orden ascendente (noData: más alto)

Si se especifica el campo noData como highest durante una clasificación ascendente, MongoDB Search devuelve documentos con valores nulos o faltantes al final de los resultados, como se muestra en el siguiente ejemplo.

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

Orden descendente (sin datos: más alto)

Si especificas el campo noData como highest durante una ordenación descendente, MongoDB Search devuelve los documentos con valores nulos o ausentes en la parte superior de los resultados, como se muestra en el siguiente ejemplo.

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

El orden de los documentos con "_id": 4, "_id": 5 y "_id": 6 es aleatorio porque MongoDB Search trata los valores nulos y ausentes como iguales al ordenar.

Ordenar en arreglos de múltiples tipos

Considera las siguientes consultas en la colección de usuarios dado un documento adicional con un arreglo de múltiples tipos en el campo c:

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

Las siguientes consultas buscan en el campo b la cadena hello utilizando el operador text y ordenan los resultados por el campo c.

Nota

Establecer noData: lowest en la sintaxis de ordenación equivale a lo establecido por defecto.

Orden ascendente (por defecto)

Para una ordenación ascendente, MongoDB Search utiliza el elemento con el tipo BSON más bajo para representar el arreglo de múltiples tipos. Por defecto, MongoDB Search considera los valores nulos o faltantes como el valor BSON más bajo. Por lo tanto, MongoDB Search utiliza null para representar el arreglo de múltiples tipos en el documento con _id: 7 y devuelve este documento en la parte superior de los resultados, junto con otros valores nulos y ausentes.

Para aprender más, consulta Ordenar por valores nulos y faltantes y Ordenar arreglos con múltiples 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 }
]

El orden de los documentos con "_id": 4, "_id": 5, "_id": 6 y "_id": 7 es aleatorio porque MongoDB Search trata los valores nulos y los valores faltantes como iguales al clasificar.

Orden descendente (por defecto)

Para una ordenación descendente, MongoDB Search utiliza el elemento con el tipo BSON más alto para representar el arreglo de tipos múltiples. MongoDB Search utiliza false para representar el arreglo de varios tipos para el documento con _id: 7, ya que este es el tipo más alto de BSON en el arreglo. Dado que MongoDB Search también clasifica los valores true por encima de los valores false, MongoDB Search devuelve este documento después del documento con _id: 1.

Para aprender más, consulta Ordenar por valores nulos y faltantes y Ordenar arreglos con múltiples 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 },
]

El orden de los documentos con "_id": 4, "_id": 5 y "_id": 6 es aleatorio porque MongoDB Search trata los valores nulos y ausentes como iguales al ordenar.

Las siguientes consultas especifican noData: highest para establecer los valores nulos como el tipo más alto de BSON durante la ordenación.

Orden ascendente (noData: más alto)

Para una ordenación ascendente, MongoDB Search utiliza el elemento con el tipo BSON más bajo para representar el arreglo de múltiples tipos. La query especifica noData: highest para considerar los valores nulos o faltantes como el valor más alto de BSON, por lo que MongoDB Search utiliza 15 para representar el arreglo de múltiples tipos para el documento con _id: 7, ya que los números son el siguiente tipo de BSON más bajo en el arreglo.

Para aprender más, consulta Ordenar por valores nulos y faltantes y Ordenar arreglos con múltiples 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 }
]

El orden de los documentos con "_id": 4, "_id": 5 y "_id": 6 es aleatorio porque MongoDB Search trata los valores nulos y ausentes como iguales al ordenar.

Orden descendente (sin datos: más alto)

Para una ordenación descendente, MongoDB Search utiliza el elemento con el tipo BSON más alto para representar el arreglo de tipos múltiples. Dado que la query especifica el campo noData como highest para establecer los valores nulos o faltantes como el valor BSON más alto, MongoDB Search utiliza null para representar el arreglo de varios tipos para el documento con _id: 7 y devuelve este documento en la parte superior de los resultados junto con otros valores nulos y faltantes.

Para aprender más, consulta Ordenar por valores nulos y faltantes y Ordenar arreglos con múltiples 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 }
]

El orden de los documentos con "_id": 4, "_id": 5, "_id": 6 y "_id": 7 es aleatorio porque MongoDB Search trata los valores nulos y los valores faltantes como iguales al clasificar.

Ordenar por booleano

La siguiente query busca en la colección sample_airbnb.listingsAndReviews las propiedades en Portugal y clasifica los resultados en orden descendente por el campo boolean is_location_exact.

La query utiliza la etapa $limit para limitar la salida a 5 documentos. También usa la etapa $project para omitir todos los campos excepto name, property_type, address.country y address.location.is_location_exact en los resultados.

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

En los resultados anteriores, el valor de is_location_exact es true para los documentos porque en un orden descendente, MongoDB Search clasifica los valores de true por encima de los valores de false. Si realiza una ordenación ascendente cambiando el valor en la línea 9 de la query anterior a 1, MongoDB Search clasifica los documentos con valores de false más alto que los de true y devuelve los siguientes 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 } }
  }
]

Búsqueda y clasificación compuesta

La siguiente query utiliza la etapa $search para hacer lo siguiente:

  • Buscar películas que contengan el término dance en el título, con preferencia por películas que hayan ganado 2 o más premios y que se hayan estrenado después del 1 de enero de 1990.

  • Ordenar los resultados por el número de premios en orden descendente, luego por el título de la película en orden ascendente y finalmente por la fecha de lanzamiento en orden descendente.

La query utiliza la etapa $limit para limitar la salida a 10 documentos. También utiliza la etapa $project para hacer lo siguiente:

  • Omita todos los campos excepto title, released y awards.wins en los resultados.

  • Agrega un 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
  }
]

Búsqueda y ordenación por facetas

La siguiente query utiliza la etapa $search para hacer lo siguiente:

  • Busca películas estrenadas entre el 01 de enero de 2010 y el 01 de enero de 2015 utilizando el operador rango.

  • Obtén un recuento del número de películas que ganaron los premios 1, 5, 10 y 15.

  • Obtén un recuento del número de películas estrenadas en 2010-01-01, 2011-01-01, 2012-01-01, 2013-01-01, 2014-01-01 y 2015-01-01.

  • Ordena los resultados en orden descendente de fecha de lanzamiento usando la opción sort.

La query utiliza la etapa $limit para hacer lo siguiente:

  • Limita la salida a 5 documentos en el campo de salida docs.

  • Limita la salida a 1 documento en el campo de salida meta.

Utiliza la fase $project para omitir todos los campos excepto los campos awards.wins, released y title.

También utiliza la etapa $replaceWith para incluir los resultados de metadatos almacenados en la variable $$SEARCH_META en el campo de salida meta y la etapa $set para añadir el campo meta a los resultados.

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

Ordenar por puntuación

Los siguientes ejemplos demuestran cómo clasificar los resultados por la puntuación de los documentos en los resultados. Los ejemplos demuestran cómo realizar las siguientes acciones:

  • Recupera los documentos con menor puntuación primero ordenando los resultados en orden ascendente.

  • Ordena los resultados por puntuación en orden descendente y para resultados con puntuaciones idénticas, ordena arbitrariamente.

  • Ordena los resultados por puntuación y, para los resultados con puntuaciones idénticas, ordena utilizando un campo único.

Orden ascendente

La query siguiente utiliza la etapa $search para realizar las siguientes acciones:

  • Busca películas que tengan el término story en el título.

  • Ordena los resultados por puntuación en orden ascendente.

La query utiliza la etapa $limit para limitar la salida a 5 documentos. También utiliza la etapa $project para realizar las siguientes acciones:

  • Omite todos los campos excepto title en los resultados.

  • Agrega un 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
  }
]

Orden por defecto (descendente)

La query siguiente utiliza la etapa $search para realizar las siguientes acciones:

  • Busca películas que tengan el término summer en el título.

  • Ordena los resultados por puntuación en orden descendente y para resultados con puntuaciones idénticas, ordena arbitrariamente.

La query utiliza la etapa $limit para limitar la salida a 5 documentos. También utiliza la etapa $project para realizar las siguientes acciones:

  • Omite todos los campos excepto _id y title en los resultados.

  • Agrega un 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
  }
]

Ordenar por campo único

La query siguiente utiliza la etapa $search para realizar las siguientes acciones:

  • Busca películas que tengan el término prince en el título.

  • Ordena los resultados primero por puntuación y, después, por el valor del campo released en orden ascendente para los resultados con puntuaciones idénticas.

La query utiliza la etapa $limit para limitar la salida a 5 documentos. También utiliza la etapa $project para realizar las siguientes acciones:

  • Omite todos los campos excepto title y released en los resultados.

  • Agrega un 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
  }
]

Volver

Detalles de la puntuación

Next

resaltar

En esta página