ordene los resultados de MongoDB Search

Ejecuta la query.

Copia y pega la siguiente query 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
  ...

Expandir tus resultados de query.

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.

Define la query.

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

   1
   using MongoDB.Bson;
   2
   using MongoDB.Bson.Serialization.Attributes;
   3
   using MongoDB.Bson.Serialization.Conventions;
   4
   using MongoDB.Driver;
   5
   using MongoDB.Driver.Search;
   6
   7
   public 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]
   55
   public 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>.

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 }

Define la query.

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

   1
   package main
   2
   3
   import (
   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
   13
   func 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>.

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

Define la query.

1. Cree un nuevo archivo llamado SortByDate.java y pegue el siguiente código:

   1
   import java.util.Arrays;
   2
   import java.util.List;
   3
   4
   import static com.mongodb.client.model.Aggregates.limit;
   5
   import static com.mongodb.client.model.Aggregates.project;
   6
   import static com.mongodb.client.model.Projections.*;
   7
   import com.mongodb.client.MongoClient;
   8
   import com.mongodb.client.MongoClients;
   9
   import com.mongodb.client.MongoCollection;
   10
   import com.mongodb.client.MongoDatabase;
   11
   import org.bson.Document;
   12
   13
   import java.time.Instant;
   14
   import java.util.Date;
   15
   16
   public 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>.

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}

Define la query.

1. Cree un nuevo archivo llamado SortByDate.kt y pegue el siguiente código:

   1
   import com.mongodb.client.model.Aggregates.limit
   2
   import com.mongodb.client.model.Aggregates.project
   3
   import com.mongodb.client.model.Projections.*
   4
   import com.mongodb.kotlin.client.coroutine.MongoClient
   5
   import kotlinx.coroutines.runBlocking
   6
   import org.bson.Document
   7
   import java.time.Instant
   8
   import java.util.*
   9
   10
   fun 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>.

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

Define la query.

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

   1
   const { MongoClient } = require("mongodb");
   2
   3
   // Replace the uri string with your MongoDB deployments connection string.
   4
   const uri =
   5
     "<connection-string>";
   6
   7
   const client = new MongoClient(uri);
   8
   9
   async 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
   }
   41
   run().catch(console.dir);

2. Especifique el <connection-string>.

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
}

Define la query.

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

   1
   import datetime
   2
   import pymongo
   3
   4
   # connect to your Atlas cluster
   5
   client = pymongo.MongoClient('<connection-string>')
   6
   7
   # define pipeline
   8
   pipeline = [
   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
   24
   result = client['sample_mflix']['movies'].aggregate(pipeline)
   25
   26
   # print results
   27
   for i in result:
   28
       print(i)

2. Especifique el <connection-string>.

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}

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

Expandir tus resultados de query.

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.

Define la query.

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

   1
   using MongoDB.Bson;
   2
   using MongoDB.Bson.Serialization.Attributes;
   3
   using MongoDB.Bson.Serialization.Conventions;
   4
   using MongoDB.Driver;
   5
   using MongoDB.Driver.Search;
   6
   7
   public 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]
   49
   public 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
   57
   public class Award
   58
   {
   59
       [BsonIgnoreIfDefault]
   60
       public int Wins { get; set; }
   61
   }

2. Especifique el <connection-string>.

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

Define la query.

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

   1
   package main
   2
   3
   import (
   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
   12
   func 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>.

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

Define la query.

1. Cree un nuevo archivo llamado SortByNumbers.java y pegue el siguiente código:

   1
   import java.util.Arrays;
   2
   3
   import static com.mongodb.client.model.Aggregates.limit;
   4
   import static com.mongodb.client.model.Aggregates.project;
   5
   import static com.mongodb.client.model.Projections.excludeId;
   6
   import static com.mongodb.client.model.Projections.fields;
   7
   import static com.mongodb.client.model.Projections.include;
   8
   import com.mongodb.client.MongoClient;
   9
   import com.mongodb.client.MongoClients;
   10
   import com.mongodb.client.MongoCollection;
   11
   import com.mongodb.client.MongoDatabase;
   12
   import org.bson.Document;
   13
   14
   public 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>.

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

Define la query.

1. Cree un nuevo archivo llamado SortByNumbers.kt y pegue el siguiente código:

   1
   import com.mongodb.client.model.Aggregates.limit
   2
   import com.mongodb.client.model.Aggregates.project
   3
   import com.mongodb.client.model.Projections.*
   4
   import com.mongodb.kotlin.client.coroutine.MongoClient
   5
   import kotlinx.coroutines.runBlocking
   6
   import org.bson.Document
   7
   8
   fun 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>.

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

Define la query.

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

   1
   const { MongoClient } = require("mongodb");
   2
   3
   // Replace the uri string with your MongoDB deployments connection string.
   4
   const uri =
   5
     "<connection-string>";
   6
   7
   const client = new MongoClient(uri);
   8
   9
   async 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
   }
   51
   run().catch(console.dir);

2. Especifique el <connection-string>.

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

Define la query.

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

   1
   import pymongo
   2
   3
   # connect to your Atlas cluster
   4
   client = pymongo.MongoClient('<connection-string>')
   5
   6
   # define pipeline
   7
   pipeline = [
   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
   28
   result = client['sample_mflix']['movies'].aggregate(pipeline)
   29
   30
   # print results
   31
   for i in result:
   32
       print(i)

2. Especifique el <connection-string>.

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