Atlas Search 결과 정렬

쿼리를 실행합니다.

다음 쿼리를 복사하여 Query Editor에 붙여 넣은 다음 Query Editor에서 Search 버튼을 클릭합니다.

[
  {
    $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
  ...

쿼리 결과를 확장합니다.

Search Tester는 반환하는 문서의 모든 필드를 표시하지 않을 수 있습니다. 쿼리 경로에 지정한 필드를 비롯하여 모든 필드를 보려면 결과에서 문서를 펼칩니다.

쿼리를 정의합니다.

1. Program.cs 파일의 내용을 다음 코드로 바꿉니다.

   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. <connection-string>을 지정합니다.

쿼리를 실행합니다.

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. sort-by-date.go라는 이름의 새 파일을 만들고 다음 코드를 붙여넣습니다.

   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. <connection-string>을 지정합니다.

쿼리를 실행합니다.

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. SortByDate.java라는 이름의 새 파일을 만들고 다음 코드를 붙여넣습니다.

   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
   }

   참고

   Maven 환경에서 샘플 코드를 실행하려면 파일의 가져오기 문 위에 다음 코드를 추가합니다.

   package com.mongodb.drivers;

2. <connection-string>을 지정합니다.

쿼리를 실행합니다.

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. SortByDate.kt라는 이름의 새 파일을 만들고 다음 코드를 붙여넣습니다.

   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. <connection-string>을 지정합니다.

쿼리를 실행합니다.

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. sort-by-date.js라는 이름의 새 파일을 만들고 다음 코드를 붙여넣습니다.

   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. <connection-string>을 지정합니다.

쿼리를 실행합니다.

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. sort-by-date.py라는 이름의 새 파일을 만들고 다음 코드를 붙여넣습니다.

   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. <connection-string>을 지정합니다.

쿼리를 실행합니다.

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}

쿼리를 실행합니다.

다음 쿼리를 복사하여 Query Editor에 붙여 넣은 다음 Query Editor에서 Search 버튼을 클릭합니다.

[
  {
    "$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
    ...
  ...

쿼리 결과를 확장합니다.

Search Tester는 반환하는 문서의 모든 필드를 표시하지 않을 수 있습니다. 쿼리 경로에 지정한 필드를 비롯하여 모든 필드를 보려면 결과에서 문서를 펼칩니다.

쿼리를 정의합니다.

1. 프로젝트에서 Program.cs 파일의 내용을 다음 코드로 바꿉니다.

   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. <connection-string>을 지정합니다.

쿼리를 실행합니다.

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. sort-by-numbers.go라는 이름의 새 파일을 만들고 다음 코드를 붙여넣습니다.

   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. <connection-string>을 지정합니다.

쿼리를 실행합니다.

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. SortByNumbers.java라는 이름의 새 파일을 만들고 다음 코드를 붙여넣습니다.

   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
   }

   참고

   Maven 환경에서 샘플 코드를 실행하려면 파일의 가져오기 문 위에 다음 코드를 추가합니다.

   package com.mongodb.drivers;

2. <connection-string>을 지정합니다.

쿼리를 실행합니다.

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. SortByNumbers.kt라는 이름의 새 파일을 만들고 다음 코드를 붙여넣습니다.

   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. <connection-string>을 지정합니다.

쿼리를 실행합니다.

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. sort-by-numbers.js라는 이름의 새 파일을 만들고 다음 코드를 붙여넣습니다.

   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. <connection-string>을 지정합니다.

쿼리를 실행합니다.

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. sort-by-numbers.py라는 이름의 새 파일을 만들고 다음 코드를 붙여넣습니다.

   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. <connection-string>을 지정합니다.

쿼리를 실행합니다.

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