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

Ordenar los resultados de búsqueda de MongoDB

Overview

MongoDB Search le permite ordenar los resultados en orden ascendente o descendente según los campos que defina en su índice de MongoDB Search. Puede ordenar por los siguientes tipos de campo usando sort opción:

  • boolean

  • date

  • number (valores enteros, flotantes y dobles)

  • objectId

  • uuid

  • string (indexado como el tipode token)

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

sort Compatibilidad de opciones

Atlas admite consultas de ordenamiento fragmentadas y no fragmentadas 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 puede utilizar la sort opción con el operador knnBeta obsoleto.

Uso

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

  1. Cree un índice de búsqueda de MongoDB en los campos para ordenar los resultados.

    Para ordenar boolean datenumberUUID objectId por campos,,, y, utilice asignaciones dinámicas o estáticas. Para ordenar por campos de cadena, debe usar asignaciones estáticas para indexar el campo como token tipo.

  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

Ordenar por campo booleano, de fecha, numérico, UUID, ObjectId o de cadena

La sort opción utiliza un documento que especifica los campos por los que se ordenará y el orden correspondiente. MongoDB Search sigue el orden de comparación de MongoDB para los tipos de datos compatibles. Trata los valores UUID BinData como. Para obtener más información, consulte Campos inexistentes.

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

1

Ordenar en orden ascendente.

Al ordenar en orden ascendente, MongoDB Search devuelve los documentos con valores faltantes antes que los documentos con valores.

-1

Ordenar en orden descendente.

Ordenar por puntuación y un campo único

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

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

También puede usar sort para garantizar que los resultados tengan un orden determinado cuando varios documentos tengan puntuaciones idénticas. Por ejemplo, si ordena 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 especifica un campo único para ordenar los resultados, MongoDB Search los devuelve ordenados por puntuación en orden descendente. MongoDB Search devuelve resultados con puntuaciones o valores idénticos en cualquier orden. El siguiente ejemplo no ordena los resultados por un campo único.

Ejemplo

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

Para obtener más información, consulte Calificar los documentos en los resultados.

Ordenar matrices

MongoDB Search aplana las matrices para ordenarlas.

Ejemplo

Considere la siguiente matriz:

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

MongoDB Search aplana la matriz 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.

Al comparar con elementos dentro de una matriz:

  • Para una ordenación ascendente, MongoDB Search compara los elementos más pequeños de la matriz o realiza una comparación menor que (<).

    Ejemplo

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

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

  • Para una ordenación descendente, MongoDB Search compara los elementos más grandes de la matriz o realiza una comparación mayor que (>).

    Ejemplo

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

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

Ordenar matrices con múltiples tipos

Al ordenar campos de matriz que contienen valores de varios Tipos BSON, MongoDB Search selecciona un elemento representativo de la matriz para usar en la comparación de acuerdo con el orden de comparación y clasificación de MongoDB de manera predeterminada.

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

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

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

Ejemplo

Considere la siguiente matriz:

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

  • Para una clasificación ascendente, MongoDB Search utiliza,null ya que es el tipo BSON admitido más bajo.

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

Sin embargo, si establece noData: highest en la sort sintaxis, MongoDB Search considera los valores nulos y faltantes como el tipo BSON más alto. Para la matriz 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 la matriz.

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

Para obtener más información, consulte Ordenar por valores nulos y faltantes.

Para ver un ejemplo, consulte Ordenar en matrices de múltiples tipos.

Ordenar por valores nulos y faltantes

MongoDB Search trata los valores nulos como si fueran valores faltantes o vacíos, y el orden de los documentos con estos valores no es determinista al momento de la clasificación.

De forma predeterminada, MongoDB Search sigue el orden de comparación y ordenación de MongoDB y considera los valores nulos como inferiores a los demás tipos BSON admitidos. Por lo tanto, los valores nulos aparecen al principio de los resultados en orden ascendente y al final en orden descendente.

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

  • lowest (Predeterminado): Establece los valores nulos como el tipo BSON más bajo durante la ordenación. Ordena los valores nulos al principio de los resultados en orden ascendente y al final en orden descendente.

  • highest: Establece los valores nulos como el tipo BSON más alto durante la ordenación. Ordena los valores nulos al final de los resultados en orden ascendente y al principio en orden descendente.

Nota

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

Para ver ejemplos, consulte Ordenar por valores nulos y Ordenar en matrices de múltiples tipos.

Ordenar por campos de matriz de documentos incrustados

Para ordenar los documentos principales por un campo de documento incrustado, debe hacer lo siguiente:

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

  • Indexe el campo secundario con valores de cadena dentro del documento incrustado como tipo de token. Para los campos secundarios con valores numéricos y de fecha, habilite la asignación dinámica para indexarlos automáticamente.

MongoDB Search ordena solo los documentos principales. No ordena los campos secundarios dentro de una matriz de documentos. Para ver un ejemplo, consulte Ejemplo de ordenación.

Considerations

Consistencia

Los índices de búsqueda de MongoDB son consistentes en última instancia y los valores devueltos en los resultados pueden ser diferentes de los valores utilizados en la clasificación.

Rendimiento

Esta función optimiza las consultas que usan $search con como etapa posterior. Si MongoDB Search necesita ordenar todos los documentos de la colección, la respuesta podría ser $limit lenta.

Puntuación

MongoDB Search devuelve puntuaciones para todos los documentos en los resultados. Sin embargo, es posible que vea documentos con puntuaciones más altas después de los de puntuaciones más bajas, ya que el orden de los documentos en los resultados se basa en los criterios de ordenación, a menos que ordene explícitamente por puntuación.

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 ordenará por puntuación de búsqueda. Para obtener más información, consulte Ordenar por puntuación y un campo único.

<field-to-sort>

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

<sort-order>

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

Si desea especificar el campo noData, utilice un documento con la siguiente sintaxis:

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

Ejemplos

Los siguientes ejemplos utilizan sample_mflix.movies, sample_airbnb.listingsAndReview o una colección personalizada denominada users.

➤ Utiliza el menú desplegable Seleccionar tu lenguaje para configurar el lenguaje de los ejemplos en esta sección.

Definición del índice

Las consultas de ejemplo de esta página utilizan sample_mflix.movies, sample_airbnb.listingsAndReview o una colección personalizada. Si crea los siguientes índices en estas colecciones, puede ejecutar las consultas de ejemplo en los campos indexados.

La definición de í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 para ordenar

    • string tipo para consultar

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 de índice anterior, MongoDB Search crea un índice llamado default con asignaciones estáticas en los campos especificados.

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

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

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 de índice para la colección users especifica lo siguiente:

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

  • Indexar estáticamente el campo denominado c según los siguientes tipos para ordenar:

    • 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 las asignaciones especificadas en los campos especificados.

Búsqueda y ordenación por fecha

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

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

  • Cerca del operador se busca buscar películas que se estrenaron en y aproximadamente cinco meses antes o después del de abril 18 2014de.

    Nota

    Al usar pivot en un campo de fecha, su unidad de medida se expresa en milisegundos. MongoDB Search calcula una puntuación para cada documento según la proximidad del campo de fecha a la fecha especificada. Para obtener más información, consulte "cerca".

La consulta utiliza las siguientes etapas de canalización:

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

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

  • $project etapa a:

    • Excluir todos los campos excepto title y released.

    • Añade un campo llamado score.

1

Ejecuta la query.

Copie y pegue la siguiente consulta en el Query Editory luego haga clic en el botón Search en Query Editor.

[
  {
    $search: {
      "compound": {
        "filter": [{
          "wildcard": {
            "query": "Summer*",
            "path": "title"
          }
        }],
        "must": [{
          "near": {
            "pivot": 13149000000,
            "path": "released",
            "origin": ISODate("2014-04-18T00:00:00.000+00:00")
          }
        }]
      },
      "sort": {
        "released": -1,
        "title": 1
      }
    }
  }
]
SCORE: 0.348105788230896  _id:  "573a13f0f29313caabddaf7a"
  countries: Array
  runtime: 104
  cast: Array
  ...
  title: "Summer Nights"
  ...
  released: 2015-01-28T00:00:00.000+00:00
  ...
SCORE: 0.5917375683784485  _id:  "573a13e6f29313caabdc673b"
  plot: "25-year-old Iiris and Karoliina have been best friends since childhood…"
  genres: Array
  runtime: 90
  ...
  title: "Summertime"
  ...
  released: 2014-08-01T00:00:00.000+00:00
  ...
SCORE: 0.9934720396995544  _id:  "573a13eff29313caabdd760c"
  plot: "Erik Sparrow is one of the lucky ones. He's got a good job. He's in a …"
  genres: Array
  runtime: 86
  ...
  title: "Summer of Blood"
  ...
  released: 2014-04-17T00:00:00.000+00:00
  ...
SCORE: 0.15982933342456818  _id:  "573a13cff29313caabd8ab74"
  plot: "The story of an adult and a teenage couple during a brief summer holid…"
  genres: Array
  countries: Array
  ...
  title: "Summer Games"
  ...
  released: 2012-02-08T00:00:00.000+00:00
  ...
SCORE: 0.13038821518421173  _id:  "573a13cef29313caabd87f4e"
  plot: "Summer of Goliath is a documentary/fiction hybrid that narrates variou…"
  genres: Array
  runtime: 78
  ...
  title: "Summer of Goliath"
  ...
  released: 2011-07-08T00:00:00.000+00:00
  ...
SCORE: 0.08124520629644394  _id:  "573a13c7f29313caabd7608d"
  plot: "A student tries to fix a problem he accidentally caused in OZ, a digit…"
  genres: Array
  runtime: 114
  ...
  title: "Summer Wars"
  ...
  released: 2009-08-01T00:00:00.000+00:00
SCORE: 0.0711759403347969  _id:  "573a13bbf29313caabd54ee6"
  plot: "The life of a public school epitomized by disobedient student Jonah Ta…"
  genres: Array
  runtime: 30
  ...
  title: "Summer Heights High"
  ...
  released: 2008-11-09T00:00:00.000+00:00
  ...
SCORE: 0.06951779872179031  _id:  "573a13bff29313caabd5f935"
  plot: "On his spring break at the seaside, with his wife and his four year ol…"
  genres: Array
  runtime: 102
  ...
  title: "Summer Holiday"
  ...
  released: 2008-09-19T00:00:00.000+00:00
  ...
SCORE: 0.05834990739822388  _id:  "573a13c0f29313caabd628ac"
  plot: "Kochi Uehara is a fourth grade student living in the suburb of Tokyo. …"
  genres: Array
  runtime: 138
  ...
  title: "Summer Days with Coo"
  ...
  released: 2007-07-28T00:00:00.000+00:00
  ...
SCORE: 0.056174591183662415  _id:  "573a13b8f29313caabd4c1d0"
  fullplot: "Country girl Yu Hong leaves her village, her family and her lover to s…"
  genres: Array
  runtime: 158
  ...
  title: "Summer Palace"
  ...
  released: 2007-04-18T00:00:00.000+00:00
  ...
2

Amplíe los resultados de su consulta.

Es posible que Search Tester no muestre todos los campos en los documentos que devuelve. Para ver todos los campos, incluido el campo que especifica en la ruta de query, expanda el documento en los resultados.

Para ejecutar la consulta mongosh en:

1db.movies.aggregate([
2{
3  $search: {
4    "index": "default",
5    "compound": {
6      "filter": [{
7        "wildcard": {
8          "query": "Summer*",
9          "path": "title"
10        }
11      }],
12      "must": [{
13        "near": {
14          "pivot": 13149000000,
15          "path": "released",
16          "origin": ISODate("2014-04-18T00:00:00.000+00:00")
17        }
18      }]
19    },
20    "sort": {
21      "released": -1
22    }
23  }
24},
25{
26  $limit: 5
27},
28{
29  $project: {
30    "_id": 0, 
31    "title": 1,
32    "released": 1,
33    "score": {
34        "$meta": "searchScore"
35    }
36  }
37}])
[
  {
    title: 'Summer Nights',
    released: ISODate("2015-01-28T00:00:00.000Z"),
    score: 0.348105788230896
  },
  {
    title: 'Summertime',
    released: ISODate("2014-08-01T00:00:00.000Z"),
    score: 0.5917375683784485
  },
  {
    title: 'Summer of Blood',
    released: ISODate("2014-04-17T00:00:00.000Z"),
    score: 0.9934720396995544
  },
  {
    title: 'Summer Games',
    released: ISODate("2012-02-08T00:00:00.000Z"),
    score: 0.15982933342456818
  },
  {
    title: 'Summer of Goliath',
    released: ISODate("2011-07-08T00:00:00.000Z"),
    score: 0.13038821518421173
  }
]

En MongoDB Compass, configure cada una de las siguientes etapas del pipeline seleccionando la etapa en el menú desplegable y agregando la consulta correspondiente. Haga clic en Add Stage para agregar etapas adicionales.

Etapa de tubería
Query

$search

