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)

You can also sort by the score of the documents in the results and by null values.

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. Create and run your query with the sort option against the fields you defined in the index for sorting. To learn more, see Syntax.

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

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

  • For an ascending sort, MongoDB Search uses the element with the lowest BSON type.

  • For a descending sort, MongoDB Search uses the element with the highest BSON type.

If there are multiple values of the same BSON type in the array, standard sort behavior for the selected type applies.

Ejemplo

Considera el siguiente arreglo:

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

  • For an ascending sort, MongoDB Search uses null, as it is the lowest supported BSON type.

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

However, if you set noData: highest in your sort syntax, MongoDB Search considers null and missing values as the highest BSON type. For the example array, the following behavior applies:

  • For an ascending sort, MongoDB Search uses 15, as it is now the lowest BSON type in the array.

  • For a descending sort, MongoDB Search uses null, as it is now the highest BSON type in the array.

To learn more, see Sort by Null and Missing Values.

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

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.

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

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

  • lowest (default): Sets null values as the lowest BSON type during sorting. Sorts null values at the top of the results during an ascending sort and at the bottom during a descending sort.

  • highest: Sets null values as the highest BSON type during sorting. Sorts null values at the bottom of the results during an ascending sort and at the top during a descending sort.

Nota

The same behavior applies when sorting on arrays with multiple types that contain null or missing values.

For examples, see Sort by Null Values and Sort on Multi-Typed Arrays.

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.

To learn more, see Sort by Null and Missing Values.

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

Setting noData: lowest in your sort syntax is the same as the default.

Orden ascendente (por defecto)

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.

To learn more, see Sort by Null and Missing Values and Sort Arrays with Multiple Types.

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)

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.

To learn more, see Sort by Null and Missing Values and Sort Arrays with Multiple Types.

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.

The following queries specify noData: highest to set null values as the highest BSON type during sorting.

Orden ascendente (noData: más 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.

To learn more, see Sort by Null and Missing Values and Sort Arrays with Multiple Types.

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)

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.

To learn more, see Sort by Null and Missing Values and Sort Arrays with Multiple Types.

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