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 se puede ordenar por la puntuación de los documentos en los resultados y por 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

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.

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

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.

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 sort sintaxis, MongoDB Search considera los valores nulos y ausentes como el tipo más alto de BSON. 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 obtener más información, consulta Ordenar por valores nulos y faltantes.

Por ejemplo, vea Ordenación en Arreglos de Múltiples 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.

Por defecto, MongoDB Search sigue el orden de comparación y ordenación de MongoDB y considera los valores nulos como inferiores a 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.

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 (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

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.

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

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

<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.

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
},
...

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 stage to limit the output to 5 results.

  • $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 stage to limit the output to 5 results.

  • $project stage to exclude all fields except title and 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.

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

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

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 stage to limit the output to 5 results.

  • $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.

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

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

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

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 obtener más información, consulta Ordenar por valores nulos y 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" }
    }
  }
])

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

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

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

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

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

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

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

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 varios 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 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": 1
      }
    }
  },
  {
    "$project": {
      "_id": 1,
      "c": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])

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 multitipo. MongoDB Search utiliza false para representar el arreglo multitipo del documento con _id: 7, ya que es el tipo BSON más alto del arreglo. Dado que MongoDB Search también clasifica los valores true por encima de los valores de 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" }
    }
  }
])

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 BSON más alto 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 varios tipos. La query especifica noData: highest para considerar los valores nulos o faltantes como el valor BSON más alto, por lo que MongoDB Search utiliza 15 para representar el arreglo de tipos múltiple para el documento con _id: 7, ya que los números son el siguiente tipo 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" }
    }
  }
])

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

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.

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

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

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.

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

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

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.

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

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

  • Limita la salida a 1 documento en el campo de salida 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]
      }
    }
  }
])

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.

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

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

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.

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

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

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.

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

  • 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"}
    }
  }
])
Volver
Detalles de la puntuación
Next
resaltar
Califique esta página

En esta página