{
  "index": "default",
  "compound": {
    "filter": [{
      "wildcard": {
        "query": "Summer*",
        "path": "title"
      }
    }],
    "must": [{
      "near": {
        "pivot": 13149000000,
        "path": "released",
        "origin": ISODate("2014-04-18T00:00:00.000+00:00")
      }
    }]
  },
  "sort": {
    "released": -1
  }
}

$limit

5

$project

{
  _id: 0,
  title: 1,
  released: 1,
  score: { $meta: "searchScore" }
}

Si habilitó Auto Preview, MongoDB Compass muestra los siguientes documentos junto a la etapa de canalización $limit:

{
  title: 'Summer Nights',
  released: 2015-01-28T00:00:00.000+00:00,
  score: 0.348105788230896
},
{
  title: 'Summertime',
  released: 2014-08-01T00:00:00.000+00:00,
  score: 0.5917375683784485
},
{
  title: 'Summer of Blood',
  released: 2014-04-17T00:00:00.000+00:00,
  score: 0.9934720396995544
},
{
  title: 'Summer Games',
  released: 2012-02-08T00:00:00.000+00:00,
  score: 0.15982933342456818
},
{
  title: 'Summer of Goliath',
  released: 2011-07-08T00:00:00.000+00:00,
  score: 0.13038821518421173
}
1

Definir la consulta.

  1. Reemplace el contenido del archivo Program.cs con el siguiente código.

    1using MongoDB.Bson;
    2using MongoDB.Bson.Serialization.Attributes;
    3using MongoDB.Bson.Serialization.Conventions;
    4using MongoDB.Driver;
    5using MongoDB.Driver.Search;
    6
    7public class SortByStrings
    8{
    9    private const string MongoConnectionString = "<connection-string>";
    10
    11    public static void Main(string[] args)
    12    {
    13        // allow automapping of the camelCase database fields to our MovieDocument
    14        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
    15        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
    16
    17        // connect to your Atlas cluster
    18        var mongoClient = new MongoClient(MongoConnectionString);
    19        var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
    20        var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
    21
    22
    23        // declare data for compound query
    24        var originDate = new DateTime(2014, 04, 18, 0, 0, 0, DateTimeKind.Utc);
    25
    26        // define search options
    27        var searchOptions = new SearchOptions<MovieDocument>() 
    28            { 
    29                Sort = Builders<MovieDocument>.Sort.Descending(movie => movie.Released),
    30                IndexName = "default"
    31            };
    32            
    33        // define and run pipeline
    34        var results = moviesCollection.Aggregate()
    35            .Search(Builders<MovieDocument>.Search.Compound()
    36                .Filter(Builders<MovieDocument>.Search.Wildcard(movie => movie.Title, "Summer*"))
    37                .Must(Builders<MovieDocument>.Search.Near(movie => movie.Released, originDate, 13149000000)), searchOptions)
    38            .Project<MovieDocument>(Builders<MovieDocument>.Projection
    39                .Include(movie => movie.Released)
    40                .Include(movie => movie.Title)
    41                .Exclude(movie => movie.Id)
    42                .MetaSearchScore(movie => movie.Score))
    43            .Limit(5)
    44            .ToList();
    45
    46        // print results
    47        foreach (var movie in results)
    48        {
    49            Console.WriteLine(movie.ToJson());
    50        }
    51    }
    52}
    53
    54[BsonIgnoreExtraElements]
    55public class MovieDocument
    56{
    57    [BsonIgnoreIfDefault]
    58    public ObjectId Id { get; set; }
    59    public DateTime Released { get; set; }
    60    public string Title { get; set; }
    61    public double Score { get; set; }
    62}

  2. Especifique el <connection-string>.

2

Ejecuta la query.

dotnet run Program.cs
{ "released" : ISODate("2015-01-28T00:00:00Z"), "title" : "Summer Nights", "score" : 0.348105788230896 }
{ "released" : ISODate("2014-08-01T00:00:00Z"), "title" : "Summertime", "score" : 0.59173756837844849 }
{ "released" : ISODate("2014-04-17T00:00:00Z"), "title" : "Summer of Blood", "score" : 0.99347203969955444 }
{ "released" : ISODate("2014-01-17T00:00:00Z"), "title" : "Summer in February", "score" : 0.62580311298370361 }
{ "released" : ISODate("2012-02-08T00:00:00Z"), "title" : "Summer Games", "score" : 0.15982933342456818 }
1

Definir la consulta.

  1. Crea un nuevo archivo llamado sort-by-date.go y pega el siguiente código:

    1package main
    2
    3import (
    4	"context"
    5	"fmt"
    6	"time"
    7
    8	"go.mongodb.org/mongo-driver/v2/bson"
    9	"go.mongodb.org/mongo-driver/v2/mongo"
    10	"go.mongodb.org/mongo-driver/v2/mongo/options"
    11)
    12
    13func main() {
    14	// connect to your Atlas cluster
    15	client, err := mongo.Connect(options.Client().ApplyURI("<connection-string"))
    16	if err != nil {
    17		panic(err)
    18	}
    19	defer client.Disconnect(context.TODO())
    20
    21	// set namespace
    22	collection := client.Database("sample_mflix").Collection("movies")
    23
    24	// define pipeline stages
    25	searchStage := bson.D{{Key: "$search", Value: bson.M{
    26		"index": "default",
    27		"compound": bson.M{
    28			"filter": bson.A{
    29				bson.M{
    30					"wildcard": bson.D{
    31						{Key: "path", Value: "title"},
    32						{Key: "query", Value: "Summer*"},
    33					}},
    34			},
    35			"must": bson.A{
    36				bson.M{
    37					"near": bson.M{
    38						"path":   "released",
    39						"origin": time.Date(2014, time.April, 18, 0, 0, 0, 0, time.UTC),
    40						"pivot":  13149000000}},
    41			},
    42		},
    43		"sort": bson.D{{Key: "released", Value: -1}},
    44	}}}
    45
    46	limitStage := bson.D{{Key: "$limit", Value: 5}}
    47	projectStage := bson.D{{Key: "$project", Value: bson.D{{Key: "_id", Value: 0}, {Key: "title", Value: 1}, {Key: "released", Value: 1}, {Key: "score", Value: bson.D{{Key: "$meta", Value: "searchScore"}}}}}}
    48
    49	// run pipeline
    50	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, limitStage, projectStage})
    51	if err != nil {
    52		panic(err)
    53	}
    54
    55	// print results
    56	var results []bson.D
    57	if err = cursor.All(context.TODO(), &results); err != nil {
    58		panic(err)
    59	}
    60	for _, result := range results {
    61		fmt.Println(result)
    62	}
    63}

  2. Especifique el <connection-string>.

2

Ejecuta la query.

go run sort-by-date.go
[{title Summer Nights} {released 1422403200000} {score 0.348105788230896}]
[{title Summertime} {released 1406851200000} {score 0.5917375683784485}]
[{title Summer of Blood} {released 1397692800000} {score 0.9934720396995544}]
[{title Summer Games} {released 1328659200000} {score 0.15982933342456818}]
[{title Summer of Goliath} {released 1310083200000} {score 0.13038821518421173}]
1

Definir la consulta.

  1. Crea un nuevo archivo llamado SortByDate.java y pega el siguiente código:

    1import java.util.Arrays;
    2import java.util.List;
    3
    4import static com.mongodb.client.model.Aggregates.limit;
    5import static com.mongodb.client.model.Aggregates.project;
    6import static com.mongodb.client.model.Projections.*;
    7import com.mongodb.client.MongoClient;
    8import com.mongodb.client.MongoClients;
    9import com.mongodb.client.MongoCollection;
    10import com.mongodb.client.MongoDatabase;
    11import org.bson.Document;
    12
    13import java.time.Instant;
    14import java.util.Date;
    15
    16public class SortByDate {
    17  public static void main( String[] args ) {
    18    // define query
    19	    Document agg =
    20	        new Document("$search", 
    21	        	    new Document("index", "default")
    22	                .append("compound", 
    23	        new Document("filter", Arrays.asList(new Document("wildcard", 
    24	                        new Document("query", "Summer*")
    25	                                .append("path", "title"))))
    26	                    .append("must", Arrays.asList(new Document("near", 
    27	                        new Document("pivot", 13149000000L)
    28	                                .append("path", "released")
    29	                                .append("origin", Date.from(Instant.parse("2014-04-18T00:00:00.000+00:00")))))))
    30	                .append("sort", new Document("released", -1)));
    31
    32    // specify connection
    33    String uri = "<connection-string>";
    34
    35    // establish connection and set namespace
    36    try (MongoClient mongoClient = MongoClients.create(uri)) {
    37      MongoDatabase database = mongoClient.getDatabase("sample_mflix");
    38      MongoCollection<Document> collection = database.getCollection("movies");
    39	  // run query and print results
    40      collection.aggregate(Arrays.asList(agg, 
    41        limit(5), 
    42        project(fields(exclude("_id"), include("title"), include("released"), computed("score", new Document("$meta", "searchScore"))))))
    43        .forEach(doc -> System.out.println(doc.toJson()));	
    44    }
    45  }
    46}

    Nota

    Para ejecutar el código de muestra en su entorno Maven, agregue el siguiente código encima de las declaraciones de importación en su archivo.

    package com.mongodb.drivers;

  2. Especifique el <connection-string>.

2

Ejecuta la query.

javac SortByDate.java
java SortByDate
{"title": "Summer Nights", "released": {"$date": "2015-01-28T00:00:00Z"}, "score": 0.348105788230896}
{"title": "Summertime", "released": {"$date": "2014-08-01T00:00:00Z"}, "score": 0.5917375683784485}
{"title": "Summer of Blood", "released": {"$date": "2014-04-17T00:00:00Z"}, "score": 0.9934720396995544}
{"title": "Summer Games", "released": {"$date": "2012-02-08T00:00:00Z"}, "score": 0.15982933342456818}
{"title": "Summer of Goliath", "released": {"$date": "2011-07-08T00:00:00Z"}, "score": 0.13038821518421173}
1

Definir la consulta.

  1. Crea un nuevo archivo llamado SortByDate.kt y pega el siguiente código:

    1import com.mongodb.client.model.Aggregates.limit
    2import com.mongodb.client.model.Aggregates.project
    3import com.mongodb.client.model.Projections.*
    4import com.mongodb.kotlin.client.coroutine.MongoClient
    5import kotlinx.coroutines.runBlocking
    6import org.bson.Document
    7import java.time.Instant
    8import java.util.*
    9
    10fun main() {
    11    // establish connection and set namespace
    12    val uri = "<connection-string>"
    13    val mongoClient = MongoClient.create(uri)
    14    val database = mongoClient.getDatabase("sample_mflix")
    15    val collection = database.getCollection<Document>("movies")
    16
    17    runBlocking {
    18        // define query
    19        val agg = Document(
    20            "\$search",
    21            Document("index", "default")
    22                .append(
    23                    "compound",
    24                    Document(
    25                        "filter", listOf(
    26                            Document(
    27                                "wildcard",
    28                                Document("query", "Summer*")
    29                                    .append("path", "title")
    30                            )
    31                        )
    32                    )
    33                        .append(
    34                            "must", listOf(
    35                                Document(
    36                                    "near",
    37                                    Document("pivot", 13149000000L)
    38                                        .append("path", "released")
    39                                        .append("origin", Date.from(Instant.parse("2014-04-18T00:00:00.000+00:00")))
    40                                )
    41                            )
    42                        )
    43                )
    44                .append("sort", Document("released", -1))
    45        )
    46
    47        // run query and print results
    48        val resultsFlow = collection.aggregate<Document>(
    49            listOf(
    50                agg,
    51                limit(5),
    52                project(fields(
    53                    excludeId(),
    54                    include("title", "released"),
    55                    computed("score", Document("\$meta", "searchScore"))
    56                ))
    57            )
    58        )
    59        resultsFlow.collect { println(it) }
    60    }
    61    mongoClient.close()
    62}

  2. Especifique el <connection-string>.

2

Ejecuta la query.

kotlin SortByDate.kt
Document{{title=Summer Nights, released=Tue Jan 27 19:00:00 EST 2015, score=0.348105788230896}}
Document{{title=Summertime, released=Thu Jul 31 20:00:00 EDT 2014, score=0.5917375683784485}}
Document{{title=Summer of Blood, released=Wed Apr 16 20:00:00 EDT 2014, score=0.9934720396995544}}
Document{{title=Summer Games, released=Tue Feb 07 19:00:00 EST 2012, score=0.15982933342456818}}
Document{{title=Summer of Goliath, released=Thu Jul 07 20:00:00 EDT 2011, score=0.13038821518421173}}
1

Definir la consulta.

  1. Crea un nuevo archivo llamado sort-by-date.js y pega el siguiente código:

    1const { MongoClient } = require("mongodb");
    2
    3// Replace the uri string with your MongoDB deployments connection string.
    4const uri =
    5  "<connection-string>";
    6
    7const client = new MongoClient(uri);
    8
    9async function run() {
    10  try {
    11    await client.connect();
    12
    13    // set namespace
    14    const database = client.db("sample_mflix");
    15    const coll = database.collection("movies");
    16
    17    // define pipeline
    18    const agg = [
    19      {$search: {
    20        index: "default",
    21        compound: {
    22          filter: {wildcard: {query: "Summer*", path: "title"}},
    23          must: [{near: {path: "released", origin: new Date("2014-04-18T00:00:00.000Z"), pivot: 13149000000}}]
    24        },
    25        sort: { released: -1 }
    26      }},
    27    {$limit: 5},
    28    {$project: {_id: 0, title: 1, released: 1, score: {$meta: "searchScore"}}}
    29  ];
    30           
    31    // run pipeline
    32    const result = await coll.aggregate(agg);
    33
    34    // print results
    35    await result.forEach((doc) => console.log(doc));
    36    
    37  } finally {
    38    await client.close();
    39  }
    40}
    41run().catch(console.dir);

  2. Especifique el <connection-string>.

2

Ejecuta la query.

node sort-by-date.js
{
  title: 'Summer Nights',
  released: 2015-01-28T00:00:00.000Z,
  score: 0.348105788230896
}
{
  title: 'Summertime',
  released: 2014-08-01T00:00:00.000Z,
  score: 0.5917375683784485
}
{
  title: 'Summer of Blood',
  released: 2014-04-17T00:00:00.000Z,
  score: 0.9934720396995544
}
{
  title: 'Summer Games',
  released: 2012-02-08T00:00:00.000Z,
  score: 0.15982933342456818
}
{
  title: 'Summer of Goliath',
  released: 2011-07-08T00:00:00.000Z,
  score: 0.13038821518421173
}
1

Definir la consulta.

  1. Crea un nuevo archivo llamado sort-by-date.py y pega el siguiente código:

    1import datetime
    2import pymongo
    3
    4# connect to your Atlas cluster
    5client = pymongo.MongoClient('<connection-string>')
    6
    7# define pipeline
    8pipeline = [
    9  {'$search': {
    10      'index': 'default',
    11      'compound': {
    12        'filter': {'wildcard': {'query': 'Summer*', 'path': 'title'}},
    13        'must': {'near': {
    14          "path": "released", 
    15          "origin": datetime.datetime(2014, 4, 18, 0, 0, 0, 0), 
    16          "pivot": 13149000000
    17      }}},
    18      'sort': { 'released': -1 }}},
    19  {'$limit': 5},
    20  {'$project': {'_id': 0, 'title': 1, 'released': 1, 'score': {'$meta': 'searchScore'}}}
    21]
    22
    23# run pipeline
    24result = client['sample_mflix']['movies'].aggregate(pipeline)
    25
    26# print results
    27for i in result:
    28    print(i)

  2. Especifique el <connection-string>.

2

Ejecuta la query.

python sort-by-date.py
{'title': 'Summer Nights', 'released': datetime.datetime(2015, 1, 28, 0, 0), 'score': 0.348105788230896}
{'title': 'Summertime', 'released': datetime.datetime(2014, 8, 1, 0, 0), 'score': 0.5917375683784485}
{'title': 'Summer of Blood', 'released': datetime.datetime(2014, 4, 17, 0, 0), 'score': 0.9934720396995544}
{'title': 'Summer Games', 'released': datetime.datetime(2012, 2, 8, 0, 0), 'score': 0.15982933342456818}
{'title': 'Summer of Goliath', 'released': datetime.datetime(2011, 7, 8, 0, 0), 'score': 0.13038821518421173}

Búsqueda y ordenación de números

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

La consulta utiliza las siguientes etapas de canalización:

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

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

  • $project etapa para excluir todos los campos excepto title awards.winsy.

1

Ejecuta la query.

Copia y pega la siguiente query en el Query Editor, y luego haz clic en el botón Search en el Query Editor.

[
  {
    "$search": {
      "range": {
        "path": "awards.wins",
        "gte": 10
      },
      "sort": {
        "awards.wins": -1,
      }
    }
  }
]
SCORE: 1  _id:  "573a13d5f29313caabd9cae7"
  fullplot: "Based on an incredible true story of one man's fight for survival and …"
  imdb: Object
    ...
  year: 2013
  ...
  awards: Object
    wins: 267
    ...
  ...
SCORE: 1  _id:  "573a13c7f29313caabd74a4d"
  fullplot: "Dr. Ryan Stone (Sandra Bullock) is a brilliant medical engineer on her…"
  imdb: Object
    ...
  year: 2013
  ...
  awards: Object
    wins: 231
    ...
  ...
SCORE: 1  _id:  "573a13cbf29313caabd808d2"
  fullplot: "Dr. Ryan Stone (Sandra Bullock) is a brilliant medical engineer on her…"
  imdb: Object
    ...
  year: 2013
  ...
  awards: Object
    wins: 231
    ...
  ...
SCORE: 1  _id:  “573a13dff29313caabdb7adb”"
  fullplot: "Actor Riggan Thomson is most famous for his movie role from over twent…"
  imdb: Object
    ...
  year: 2014
  ...
  awards: Object
    wins: 210
    ...
  ...
SCORE: 1  _id:  "573a13bef29313caabd5c06c"
  plot: "The life of Mason, from early childhood to his arrival at college."
  imdb: Object
    ...
  runtime: 165
  ...
  awards: Object
    wins: 185
    ...
  ...
SCORE: 1  _id:  "573a139ef29313caabcfbd6a"
  fullplot: "While Frodo & Sam continue to approach Mount Doom to destroy the One R…"
  imdb: Object
    ...
  year: 2003
  ...
  awards: Object
    wins: 175
    ...
  ...
SCORE: 1  _id:  "573a13b5f29313caabd447f5"
  plot: "In rural Texas, welder and hunter Llewelyn Moss discovers the remains …"
  imdb: Object
    ...
  year: 2007
  ...
  awards: Object
    wins: 172
    ...
  ...
SCORE: 1  _id:  "573a13c3f29313caabd68d9f"
  plot: "On a fall night in 2003, Harvard undergrad and computer programming ge…"
  imdb: Object
    ...
  year: 2010
  ...
  awards: Object
    wins: 171
    ...
  ...
SCORE: 1  _id:  "573a13c5f29313caabd6ee61"
  fullplot: "Dom Cobb is a skilled thief, the absolute best in the dangerous art of…"
  imdb: Object
    ...
  year: 2010
  ...
  awards: Object
    wins: 162
    ...
  ...
SCORE: 1  _id:  "573a13bdf29313caabd58fd3"
  plot: "The story of Jamal Malik, an 18 year-old orphan from the slums of Mumb…"
  imdb: Object
    ...
  year: 2008
  ...
  awards: Object
    wins: 161
    ...
  ...
2

Amplíe los resultados de su consulta.

Es posible que Search Tester no muestre todos los campos en los documentos que devuelve. Para ver todos los campos, incluido el campo que especifica en la ruta de query, expanda el documento en los resultados.

Para ejecutar la consulta mongosh en:

1db.movies.aggregate([
2  {
3    "$search": {
4      "range": {
5        "path": "awards.wins",
6        "gte": 10
7      },
8      "sort": {
9        "awards.wins": -1,
10      }
11    }
12  },
13  {
14    $limit: 5
15  },
16  {
17    "$project": {
18      "_id": 0,
19      "title": 1,
20      "awards.wins": 1
21    }
22  }
23])
[
  {
    title: '12 Years a Slave',
    awards: { wins: 267 }
  },
  {
    title: 'Gravity',
    awards: { wins: 231 }
  },
  {
    title: 'Gravity',
    awards: { wins: 231 }
  },
  {
    title: 'Birdman: Or (The Unexpected Virtue of Ignorance)',
    awards: { wins: 210 }
  },
  {
    title: 'Boyhood',
    awards: { wins: 185 }
  }
]

En MongoDB Compass, configure cada una de las siguientes etapas del pipeline seleccionando la etapa en el menú desplegable y agregando la consulta correspondiente. Haga clic en Add Stage para agregar etapas adicionales.

Etapa de tubería
Query

$search

{
  index: "default",
  "range": {
    "path": "awards.wins",
    "gte": 10
  },
  "sort": {
    "awards.wins": -1,
  }
}

$limit

5

$project

{
  title: 1,
  released: 1,
  year: 1
}

Si habilitó Auto Preview, MongoDB Compass muestra los siguientes documentos junto a la etapa de canalización $limit:

[
  {
    title: '12 Years a Slave',
    awards: { wins: 267 }
  },
  {
    title: 'Gravity',
    awards: { wins: 231 }
  },
  {
    title: 'Gravity',
    awards: { wins: 231 }
  },
  {
    title: 'Birdman: Or (The Unexpected Virtue of Ignorance)',
    awards: { wins: 210 }
  },
  {
    title: 'Boyhood',
    awards: { wins: 185 }
  }
]
1

Definir la consulta.

  1. En tu proyecto, reemplaza el contenido del archivo Program.cs con el siguiente código.

    1using MongoDB.Bson;
    2using MongoDB.Bson.Serialization.Attributes;
    3using MongoDB.Bson.Serialization.Conventions;
    4using MongoDB.Driver;
    5using MongoDB.Driver.Search;
    6
    7public class SortByNumbers
    8{
    9    private const string MongoConnectionString = "<connection-string>";
    10
    11    public static void Main(string[] args)
    12    {
    13        // allow automapping of the camelCase database fields to our MovieDocument
    14        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
    15        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
    16
    17        // connect to your Atlas cluster
    18        var mongoClient = new MongoClient(MongoConnectionString);
    19        var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
    20        var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
    21
    22        // define search options
    23        var searchOptions = new SearchOptions<MovieDocument>() 
    24            { 
    25                Sort = Builders<MovieDocument>.Sort.Descending(movies => movies.Awards.Wins),
    26                IndexName = "default"
    27            };
    28
    29        // define and run pipeline
    30        var results = moviesCollection.Aggregate()
    31            .Search(
    32                Builders<MovieDocument>.Search.Range(movie => movie.Awards.Wins, SearchRangeBuilder.Gte(10)), searchOptions)
    33            .Project<MovieDocument>(Builders<MovieDocument>.Projection
    34                .Exclude(movie => movie.Id)
    35                .Include(movie => movie.Title)
    36                .Include(movie => movie.Awards.Wins))
    37            .Limit(5)
    38            .ToList();
    39
    40        // print results
    41        foreach (var movie in results)
    42        {
    43            Console.WriteLine(movie.ToJson());
    44        }
    45    }
    46}
    47
    48[BsonIgnoreExtraElements]
    49public class MovieDocument
    50{
    51    [BsonIgnoreIfDefault]
    52    public ObjectId Id { get; set; }
    53    public string Title { get; set; }
    54    public Award Awards { get; set; }
    55}
    56
    57public class Award
    58{
    59    [BsonIgnoreIfDefault]
    60    public int Wins { get; set; }
    61}

  2. Especifique el <connection-string>.

2

Ejecuta la query.

dotnet run Program.cs
{ "title" : "12 Years a Slave", "awards" : { "wins" : 267 } }
{ "title" : "Gravity", "awards" : { "wins" : 231 } }
{ "title" : "Gravity", "awards" : { "wins" : 231 } }
{ "title" : "Birdman: Or (The Unexpected Virtue of Ignorance)", "awards" : { "wins" : 210 } }
{ "title" : "Boyhood", "awards" : { "wins" : 185 } }
1

Definir la consulta.

  1. Crea un nuevo archivo llamado sort-by-numbers.go y pega el siguiente código:

    1package main
    2
    3import (
    4	"context"
    5	"fmt"
    6
    7	"go.mongodb.org/mongo-driver/v2/bson"
    8	"go.mongodb.org/mongo-driver/v2/mongo"
    9	"go.mongodb.org/mongo-driver/v2/mongo/options"
    10)
    11
    12func main() {
    13	// connect to your Atlas cluster
    14	client, err := mongo.Connect(options.Client().ApplyURI("<connection-string>"))
    15	if err != nil {
    16		panic(err)
    17	}
    18	defer client.Disconnect(context.TODO())
    19
    20	// set namespace
    21	collection := client.Database("sample_mflix").Collection("movies")
    22
    23	// define pipeline stages
    24	searchStage := bson.D{{Key: "$search", Value: bson.D{
    25		{Key: "index", Value: "default"},
    26		{Key: "range", Value: bson.D{
    27			{Key: "path", Value: "awards.wins"},
    28			{Key: "gte", Value: 10},
    29		}},
    30		{Key: "sort", Value: bson.D{{Key: "awards.wins", Value: -1}}},
    31	}}}
    32	limitStage := bson.D{{Key: "$limit", Value: 5}}
    33	projectStage := bson.D{{Key: "$project", Value: bson.D{{Key: "title", Value: 1}, {Key: "awards.wins", Value: 1}, {Key: "_id", Value: 0}}}}
    34
    35	// run pipeline
    36	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, limitStage, projectStage})
    37	if err != nil {
    38		panic(err)
    39	}
    40
    41	// print results
    42	var results []bson.D
    43	if err = cursor.All(context.TODO(), &results); err != nil {
    44		panic(err)
    45	}
    46	for _, result := range results {
    47		fmt.Println(result)
    48	}
    49}

  2. Especifique el <connection-string>.

2

Ejecuta la query.

go run sort-by-numbers.go
[{title 12 Years a Slave} {awards [{wins 267}]}]
[{title Gravity} {awards [{wins 231}]}]
[{title Gravity} {awards [{wins 231}]}]
[{title Birdman: Or (The Unexpected Virtue of Ignorance)} {awards [{wins 210}]}]
[{title Boyhood} {awards [{wins 185}]}]
1

Definir la consulta.

  1. Crea un nuevo archivo llamado SortByNumbers.java y pega el siguiente código:

    1import java.util.Arrays;
    2
    3import static com.mongodb.client.model.Aggregates.limit;
    4import static com.mongodb.client.model.Aggregates.project;
    5import static com.mongodb.client.model.Projections.excludeId;
    6import static com.mongodb.client.model.Projections.fields;
    7import static com.mongodb.client.model.Projections.include;
    8import com.mongodb.client.MongoClient;
    9import com.mongodb.client.MongoClients;
    10import com.mongodb.client.MongoCollection;
    11import com.mongodb.client.MongoDatabase;
    12import org.bson.Document;
    13
    14public class SortByNumbers {
    15  public static void main( String[] args ) {
    16    // define query
    17    Document agg =
    18        new Document("$search", 
    19        	    new Document("index", "default")
    20        	            .append("range", 
    21        	    new Document("path", "awards.wins")
    22        	                .append("gte", 10L))
    23        	            .append("sort", 
    24        	    new Document("awards.wins", -1L)));
    25    
    26    // specify connection
    27    String uri = "<connection-string>";
    28    
    29    // establish connection and set namespace
    30    try (MongoClient mongoClient = MongoClients.create(uri)) {
    31      MongoDatabase database = mongoClient.getDatabase("sample_mflix");
    32      MongoCollection<Document> collection = database.getCollection("movies");
    33	  
    34      // run query and print results
    35      collection.aggregate(Arrays.asList(agg, 
    36        limit(5), 
    37        project(fields(excludeId(), include("title"), include("awards.wins")))))
    38        .forEach(doc -> System.out.println(doc.toJson()));	
    39    }
    40  }
    41}

    Nota

    Para ejecutar el código de muestra en su entorno Maven, agregue el siguiente código encima de las declaraciones de importación en su archivo.

    package com.mongodb.drivers;

  2. Especifique el <connection-string>.

2

Ejecuta la query.

javac SortByNumbers.java
java SortByNumbers
{"title": "12 Years a Slave", "awards": {"wins": 267}}
{"title": "Gravity", "awards": {"wins": 231}}
{"title": "Gravity", "awards": {"wins": 231}}
{"title": "Birdman: Or (The Unexpected Virtue of Ignorance)", "awards": {"wins": 210}}
{"title": "Boyhood", "awards": {"wins": 185}}
1

Definir la consulta.

  1. Crea un nuevo archivo llamado SortByNumbers.kt y pega el siguiente código:

    1import com.mongodb.client.model.Aggregates.limit
    2import com.mongodb.client.model.Aggregates.project
    3import com.mongodb.client.model.Projections.*
    4import com.mongodb.kotlin.client.coroutine.MongoClient
    5import kotlinx.coroutines.runBlocking
    6import org.bson.Document
    7
    8fun main() {
    9    // establish connection and set namespace
    10    val uri = "<connection-string>"
    11    val mongoClient = MongoClient.create(uri)
    12    val database = mongoClient.getDatabase("sample_mflix")
    13    val collection = database.getCollection<Document>("movies")
    14
    15    runBlocking {
    16        // define query
    17        val agg = Document(
    18            "\$search",
    19            Document("index", "default")
    20                .append(
    21                    "range",
    22                    Document("path", "awards.wins")
    23                        .append("gte", 10L)
    24                )
    25                .append(
    26                    "sort",
    27                    Document("awards.wins", -1L)
    28                )
    29        )
    30
    31        // run query and print results
    32        val resultsFlow = collection.aggregate<Document>(
    33            listOf(
    34                agg,
    35                limit(5),
    36                project(fields(
    37                    excludeId(),
    38                    include("title", "awards.wins")
    39                ))
    40            )
    41        )
    42        resultsFlow.collect { println(it) }
    43    }
    44    mongoClient.close()
    45}

  2. Especifique el <connection-string>.

2

Ejecuta la query.

kotlin SortByNumbers.kt
Document{{title=12 Years a Slave, awards=Document{{wins=267}}}}
Document{{title=Gravity, awards=Document{{wins=231}}}}
Document{{title=Gravity, awards=Document{{wins=231}}}}
Document{{title=Birdman: Or (The Unexpected Virtue of Ignorance), awards=Document{{wins=210}}}}
Document{{title=Boyhood, awards=Document{{wins=185}}}}
1

Definir la consulta.

  1. Crea un nuevo archivo llamado sort-by-numbers.js y pega el siguiente código:

    1const { MongoClient } = require("mongodb");
    2
    3// Replace the uri string with your MongoDB deployments connection string.
    4const uri =
    5  "<connection-string>";
    6
    7const client = new MongoClient(uri);
    8
    9async function run() {
    10  try {
    11    await client.connect();
    12
    13    // set namespace
    14    const database = client.db("sample_mflix");
    15    const coll = database.collection("movies");
    16
    17    // define pipeline
    18    const agg = [
    19      {
    20        '$search': {
    21          'index': 'default',
    22          'range': {
    23            'path': 'awards.wins', 
    24            'gte': 10
    25          }, 
    26          'sort': {
    27            'awards.wins': -1
    28          }
    29        }
    30      }, {
    31        '$limit': 5
    32      }, {
    33        '$project': {
    34          '_id': 0, 
    35          'title': 1, 
    36          'awards.wins': 1
    37        }
    38      }
    39    ];
    40
    41    // run pipeline
    42    const result = await coll.aggregate(agg);
    43
    44    // print results
    45    await result.forEach((doc) => console.log(doc));
    46
    47  } finally {
    48    await client.close();
    49  }
    50}
    51run().catch(console.dir);

  2. Especifique el <connection-string>.

2

Ejecuta la query.

node sort-by-numbers.js
{ title: '12 Years a Slave', awards: { wins: 267 } }
{ title: 'Gravity', awards: { wins: 231 } }
{ title: 'Gravity', awards: { wins: 231 } }
{
  title: 'Birdman: Or (The Unexpected Virtue of Ignorance)',
  awards: { wins: 210 }
}
{ title: 'Boyhood', awards: { wins: 185 } }
1

Definir la consulta.

  1. Crea un nuevo archivo llamado sort-by-numbers.py y pega el siguiente código:

    1import pymongo
    2
    3# connect to your Atlas cluster
    4client = pymongo.MongoClient('<connection-string>')
    5
    6# define pipeline
    7pipeline = [
    8  {
    9    '$search': {
    10      'index': 'default',
    11      'range': {
    12        'path': 'awards.wins',
    13        'gte': 10
    14      },
    15      'sort': {
    16        'awards.wins': -1
    17      }
    18    }
    19  }, {
    20    '$limit': 5
    21  }, {
    22    '$project': {'_id': 0, 'title': 1, 'awards.wins': 1
    23    }
    24  }
    25]
    26
    27# run pipeline
    28result = client['sample_mflix']['movies'].aggregate(pipeline)
    29
    30# print results
    31for i in result:
    32    print(i)

  2. Especifique el <connection-string>.

2

Ejecuta la query.

python sort-by-numbers.py
{'title': '12 Years a Slave', 'awards': {'wins': 267}}
{'title': 'Gravity', 'awards': {'wins': 231}}
{'title': 'Gravity', 'awards': {'wins': 231}}
{'title': 'Birdman: Or (The Unexpected Virtue of Ignorance)', 'awards': {'wins': 210}}
{'title': 'Boyhood', 'awards': {'wins': 185}}

Búsqueda y ordenación de cadenas

Ejemplo básico

La siguiente consulta en el espacio de sample_mflix.movies nombres utiliza la etapa para hacer lo $search siguiente:

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

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

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

  • Omitir todos los campos excepto title en los resultados.

  • Añade un campo llamado 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 y ordenamiento con comodines compuestos

La siguiente consulta muestra cómo consultar y ordenar los resultados por un campo de cadena. Busca títulos que comiencen por Prance o Prince y ordena los resultados por el campo title en orden ascendente.

La consulta utiliza las siguientes etapas de canalización:

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

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

  • $project etapa a:

    • Excluir todos los campos excepto title.

    • Añade un campo llamado score.

[
  {
    $search: {
      "compound": {
        "should": [{
          "wildcard": {
            "query": ["Prance*"],
            "path": "title",
            "allowAnalyzedField": true
          }
        },
        {
          "wildcard": {
            "query": ["Prince*"],
            "path": "title",
            "allowAnalyzedField": true
          }
        }]
      },
      "sort": {
        "title": 1
      }
    }
  }
]
SCORE: 1  _id:  "573a1398f29313caabceb98e"
  plot: "A farm girl nurses a wounded reindeer she believes is one of Santa's, …"
  genres: Array
  runtime: 103
  ...
  title: "Prancer"
  ...
SCORE: 1  _id:  "573a13a5f29313caabd14f54"
  plot: "Preteen brothers from a broken marriage live with their mother, Denise…"
  genres: Array
  runtime: 91
  ...
  title: "Prancer Returns"
  ...
SCORE: 1  _id:  "573a13f5f29313caabde3755"
  plot: "A troubled teenager attempts to conquer the love of his life by becomi…"
  genres: Array
  runtime: 78
  ...
  title: "Prince"
  ...
SCORE: 1  _id:  "573a13d8f29313caabda665f"
  fullplot: "Two highway road workers spend the summer of 1988 away from their city…"
  imdb: Object
  year: 2013
  ...
  title: "Prince Avalanche"
  ...
SCORE: 1  _id:  "573a13bdf29313caabd5898a"
  plot: "A New York street drama about the lives of immigrants in America seeki…"
  genres: Array
  runtime: 70
  ...
  title: "Prince of Broadway"
  ...
SCORE: 1  _id:  "573a1398f29313caabcea967"
  fullplot: "A sinister secret has been kept in the basement of an abandoned Los An…"
  imdb: Object
  year: 1987
  ...
  title: "Prince of Darkness"
  ...
SCORE: 1  _id:  "573a1393f29313caabcde40d"
  plot: "An unscrupulous agent for the Borgias suffers a change of heart when a…"
  genres: Array
  runtime: 107
  ...
  title: "Princess of Foxes"
  ...
SCORE: 1  _id:  "573a13b5f29313caabd43816"
  plot: "A young fugitive prince and princess must stop a villain who unknowing…"
  genres: Array
  runtime: 116
  ...
  title: "Prince of Persia: The Sands of Time"
  ...
SCORE: 1  _id:  "573a1397f29313caabce8081"
  plot: "A New York City narcotics detective reluctantly agrees to cooperate wi…"
  genres: Array
  runtime: 167
  ...
  title: "Prince of the City"
  ...
SCORE: 1  _id:  "573a13a2f29313caabd0a767"
  plot: "Six old-style funny silhouetted fairy tales for not so-old-style peopl…"
  genres: Array
  runtime: 70
  ...
  title: "Princes and Princesses"
  ...

Los resultados de MongoDB Search contienen documentos con títulos de películas que empiezan por Prance y Prince. MongoDB Search devuelve títulos con Prance seguido de Prince porque ordena los documentos por el campo title en orden ascendente.

Es posible que Search Tester no muestre todos los campos en los documentos que devuelve. Para ver todos los campos, incluido el campo que especifica en la ruta de query, expanda el documento en los resultados.

1db.movies.aggregate([{ 
2  $search: { 
3    "index": "default",
4    "compound": {
5      "should": [{
6        "wildcard": {
7          "query": ["Prance*"],
8          "path": "title",
9          "allowAnalyzedField": true
10        }
11      },
12      {
13        "wildcard": {
14          "query": ["Prince*"],
15          "path": "title",
16          "allowAnalyzedField": true
17        }
18      }]
19    },
20    "sort": {
21      "title": 1
22    }
23  }},
24  { 
25    $limit: 5
26  },
27  {
28    $project: {
29      "_id": 0,
30      "title": 1,
31      "score": { "$meta": "searchScore" }
32    }
33  }
34])
[
  { title: 'Prancer', score: 1 },
  { title: 'Prancer Returns', score: 1 },
  { title: 'Prince', score: 1 },
  { title: 'Prince Avalanche', score: 1 },
  { title: 'Prince of Broadway', score: 1 }
]

Los resultados de MongoDB Search contienen documentos con títulos de películas que empiezan por Prance y Prince. MongoDB Search devuelve títulos con Prance seguido de Prince porque ordena los documentos por el campo title en orden ascendente.

Etapa de tubería
Query

$search

{
  compound: {
    should: [{
      wildcard: {
      query: "Prance*",
      path: 'title',
      allowAnalyzedField: true
      }},
    {
      wildcard: {
      query: "Prince*",
      path: 'title',
      allowAnalyzedField: true
      }
    }]
  },
  sort: {
    title: 1
  }
}

$limit

5

$project

{
  _id: 0,
  title: 1,
  score: { $meta: "searchScore" }
}

Si habilitó Auto Preview, MongoDB Compass muestra los siguientes documentos junto a la etapa de canalización $project:

{
 title: 'Prancer',
 score: 1
},
{
 title: 'Prancer Returns',
 score: 1
},
{
 title: 'Prince',
 score: 1
},
{
 title: 'Prince Avalanche',
 score: 1
},
{
 title: 'Prince of Boradway',
 score: 1
}

Los resultados de MongoDB Search contienen documentos con títulos de películas que empiezan por Prance y Prince. MongoDB Search devuelve títulos con Prance seguido de Prince porque ordena los documentos por el campo title en orden ascendente.

El ejemplo de código realiza las siguientes tareas:

  • Importa los paquetes y dependencias de mongodb.

  • Establece una conexión con su clúster.

  • La consulta utiliza las siguientes etapas de canalización:

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

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

    • $project etapa a:

      • Excluir todos los campos excepto title.

      • Añade un campo llamado score.

  • Itera sobre el cursor para imprimir los documentos que coinciden con el query.

1using MongoDB.Bson;
2using MongoDB.Bson.Serialization.Attributes;
3using MongoDB.Bson.Serialization.Conventions;
4using MongoDB.Driver;
5using MongoDB.Driver.Search;
6
7public class SortByStrings
8{
9    private const string MongoConnectionString = "<connection-string>";
10
11    public static void Main(string[] args)
12    {
13        // allow automapping of the camelCase database fields to our MovieDocument
14        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
15        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
16
17        // connect to your Atlas cluster
18        var mongoClient = new MongoClient(MongoConnectionString);
19        var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
20        var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
21
22        // define search options
23        var searchOptions = new SearchOptions<MovieDocument>() 
24            { 
25                Sort = Builders<MovieDocument>.Sort.Ascending(movie => movie.Title),
26                IndexName = "default"
27            };
28
29        // define and run pipeline
30        var results = moviesCollection.Aggregate()
31            .Search(Builders<MovieDocument>.Search.Compound()
32                .Should(Builders<MovieDocument>.Search.Wildcard(movie => movie.Title, "Prance*", true ))
33                .Should(Builders<MovieDocument>.Search.Wildcard(movie => movie.Title, "Prince*" )), searchOptions)
34            .Project<MovieDocument>(Builders<MovieDocument>.Projection
35                .Include(movie => movie.Title)
36                .Exclude(movie => movie.Id)
37                .MetaSearchScore(movie => movie.Score))
38            .Limit(5)
39            .ToList();
40
41        // print results
42        foreach (var movie in results)
43        {
44            Console.WriteLine(movie.ToJson());
45        }
46    }
47}
48
49[BsonIgnoreExtraElements]
50public class MovieDocument
51{
52    [BsonIgnoreIfDefault]
53    public ObjectId Id { get; set; }
54    public string Title { get; set; }
55    public double Score { get; set; }
56}
{ "title" : "Prancer", "score" : 1.0 }
{ "title" : "Prancer Returns", "score" : 1.0 }
{ "title" : "Prince", "score" : 1.0 }
{ "title" : "Prince Avalanche", "score" : 1.0 }
{ "title" : "Prince of Broadway", "score" : 1.0 }

Los resultados de MongoDB Search contienen documentos con títulos de películas que empiezan por Prance y Prince. MongoDB Search devuelve títulos con Prance seguido de Prince porque ordena los documentos por el campo title en orden ascendente.

El ejemplo de código realiza las siguientes tareas:

  • Importa los paquetes y dependencias de mongodb.

  • Establece una conexión con su clúster.

  • Itera sobre el cursor para imprimir los documentos que coinciden con el query.

1package main
2
3import (
4	"context"
5	"fmt"
6
7	"go.mongodb.org/mongo-driver/v2/bson"
8	"go.mongodb.org/mongo-driver/v2/mongo"
9	"go.mongodb.org/mongo-driver/v2/mongo/options"
10)
11
12func main() {
13	// connect to your Atlas cluster
14	client, err := mongo.Connect(options.Client().ApplyURI("<connection-string>"))
15	if err != nil {
16		panic(err)
17	}
18	defer client.Disconnect(context.TODO())
19
20	// set namespace
21	collection := client.Database("sample_mflix").Collection("movies")
22
23	// define pipeline stages
24	searchStage := bson.D{{Key: "$search", Value: bson.M{
25		"index": "default",
26		"compound": bson.M{
27			"should": bson.A{
28				bson.M{
29					"wildcard": bson.D{
30						{Key: "path", Value: "title"},
31						{Key: "query", Value: "Prance*"},
32						{Key: "allowAnalyzedField", Value: true},
33					}},
34				bson.M{
35					"wildcard": bson.D{
36						{Key: "path", Value: "title"},
37						{Key: "query", Value: "Prince*"},
38						{Key: "allowAnalyzedField", Value: true},
39					}},
40			},
41		},
42		"sort": bson.D{{Key: "title", Value: 1}},
43	}}}
44
45	limitStage := bson.D{{Key: "$limit", Value: 5}}
46	projectStage := bson.D{{Key: "$project", Value: bson.D{{Key: "title", Value: 1}, {Key: "_id", Value: 0}, {Key: "score", Value: bson.D{{Key: "$meta", Value: "searchScore"}}}}}}
47
48	// run pipeline
49	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, limitStage, projectStage})
50	if err != nil {
51		panic(err)
52	}
53
54	// print results
55	var results []bson.D
56	if err = cursor.All(context.TODO(), &results); err != nil {
57		panic(err)
58	}
59	for _, result := range results {
60		fmt.Println(result)
61	}
62}
[{title Prancer} {score 1}]
[{title Prancer Returns} {score 1}]
[{title Prince} {score 1}]
[{title Prince Avalanche} {score 1}]
[{title Prince of Broadway} {score 1}]

Los resultados de MongoDB Search contienen documentos con títulos de películas que empiezan por Prance y Prince. MongoDB Search devuelve títulos con Prance seguido de Prince porque ordena los documentos por el campo title en orden ascendente.

El ejemplo de código realiza las siguientes tareas:

  • Importa los paquetes y dependencias de mongodb.

  • Establece una conexión con su clúster.

  • Itera sobre el cursor para imprimir los documentos que coinciden con el query.

1import java.util.Arrays;
2import java.util.List;
3
4import static com.mongodb.client.model.Aggregates.limit;
5import static com.mongodb.client.model.Aggregates.project;
6import static com.mongodb.client.model.Projections.*;
7import com.mongodb.client.MongoClient;
8import com.mongodb.client.MongoClients;
9import com.mongodb.client.MongoCollection;
10import com.mongodb.client.MongoDatabase;
11import org.bson.Document;
12
13import java.util.Date;
14
15public class SortByString {
16  public static void main( String[] args ) {
17    // define clause
18    List<Document> shouldClause =
19        List.of(
20            new Document(
21                "wildcard",
22                new Document("query", "Prance*")
23                    .append("path", "title")
24                    .append("allowAnalyzedField", true)),
25            new Document(
26                "wildcard",
27                new Document("query", "Prince*")
28                    .append("path", "title")
29                    .append("allowAnalyzedField", true)));
30    
31    // define query
32    Document agg =
33        new Document(
34            "$search",
35            new Document("index", "default")
36            .append("compound",
37                new Document("should", shouldClause))
38                .append("sort", new Document("title", 1L)));
39    
40    // specify connection
41    String uri = "<connection-string>";
42    
43    // establish connection and set namespace
44    try (MongoClient mongoClient = MongoClients.create(uri)) {
45      MongoDatabase database = mongoClient.getDatabase("sample_mflix");
46      MongoCollection<Document> collection = database.getCollection("movies");
47	  
48      // run query and print results
49      collection.aggregate(Arrays.asList(agg, 
50        limit(5),
51        project(fields(excludeId(), include("title"), computed("score", new Document("$meta", "searchScore"))))))
52        .forEach(doc -> System.out.println(doc.toJson()));	
53    }
54  }
55}
{"title": "Prancer", "score": 1.0}
{"title": "Prancer Returns", "score": 1.0}
{"title": "Prince", "score": 1.0}
{"title": "Prince Avalanche", "score": 1.0}
{"title": "Prince of Broadway", "score": 1.0}

Los resultados de MongoDB Search contienen documentos con títulos de películas que empiezan por Prance y Prince. MongoDB Search devuelve títulos con Prance seguido de Prince porque ordena los documentos por el campo title en orden ascendente.

El ejemplo de código realiza las siguientes tareas:

  • Importa los paquetes y dependencias de mongodb.

  • Establece una conexión con su clúster.

  • Imprime los documentos que coinciden con la consulta de la instancia AggregateFlow.

1import com.mongodb.client.model.Aggregates.limit
2import com.mongodb.client.model.Aggregates.project
3import com.mongodb.client.model.Projections.*
4import com.mongodb.kotlin.client.coroutine.MongoClient
5import kotlinx.coroutines.runBlocking
6import org.bson.Document
7
8fun main() {
9    // establish connection and set namespace
10    val uri = "<connection-string>"
11    val mongoClient = MongoClient.create(uri)
12    val database = mongoClient.getDatabase("sample_mflix")
13    val collection = database.getCollection<Document>("movies")
14
15    runBlocking {
16        // define clause
17        val shouldClause = listOf(
18            Document("wildcard", Document("query", "Prance*")
19                .append("path", "title")
20                .append("allowAnalyzedField", true)),
21            Document("wildcard", Document("query", "Prince*")
22                .append("path", "title")
23                .append("allowAnalyzedField", true))
24        )
25
26        // define query
27        val agg = Document(
28            "\$search",
29            Document("index", "default")
30                .append(
31                    "compound",
32                    Document("should", shouldClause)
33                )
34                .append("sort", Document("title", 1L))
35        )
36
37        // run query and print results
38        val resultsFlow = collection.aggregate<Document>(
39            listOf(
40                agg,
41                limit(5),
42                project(fields(
43                    excludeId(),
44                    include("title"),
45                    computed("score", Document("\$meta", "searchScore"))
46                ))
47            )
48        )
49        resultsFlow.collect { println(it) }
50    }
51    mongoClient.close()
52}
Document{{title=Prancer, score=1.0}}
Document{{title=Prancer Returns, score=1.0}}
Document{{title=Prince, score=1.0}}
Document{{title=Prince Avalanche, score=1.0}}
Document{{title=Prince of Broadway, score=1.0}}

Los resultados de MongoDB Search contienen documentos con títulos de películas que empiezan por Prance y Prince. MongoDB Search devuelve títulos con Prance seguido de Prince porque ordena los documentos por el campo title en orden ascendente.

El ejemplo de código realiza las siguientes tareas:

  • Importa mongodb, controlador Node.js de MongoDB.

  • Crea una instancia de la clase MongoClient para establecer una conexión a su clúster.

  • La consulta utiliza las siguientes etapas de canalización:

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

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

    • $project etapa a:

      • Excluir todos los campos excepto title.

      • Añade un campo llamado score.

  • Itera sobre el cursor para imprimir los documentos que coinciden con el query.

1const { MongoClient } = require("mongodb");
2
3// Replace the uri string with your MongoDB deployments connection string.
4const uri =
5  "<connection-string>";
6
7const client = new MongoClient(uri);
8
9async function run() {
10  try {
11    await client.connect();
12
13    // set namespace
14    const database = client.db("sample_mflix");
15    const coll = database.collection("movies");
16
17    // define pipeline
18    const agg = [
19      {
20        '$search': {
21          'compound': {
22            'should': [
23              {
24                'wildcard': {
25                  'query': [
26                    'Prance*'
27                  ], 
28                  'path': 'title', 
29                  'allowAnalyzedField': true
30                }
31              }, {
32                'wildcard': {
33                  'query': [
34                    'Prince*'
35                  ], 
36                  'path': 'title', 
37                  'allowAnalyzedField': true
38                }
39              }
40            ]
41          }, 
42          'sort': { 'title': 1 }
43        }
44      }, {
45        '$limit': 5
46      }, {
47        '$project': {'_id': 0, 'title': 1, 'score': {'$meta': 'searchScore'}
48        }
49      }
50    ];
51           
52    // run pipeline
53    const result = await coll.aggregate(agg);
54
55    // print results
56    await result.forEach((doc) => console.log(doc));
57    
58  } finally {
59    await client.close();
60  }
61}
62run().catch(console.dir);
{ title: 'Prancer', score: 1 }
{ title: 'Prancer Returns', score: 1 }
{ title: 'Prince', score: 1 }
{ title: 'Prince Avalanche', score: 1 }
{ title: 'Prince of Broadway', score: 1 }

Los resultados de MongoDB Search contienen documentos con títulos de películas que empiezan por Prance y Prince. MongoDB Search devuelve títulos con Prance seguido de Prince porque ordena los documentos por el campo title en orden ascendente.

El siguiente ejemplo de código:

  • Importa,pymongo el controlador Python de MongoDB y el dns módulo, que es necesario para conectar pymongo a Atlas mediante una cadena de conexión de lista de semillas DNS.

  • Crea una instancia de la clase MongoClient para establecer una conexión a su clúster.

  • La consulta utiliza las siguientes etapas de canalización:

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

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

    • $project etapa a:

      • Excluir todos los campos excepto title.

      • Añade un campo llamado score.

  • Itera sobre el cursor para imprimir los documentos que coinciden con el query.

1import pymongo
2
3# connect to your Atlas cluster
4client = pymongo.MongoClient('<connection-string>')
5
6# define pipeline
7pipeline = [
8  {'$search': {
9      'compound': {
10        'should': [{'wildcard': {'query': 'Prance*', 'path': 'title', 'allowAnalyzedField': True}},
11                   {'wildcard': {'query': 'Prince*', 'path': 'title', 'allowAnalyzedField': True}}]
12      }, 
13      'sort': { 'title': 1 }}},
14  {'$limit': 5},
15  {'$project': {'_id': 0, 'title': 1, 'score': {'$meta': 'searchScore'}}}
16]
17
18# run pipeline
19result = client['sample_mflix']['movies'].aggregate(pipeline)
20
21# print results
22for i in result:
23    print(i)
{'title': 'Prancer', 'score': 1.0}
{'title': 'Prancer Returns', 'score': 1.0}
{'title': 'Prince', 'score': 1.0}
{'title': 'Prince Avalanche', 'score': 1.0}
{'title': 'Prince of Broadway', 'score': 1.0}

Los resultados de MongoDB Search contienen documentos con títulos de películas que empiezan por Prance y Prince. MongoDB Search devuelve títulos con Prance seguido de Prince porque ordena los documentos por el campo title en orden ascendente.

Ejemplo de ordenamiento sin distinción entre mayúsculas y minúsculas

La siguiente consulta muestra cómo ordenar los resultados independientemente de si se trata de mayúsculas o minúsculas. Utiliza el operador de texto para buscar películas que contengan el término train en el title campo y, a continuación, ordena los resultados por el title valor del campo en orden ascendente.

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

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

  • Añade un campo llamado puntuación en los resultados.

[
  {
    "$search": {
      "text": {
        "path": "title",
        "query": "train",
      },
      "sort": {
        "title": 1
      }
    }
  }
]
SCORE: 3.317898988723755  _id: "573a139cf29313caabcf662c"
plot: "A train filled with atomic devices threatens to destroy the city of De…"
genres: Array
runtime: 122
SCORE: 3.317898988723755  _id: "64de50ae2932de4dd3203061"
genres: Array
title: "atomic train"
awards: Object
SCORE: 2.228306293487549  _id: "573a13bbf29313caabd52ff4"
fullplot: "Long ago up North on the Island of Berk, the young Viking, Hiccup, wan…"
imdb: Object
year: 2010
SCORE: 2.228306293487549  _id: "64de50da2932de4dd3204393"
genres: Array
title: "how to train your dragon"
awards: Object
SCORE: 2.008449077606201  _id: "573a13ccf29313caabd83281"
plot: "When Hiccup and Toothless discover an ice cave that is home to hundred…"
genres: Array
runtime: 102
SCORE: 1.4400973320007324  _id: "573a13b1f29313caabd36490"
plot: "The life and times of Howard Zinn: the historian, activist, and author…"
genres: Array
runtime: 78
SCORE: 2.228306293487549  _id: "573a1394f29313caabce0fb4"
plot: "A marshal tries to bring the son of an old friend, an autocratic cattl…"
genres: Array
runtime: 95
SCORE: 2.8528976440429688  _id: "573a13c8f29313caabd78a6b"
plot: "A couple embarks on a journey home for Chinese new year along with 130…"
genres: Array
runtime: 85
SCORE: 2.502213716506958  _id: "573a13baf29313caabd50811"
plot: "Two thugs from the Perth suburb of Midland catch the last train to Fre…"
genres: Array
runtime: 89
SCORE: 2.502213716506958  _id: "573a13a7f29313caabd1b667"
fullplot: "A teacher and a gangster meet by chance in a small town pharmacy. As a…"
imdb: Object
year: 2002

Los resultados contienen documentos ordenados independientemente de si se usan mayúsculas o minúsculas. Sin embargo, si se establece normalizer en none, MongoDB Search devuelve los siguientes resultados:

SCORE: 3.317898988723755  _id: "573a139cf29313caabcf662c"
plot: "A train filled with atomic devices threatens to destroy the city of De…"
genres: Array
runtime: 122
SCORE: 2.2382168769836426  _id: "573a13bbf29313caabd52ff4"
fullplot: "Long ago up North on the Island of Berk, the young Viking, Hiccup, wan…"
imdb: object
year: 2010
SCORE: 2.008449077606201  _id: "573a13ccf29313caabd83281"
plot: "When Hiccup and Toothless discover an ice cave that is home to hundred…"
genres: Array
runtime: 102
SCORE: 1.4400973320007324  _id: "573a13b1f29313caabd36490"
plot: "The life and times of Howard Zinn: the historian, activist, and author…"
genres: Array
runtime: 78
SCORE: 2.8528976440429688  _id: "573a13c8f29313caabd78a6b"
plot: "A couple embarks on a journey home for Chinese new year along with 130…"
genres: Array
runtime: 85
SCORE: 2.228306293487549  _id: "573a1394f29313caabce0fb4"
plot: "A marshal tries to bring the son of an old friend, an autocratic cattl…"
genres: Array
runtime: 95
SCORE: 2.502213716506958  _id: "573a13baf29313caabd50811"
plot: "Two thugs from the Perth suburb of Midland catch the last train to Fre…"
genres: Array
runtime: 89
SCORE: 2.502213716506958  _id: "573a13a7f29313caabd1b667"
fullplot: "A teacher and a gangster meet by chance in a small town pharmacy. As a…"
imdb: Object
year: 2002
SCORE: 3.3326687812805176  _id: "573a139af29313caabcef573"
plot: "A vengeful New York transit cop decides to steal a trainload of subway…"
genres: Array
runtime: 110
SCORE: 3.3326687812805176  _id: "573a1398f29313caabceb8f2"
plot: "Three stories are connected by a Memphis hotel and the spirit of Elvis…"
genres: Array
runtime: 110

Para ordenar tus resultados sin normalizar las mayúsculas y minúsculas, configura la opción normalizer en none (en la línea 7) en tu definición de índice, guarda la definición del índice y vuelve a ejecutar la query.

db.movies.aggregate(
  {
    "$search": {
      "index": "default",
      "text": {
        "path": "title",
        "query": "train",
      },
      "sort": {
        "title": 1
      }
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 1,
      "title": 1,
      "awards": 1,
      "score": { $meta: "searchScore" }
    }
  }
)
[
  {
    _id: ObjectId("573a139cf29313caabcf662c"),
    title: 'Atomic Train',
    awards: { wins: 1, nominations: 1, text: '1 win & 1 nomination.' },
    score: 3.317898988723755
  },
  {
    _id: ObjectId("64de50ae2932de4dd3203061"),
    title: 'atomic train',
    awards: { wins: 1, nominations: 1 },
    score: 3.317898988723755
  },
  {
    _id: ObjectId("573a13bbf29313caabd52ff4"),
    title: 'How to Train Your Dragon',
    awards: {
      wins: 32,
      nominations: 51,
      text: 'Nominated for 2 Oscars. Another 30 wins & 51 nominations.'
    },
    score: 2.228306293487549
  },
  {
    _id: ObjectId("64de50da2932de4dd3204393"),
    title: 'how to train your dragon',
    awards: { wins: 32, nominations: 51 },
    score: 2.228306293487549
  },
  {
    _id: ObjectId("573a13ccf29313caabd83281"),
    title: 'How to Train Your Dragon 2',
    awards: {
      wins: 18,
      nominations: 52,
      text: 'Nominated for 1 Oscar. Another 17 wins & 52 nominations.'
    },
    score: 2.008449077606201
  }
]

Los resultados contienen documentos ordenados independientemente de si se usan mayúsculas o minúsculas. Sin embargo, si se establece normalizer en none, MongoDB Search devuelve los siguientes resultados:

[
  {
    _id: ObjectId("573a139cf29313caabcf662c"),
    title: 'Atomic Train',
    awards: { wins: 1, nominations: 1, text: '1 win & 1 nomination.' },
    score: 3.3326687812805176
  },
 {
    _id: ObjectId("573a13bbf29313caabd52ff4"),
    title: 'How to Train Your Dragon',
    awards: {
      wins: 32,
      nominations: 51,
      text: 'Nominated for 2 Oscars. Another 30 wins & 51 nominations.'
    },
    score: 2.2382168769836426
  },
  {
    _id: ObjectId("573a13ccf29313caabd83281"),
    title: 'How to Train Your Dragon 2',
    awards: {
      wins: 18,
     nominations: 52,
      text: 'Nominated for 1 Oscar. Another 17 wins & 52 nominations.'
    },
    score: 2.0173802375793457
  },
  {
    _id: ObjectId("573a13b1f29313caabd36490"),
    title: "Howard Zinn: You Can't Be Neutral on a Moving Train",
    awards: { wins: 1, nominations: 0, text: '1 win.' },
    score: 1.446497917175293
  },
  {
    _id: ObjectId("573a13c8f29313caabd78a6b"),
    title: 'Last Train Home',
    awards: { wins: 14, nominations: 9, text: '14 wins & 9 nominations.' },
    score: 2.8655927181243896
  }
]

Para ordenar tus resultados sin normalizar las mayúsculas y minúsculas, configura la opción normalizer en none (en la línea 7) en tu definición de índice, guarda la definición del índice y vuelve a ejecutar la query.

Etapa de tubería
Query

$search

{
  "index": "default",
  "text": {
    "path": "title",
    "query": "train",
  },
  "sort": {
    "title": 1,
  }
}

$limit

5

$project

{
  "_id": 1,
  "title": 1,
  "awards": 1,
  "score": { $meta: "searchScore" }
}

Si Auto Previewhabilitó, MongoDB Compass muestra los siguientes documentos junto a la $project etapa de canalización:

_id: ObjectId('573a139cf29313caabcf662c')
title: 'Atomic Train'
awards: Object
score: 3.317898988723755
_id:  ObjectId("64de50ae2932de4dd3203061")
title: 'atomic train'
awards: Object
score: 3.317898988723755
_id: ObjectId('573a13bbf29313caabd52ff4')
title: 'How to Train Your Dragon'
awards: Object
score: 2.228306293487549
_id: ObjectId("64de50da2932de4dd3204393"),
title: 'how to train your dragon'
awards:
score: 2.228306293487549
_id: ObjectId('573a13ccf29313caabd83281')
title: 'How to Train Your Dragon 2'
awards: object
score: 2.0173802375793457

Los resultados contienen documentos ordenados independientemente de si se usan mayúsculas o minúsculas. Sin embargo, si se establece normalizer en none, MongoDB Search devuelve los siguientes resultados:

1using MongoDB.Bson;
2using MongoDB.Bson.Serialization.Attributes;
3using MongoDB.Bson.Serialization.Conventions;
4using MongoDB.Driver;
5using MongoDB.Driver.Search;
6
7public class CaseInsensitiveSort
8{
9    private const string MongoConnectionString = "<connection-string>";
10
11    public static void Main(string[] args)
12    {
13        // allow automapping of the camelCase database fields to our MovieDocument
14        var camelCaseConvention = new ConventionPack { new camelCaseConvention() };
15        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
16
17        // connect to your Atlas cluster
18        var mongoClient = new MongoClient(MongoConnectionString);
19        var yourDatabase = mongoClient.GetDatabase("sample_mflix");
20        var moviesCollection = yourDatabase.GetCollection<MovieDocument>("movies");
21        
22        // define options for search 
23        var searchOptions = new SearchOptions<MovieDocument>() {
24            Sort = Builders<MovieDocument>.Sort.Ascending(movie => movie.Title), 
25            IndexName = "default"
26        };
27        
28        // define and run pipeline
29        var results = moviesCollection.Aggregate()
30            .Search(Builders<MovieDocument>.Search.Text(movie => movie.Title, "train"), searchOptions)
31            .Limit (5)
32            .Project<MovieDocument>(Builders<MovieDocument>.Projection
33                .Include(movie => movie.Id)
34                .Include(movie => movie.Title)
35                .Include(movie => movie.Awards)
36                .MetaSearchScore(movie => movie.Score))
37            .ToList();
38
39        // print results
40        foreach (var movie in results)
41        {
42            Console.WriteLine(movie.ToJson());
43        }
44    }
45}
46
47[BsonIgnoreExtraElements]
48public class MovieDocument
49{
50    [BsonIgnoreIfDefault]
51    public ObjectId Id { get; set; }
52    public string Title { get; set; }
53    public Award Awards { get; set; }
54    public double Score { get; set; }
55}
56
57[BsonIgnoreExtraElements]
58public class Award
59{
60    public int Wins { get; set; }
61    public int Nominations { get; set; }
62}
{ "_id" : ObjectId("573a139cf29313caabcf662c"), "title" : "Atomic Train", "awards" : { "wins" : 1, "nominations" : 1 }, "score" : 3.3035578727722168 }
{ "_id" : ObjectId("64de50ae2932de4dd3203061"), "title" : "atomic train", "awards" : { "wins" : 1, "nominations" : 1 }, "score" : 3.3035578727722168 }
{ "_id" : ObjectId("573a13bbf29313caabd52ff4"), "title" : "How to Train Your Dragon", "awards" : { "wins" : 32, "nominations" : 51 }, "score" : 2.2186923027038574 }
{ "_id" : ObjectId("64de50da2932de4dd3204393"), "title" : "how to train your dragon", "awards" : { "wins" : 32, "nominations" : 51 }, "score" : 2.2186923027038574 }
{ "_id" : ObjectId("573a13ccf29313caabd83281"), "title" : "How to Train Your Dragon 2", "awards" : { "wins" : 18, "nominations" : 52 }, "score" : 1.9997868537902832 }

Los resultados contienen documentos ordenados independientemente de si se usan mayúsculas o minúsculas. Sin embargo, si se establece normalizer en none, MongoDB Search devuelve los siguientes resultados:

{ "_id" : ObjectId("573a139cf29313caabcf662c"), "title" : "Atomic Train", "awards" : { "wins" : 1, "nominations" : 1 }, "score" : 3.3035225868225098 }
{ "_id" : ObjectId("573a13bbf29313caabd52ff4"), "title" : "How to Train Your Dragon", "awards" : { "wins" : 32, "nominations" : 51 }, "score" : 2.2186522483825684 }
{ "_id" : ObjectId("573a13ccf29313caabd83281"), "title" : "How to Train Your Dragon 2", "awards" : { "wins" : 18, "nominations" : 52 }, "score" : 1.9997482299804688 }
{ "_id" : ObjectId("573a13b1f29313caabd36490"), "title" : "Howard Zinn: You Can't Be Neutral on a Moving Train", "awards" : { "wins" : 1, "nominations" : 0 }, "score" : 1.4338588714599609 }
{ "_id" : ObjectId("573a13c8f29313caabd78a6b"), "title" : "Last Train Home", "awards" : { "wins" : 14, "nominations" : 9 }, "score" : 2.8405368328094482 }

Para ordenar tus resultados sin normalizar las mayúsculas y minúsculas, configura la opción normalizer en none (en la línea 7) en tu definición de índice, guarda la definición del índice y vuelve a ejecutar la query.

1package main
2
3import (
4	"context"
5	"fmt"
6
7	"go.mongodb.org/mongo-driver/bson"
8	"go.mongodb.org/mongo-driver/mongo"
9	"go.mongodb.org/mongo-driver/mongo/options"
10)
11
12func main() {
13	// connect to your Atlas cluster
14	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI("<connection-string>"))
15	if err != nil {
16		panic(err)
17	}
18	defer client.Disconnect(context.TODO())
19
20	// set namespace
21	collection := client.Database("sample_mflix").Collection("movies")
22
23	// define pipeline stages
24	searchStage := bson.D{{"$search", bson.M{
25		"index": "default",
26		"text": bson.D{
27			{"path", "title"},
28			{"query", "train"},
29		},
30		"sort": bson.D{{"title", 1}},
31	}}}
32	limitStage := bson.D{{"$limit", 5}}
33	projectStage := bson.D{{"$project", bson.D{{"_id", 1}, {"title", 1}, {"awards", 1}, {"score", bson.D{{"$meta", "searchScore"}}}}}}
34
35	// run pipeline
36	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, limitStage, projectStage})
37	if err != nil {
38		panic(err)
39	}
40
41	// print results
42	var results []bson.D
43	if err = cursor.All(context.TODO(), &results); err != nil {
44		panic(err)
45	}
46	for _, result := range results {
47		fmt.Println(result)
48	}
49}
[{_id ObjectID("573a139cf29313caabcf662c")} {title Atomic Train} {awards [{wins 1} {nominations 1} {text 1 win & 1 nomination.}]} {score 3.317898988723755}]
[{_id ObjectId("64de50ae2932de4dd3203061")} {title atomic train} {awards [{wins 1} {nominations 1}]} {score 3.317898988723755}]
[{_id ObjectID("573a13bbf29313caabd52ff4")} {title How to Train Your Dragon} {awards [{wins 32} {nominations 51} {text Nominated for 2 Oscars. Another 30 wins & 51 nominations.}]} {score 2.228306293487549}]
[{_id ObjectId("64de50da2932de4dd3204393")} {title how to train your dragon} {awards [{wins 32} {nominations 51}]} {score 2.228306293487549}]
[{_id ObjectID("573a13ccf29313caabd83281")} {title How to Train Your Dragon 2} {awards [{wins 18} {nominations 52} {text Nominated for 1 Oscar. Another 17 wins & 52 nominations.}]} {score 2.008449077606201}]

Los resultados contienen documentos ordenados independientemente de si se usan mayúsculas o minúsculas. Sin embargo, si se establece normalizer en none, MongoDB Search devuelve los siguientes resultados:

[{_id ObjectID("573a139cf29313caabcf662c")} {title Atomic Train} {awards [{wins 1} {nominations 1} {text 1 win & 1 nomination.}]} {score 3.3326687812805176}]
[{_id ObjectID("573a13bbf29313caabd52ff4")} {title How to Train Your Dragon} {awards [{wins 32} {nominations 51} {text Nominated for 2 Oscars. Another 30 wins & 51 nominations.}]} {score 2.2382168769836426}]
[{_id ObjectID("573a13ccf29313caabd83281")} {title How to Train Your Dragon 2} {awards [{wins 18} {nominations 52} {text Nominated for 1 Oscar. Another 17 wins & 52 nominations.}]} {score 2.0173802375793457}]
[{_id ObjectID("573a13b1f29313caabd36490")} {title Howard Zinn: You Can't Be Neutral on a Moving Train} {awards [{wins 1} {nominations 0} {text 1 win.}]} {score 1.446497917175293}]
[{_id ObjectID("573a13c8f29313caabd78a6b")} {title Last Train Home} {awards [{wins 14} {nominations 9} {text 14 wins & 9 nominations.}]} {score 2.8655927181243896}]

Para ordenar tus resultados sin normalizar las mayúsculas y minúsculas, configura la opción normalizer en none (en la línea 7) en tu definición de índice, guarda la definición del índice y vuelve a ejecutar la query.

1import java.util.Arrays;
2import static com.mongodb.client.model.Aggregates.limit;
3import static com.mongodb.client.model.Aggregates.project;
4import static com.mongodb.client.model.Projections.*;
5import com.mongodb.client.MongoClient;
6import com.mongodb.client.MongoClients;
7import com.mongodb.client.MongoCollection;
8import com.mongodb.client.MongoDatabase;
9import org.bson.Document;
10
11public class CaseInsensitiveQuery {
12  public static void main( String[] args ) {
13    // define query
14	    Document agg =
15	        new Document("$search", 
16	        	    new Document("index", "default")
17	        	    .append("text", 
18	        	    	new Document("path", "title")
19	        	    	        .append("query", "train"))
20	        	    	            .append("sort", 
21	        	    	    new Document("title", 1)));
22
23    // specify connection
24    String uri = "<connection-string>";
25
26    // establish connection and set namespace
27    try (MongoClient mongoClient = MongoClients.create(uri)) {
28      MongoDatabase database = mongoClient.getDatabase("sample_mflix");
29      MongoCollection<Document> collection = database.getCollection("movies");
30      
31	  // run query and print results
32      collection.aggregate(Arrays.asList(agg, 
33        limit(5),
34        project(fields(include("_id"), include("title"), include("awards"), computed("score", new Document("$meta", "searchScore"))))))
35        .forEach(doc -> System.out.println(doc.toJson()));	
36    }
37  }
38}
{"_id": {"$oid": "573a139cf29313caabcf662c"}, "title": "Atomic Train", "awards": {"wins": 1, "nominations": 1, "text": "1 win & 1 nomination."}, "score": 3.317898988723755}
{"_id": {"$oid": "64de50ae2932de4dd3203061"}, "title": "atomic train", "awards": {"wins": 1, "nominations": 1}, "score": 3.317898988723755}
{"_id": {"$oid": "573a13bbf29313caabd52ff4"}, "title": "How to Train Your Dragon", "awards": {"wins": 32, "nominations": 51, "text": "Nominated for 2 Oscars. Another 30 wins & 51 nominations."}, "score": 2.228306293487549}
{"_id": {"$oid": "64de50da2932de4dd3204393"}, "title": "how to train your dragon", "awards": {"wins": 32, "nominations": 51}, "score": 2.228306293487549}
{"_id": {"$oid": "573a13ccf29313caabd83281"}, "title": "How to Train Your Dragon 2", "awards": {"wins": 18, "nominations": 52, "text": "Nominated for 1 Oscar. Another 17 wins & 52 nominations."}, "score": 2.008449077606201}

Los resultados contienen documentos ordenados independientemente de si se usan mayúsculas o minúsculas. Sin embargo, si se establece normalizer en none, MongoDB Search devuelve los siguientes resultados:

{"_id": {"$oid": "573a139cf29313caabcf662c"}, "title": "Atomic Train", "awards": {"wins": 1, "nominations": 1, "text": "1 win & 1 nomination."}, "score": 3.3326687812805176}
{"_id": {"$oid": "573a13bbf29313caabd52ff4"}, "title": "How to Train Your Dragon", "awards": {"wins": 32, "nominations": 51, "text": "Nominated for 2 Oscars. Another 30 wins & 51 nominations."}, "score": 2.2382168769836426}
{"_id": {"$oid": "573a13ccf29313caabd83281"}, "title": "How to Train Your Dragon 2", "awards": {"wins": 18, "nominations": 52, "text": "Nominated for 1 Oscar. Another 17 wins & 52 nominations."}, "score": 2.0173802375793457}
{"_id": {"$oid": "573a13b1f29313caabd36490"}, "title": "Howard Zinn: You Can't Be Neutral on a Moving Train", "awards": {"wins": 1, "nominations": 0, "text": "1 win."}, "score": 1.446497917175293}
{"_id": {"$oid": "573a13c8f29313caabd78a6b"}, "title": "Last Train Home", "awards": {"wins": 14, "nominations": 9, "text": "14 wins & 9 nominations."}, "score": 2.8655927181243896}

Para ordenar tus resultados sin normalizar las mayúsculas y minúsculas, configura la opción normalizer en none (en la línea 7) en tu definición de índice, guarda la definición del índice y vuelve a ejecutar la query.

1import com.mongodb.client.model.Aggregates.limit
2import com.mongodb.client.model.Aggregates.project
3import com.mongodb.client.model.Projections.*
4import com.mongodb.kotlin.client.coroutine.MongoClient
5import kotlinx.coroutines.runBlocking
6import org.bson.Document
7
8fun main() {
9    // establish connection and set namespace
10    val uri = "<connection-string>"
11    val mongoClient = MongoClient.create(uri)
12    val database = mongoClient.getDatabase("sample_mflix")
13    val collection = database.getCollection<Document>("movies")
14
15    runBlocking {
16        // define query
17        val agg = Document(
18            "\$search",
19            Document("index", "default")
20                .append(
21                    "text",
22                    Document("path", "title")
23                        .append("query", "train")
24                )
25                .append(
26                    "sort",
27                    Document("title", 1)
28                )
29        )
30
31        // run query and print results
32        val resultsFlow = collection.aggregate<Document>(
33            listOf(
34                agg,
35                limit(5),
36                project(fields(
37                    excludeId(),
38                    include("title", "awards"),
39                    computed("score", Document("\$meta", "searchScore"))
40                ))
41            )
42        )
43        resultsFlow.collect { println(it) }
44    }
45    mongoClient.close()
46}
Document{{title=atomic train, awards=Document{{wins=1, nominations=1}}, score=3.3326687812805176}}
Document{{title=Atomic Train, awards=Document{{wins=1, nominations=1, text=1 win & 1 nomination.}}, score=3.3326687812805176}}
Document{{title=how to train your dragon, awards=Document{{wins=32, nominations=51}}, score=2.2382168769836426}}
Document{{title=How to Train Your Dragon, awards=Document{{wins=32, nominations=51, text=Nominated for 2 Oscars. Another 30 wins & 51 nominations.}}, score=2.2382168769836426}}
Document{{title=How to Train Your Dragon 2, awards=Document{{wins=18, nominations=52, text=Nominated for 1 Oscar. Another 17 wins & 52 nominations.}}, score=2.0173802375793457}}

Los resultados contienen documentos ordenados independientemente de si se usan mayúsculas o minúsculas. Sin embargo, si se establece normalizer en none, MongoDB Search devuelve los siguientes resultados:

Document{{title=Atomic Train, awards=Document{{wins=1, nominations=1, text=1 win & 1 nomination.}}, score=3.3326687812805176}}
Document{{title=How to Train Your Dragon, awards=Document{{wins=32, nominations=51, text=Nominated for 2 Oscars. Another 30 wins & 51 nominations.}}, score=2.2382168769836426}}
Document{{title=How to Train Your Dragon 2, awards=Document{{wins=18, nominations=52, text=Nominated for 1 Oscar. Another 17 wins & 52 nominations.}}, score=2.0173802375793457}}
Document{{title=Howard Zinn: You Can't Be Neutral on a Moving Train, awards=Document{{wins=1, nominations=0, text=1 win.}}, score=1.446497917175293}}
Document{{title=Last Train Home, awards=Document{{wins=14, nominations=9, text=14 wins & 9 nominations.}}, score=2.8655927181243896}}

Para ordenar tus resultados sin normalizar las mayúsculas y minúsculas, configura la opción normalizer en none (en la línea 7) en tu definición de índice, guarda la definición del índice y vuelve a ejecutar la query.

1const { MongoClient } = require("mongodb");
2
3// Replace the uri string with your MongoDB deployments connection string.
4const uri =
5  "<connection-string>";
6
7const client = new MongoClient(uri);
8
9async function run() {
10  try {
11    await client.connect();
12
13    // set namespace
14    const database = client.db("sample_mflix");
15    const coll = database.collection("movies");
16
17    // define pipeline
18    const agg = [
19        {
20          '$search': {
21            'index': 'default', 
22            'text': { 'path': 'title', 'query': 'train' }, 
23            'sort': { 'title': 1 }
24          }
25        }, {
26          '$limit': 5
27        }, {
28          '$project': { '_id': 1, 'title': 1, 'awards': 1, 'score': { '$meta': 'searchScore' }}
29        }
30      ];
31           
32    // run pipeline
33    const result = await coll.aggregate(agg);
34
35    // print results
36    await result.forEach((doc) => console.log(doc));
37    
38  } finally {
39    await client.close();
40  }
41}
42run().catch(console.dir);
{
  _id: new ObjectId("573a139cf29313caabcf662c"),
  title: 'Atomic Train',
  awards: { wins: 1, nominations: 1, text: '1 win & 1 nomination.' },
  score: 3.317898988723755
}
{
  _id: new ObjectId("64de50ae2932de4dd3203061"),
  title: 'atomic train',
  awards: { wins: 1, nominations: 1 },
 score: 3.317898988723755
}
{
  _id: new ObjectId("573a13bbf29313caabd52ff4"),
  title: 'How to Train Your Dragon',
  awards: {
    wins: 32,
    nominations: 51,
    text: 'Nominated for 2 Oscars. Another 30 wins & 51 nominations.'
  },
  score: 2.228306293487549
}
{
  _id: new ObjectId("64de50da2932de4dd3204393"),
  title: 'how to train your dragon',
  awards: { wins: 32, nominations: 51 },
  score: 2.228306293487549
}
{
  _id: new ObjectId("573a13ccf29313caabd83281"),
  title: 'How to Train Your Dragon 2',
  awards: {
    wins: 18,
    nominations: 52,
    text: 'Nominated for 1 Oscar. Another 17 wins & 52 nominations.'
  },
  score: 2.008449077606201
}

Los resultados contienen documentos ordenados independientemente de si se usan mayúsculas o minúsculas. Sin embargo, si se establece normalizer en none, MongoDB Search devuelve los siguientes resultados:

{
  _id: new ObjectId("573a139cf29313caabcf662c"),
  title: 'Atomic Train',
  awards: { wins: 1, nominations: 1, text: '1 win & 1 nomination.' },
  score: 3.3326687812805176
}
{
  _id: new ObjectId("573a13bbf29313caabd52ff4"),
  title: 'How to Train Your Dragon',
  awards: {
    wins: 32,
    nominations: 51,
    text: 'Nominated for 2 Oscars. Another 30 wins & 51 nominations.'
  },
  score: 2.2382168769836426
}
{
  _id: new ObjectId("573a13ccf29313caabd83281"),
  title: 'How to Train Your Dragon 2',
  awards: {
    wins: 18,
    nominations: 52,
    text: 'Nominated for 1 Oscar. Another 17 wins & 52 nominations.'
  },
  score: 2.0173802375793457
}
{
  _id: new ObjectId("573a13b1f29313caabd36490"),
  title: "Howard Zinn: You Can't Be Neutral on a Moving Train",
  awards: { wins: 1, nominations: 0, text: '1 win.' },
  score: 1.446497917175293
}
{
  _id: new ObjectId("573a13c8f29313caabd78a6b"),
  title: 'Last Train Home',
  awards: { wins: 14, nominations: 9, text: '14 wins & 9 nominations.' },
  score: 2.8655927181243896
}

Para ordenar tus resultados sin normalizar las mayúsculas y minúsculas, configura la opción normalizer en none (en la línea 7) en tu definición de índice, guarda la definición del índice y vuelve a ejecutar la query.

1import pymongo
2
3# connect to your Atlas cluster
4client = pymongo.MongoClient('<connection-string>')
5
6# define pipeline
7pipeline = [
8    {
9        '$search': {
10            'index': 'default', 
11            'text': { 'path': 'title', 'query': 'train' }, 
12            'sort': { 'title': 1 }
13        }
14    }, {
15        '$limit': 5
16    }, {
17        '$project': { '_id': 1, 'title': 1, 'awards': 1, 'score': { '$meta': 'searchScore' } }
18    }
19]
20
21# run pipeline
22result = client['sample_mflix']['movies'].aggregate(pipeline)
23
24# print results
25for i in result:
26    print(i)
{'_id': ObjectId('573a139cf29313caabcf662c'), 'title': 'Atomic Train', 'awards': {'wins': 1, 'nominations': 1, 'text': '1 win & 1 nomination.'}, 'score': 3.317898988723755}
{'_id': ObjectId('64de50ae2932de4dd3203061'), 'title': 'atomic train', 'awards': {'wins': 1, 'nominations': 1}, 'score': 3.317898988723755}
{'_id': ObjectId('573a13bbf29313caabd52ff4'), 'title': 'How to Train Your Dragon', 'awards': {'wins': 32, 'nominations': 51, 'text': 'Nominated for 2 Oscars. Another 30 wins & 51 nominations.'}, 'score': 2.228306293487549}
{'_id': ObjectId('64de50da2932de4dd3204393'), 'title': 'how to train your dragon', 'awards': {'wins': 32, 'nominations': 51}, 'score': 2.228306293487549}
{'_id': ObjectId('573a13ccf29313caabd83281'), 'title': 'How to Train Your Dragon 2', 'awards': {'wins': 18, 'nominations': 52, 'text': 'Nominated for 1 Oscar. Another 17 wins & 52 nominations.'}, 'score': 2.008449077606201}

Los resultados contienen documentos ordenados independientemente de si se usan mayúsculas o minúsculas. Sin embargo, si se establece normalizer en none, MongoDB Search devuelve los siguientes resultados:

{'_id': ObjectId('573a139cf29313caabcf662c'), 'title': 'Atomic Train', 'awards': {'wins': 1, 'nominations': 1, 'text': '1 win & 1 nomination.'}, 'score': 3.3326687812805176}
{'_id': ObjectId('573a13bbf29313caabd52ff4'), 'title': 'How to Train Your Dragon', 'awards': {'wins': 32, 'nominations': 51, 'text': 'Nominated for 2 Oscars. Another 30 wins & 51 nominations.'}, 'score': 2.2382168769836426}
{'_id': ObjectId('573a13ccf29313caabd83281'), 'title': 'How to Train Your Dragon 2', 'awards': {'wins': 18, 'nominations': 52, 'text': 'Nominated for 1 Oscar. Another 17 wins & 52 nominations.'}, 'score': 2.0173802375793457}
{'_id': ObjectId('573a13b1f29313caabd36490'), 'title': "Howard Zinn: You Can't Be Neutral on a Moving Train", 'awards': {'wins': 1, 'nominations': 0, 'text': '1 win.'}, 'score': 1.446497917175293}
{'_id': ObjectId('573a13c8f29313caabd78a6b'), 'title': 'Last Train Home', 'awards': {'wins': 14, 'nominations': 9, 'text': '14 wins & 9 nominations.'}, 'score': 2.8655927181243896}

Para ordenar tus resultados sin normalizar las mayúsculas y minúsculas, configura la opción normalizer en none (en la línea 7) en tu definición de índice, guarda la definición del índice y vuelve a ejecutar la query.

Ordenar por ObjectId

La siguiente consulta utiliza el operador de rango para buscar released sample_mflix.movies películas estrenadas entre el 2015-01-01 y el en el campo de la 2015-12-31 colección. Ordena los resultados por el _id campo, que contiene un valor de ObjectId tipo, 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

Considere las siguientes consultas que buscan b la cadena en el campo hello de la users colección mediante el operador de texto. La consulta ordena los resultados por c el campo, que contiene valores nulos o faltantes para algunos documentos de la colección.

Para obtener más información, consulte Ordenar por valores nulos y faltantes.

Durante una ordenación ascendente, MongoDB Search devuelve documentos con valores nulos o faltantes en la parte superior de los resultados de forma predeterminada, 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 }
]

Durante una ordenación descendente, MongoDB Search devuelve documentos con valores nulos o faltantes en la parte inferior de los resultados de forma predeterminada, 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 predeterminada.

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

Si especifica el campo noData como lowest durante una ordenación descendente, MongoDB Search devuelve documentos con valores nulos o faltantes 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 }
]

Si especifica el campo noData como highest durante una ordenación ascendente, MongoDB Search devuelve documentos con valores nulos o faltantes 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": "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 }
]

Si especifica el campo noData como highest durante una ordenación descendente, MongoDB Search devuelve documentos con valores nulos o faltantes 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 faltantes como iguales al ordenar.

Ordenar en matrices multitipo

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

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

La siguiente consulta busca b en el campo la cadena hello utilizando el operador de texto y ordena los resultados por el c campo.

Nota

La noData: lowest configuración en la sintaxis de clasificación es la misma que la predeterminada.

Para una ordenación ascendente, MongoDB Search utiliza el elemento con el tipo BSON más bajo para representar la matriz multitipada. De forma predeterminada, MongoDB Search considera los valores nulos o faltantes como el valor BSON más bajo. Por lo tanto, MongoDB Search utiliza null para representar la matriz multitipada del documento con _id: 7 y devuelve este documento al principio de los resultados junto con otros valores nulos o faltantes.

Para obtener más información, consulte Ordenar por valores nulos y faltantes y Ordenar matrices 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 faltantes como iguales al ordenar.

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

Para obtener más información, consulte Ordenar por valores nulos y faltantes y Ordenar matrices 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 faltantes como iguales al ordenar.

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

Para una ordenación ascendente, MongoDB Search utiliza el elemento con el tipo BSON más bajo para representar la matriz multitipada. La consulta especifica noData: highest para considerar los valores nulos o faltantes como el valor BSON más alto. Por lo tanto, MongoDB Search utiliza 15 para representar la matriz multitipada del documento con, ya _id: 7 que los números son el siguiente tipo BSON más bajo de la matriz.

Para obtener más información, consulte Ordenar por valores nulos y faltantes y Ordenar matrices 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 faltantes como iguales al ordenar.

Para una ordenación descendente, MongoDB Search utiliza el elemento con el tipo BSON más alto para representar la matriz multitipada. Dado que la consulta especifica el noData campo como highest para establecer los valores nulos o faltantes como el valor BSON más alto, MongoDB Search utiliza null para representar la matriz multitipada del documento con _id: 7 y ​​devuelve este documento al principio de los resultados junto con otros valores nulos o faltantes.

Para obtener más información, consulte Ordenar por valores nulos y faltantes y Ordenar matrices 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 faltantes como iguales al ordenar.

Ordenar por booleano

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

La consulta utiliza la etapa para limitar la salida $limit a 5 documentos. También utiliza la etapa para omitir todos los $project campos name property_typeexcepto,, 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 una ordenación descendente, MongoDB Search clasifica los valores true por encima de los valores false. Si realiza una ordenación ascendente cambiando el valor de la línea 9 de la consulta anterior a 1, MongoDB Search clasifica los documentos con valores false por encima de los valores 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 ordenación de compuestos

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

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

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

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

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

  • Añade un campo llamado 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 de facetas

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

  • Busque películas estrenadas entre 01 el de enero de2010 y 01 el de enero de2015 utilizando el operador de rango.

  • Obtenga un recuento de la cantidad de películas que ganaron 1, 5, 10 y 15 premios.

  • Obtenga un recuento de la cantidad de películas estrenadas los días 2010-01-01, 2011-01-01, 2012-01-01, 2013-01-01, 2014-01-01 y 2015-01-01.

  • Ordene los resultados en orden descendente de fecha de publicación utilizando la opción sort.

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

  • Limite 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 para incluir los resultados de metadatos almacenados en $replaceWith la $$SEARCH_META variable en el meta campo de salida y la etapa para agregar $set el meta campo 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 muestran cómo ordenar los resultados según la puntuación de los documentos. Los ejemplos muestran cómo realizar las siguientes acciones:

  • Recupere primero los documentos con la puntuación más baja ordenando los resultados en orden ascendente.

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

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

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

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

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

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

  • Omitir todos los campos excepto title en los resultados.

  • Añade un campo llamado 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
  }
]

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

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

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

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

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

  • Añade un campo llamado 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
  }
]

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

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

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

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

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

  • Añade un campo llamado 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