Atlas Search에서 패싯을 사용하는 방법

Atlas Clusters 에서 프로젝트 의 페이지로 이동합니다.

1. 아직 표시되지 않은 경우 탐색 표시줄의 Organizations 메뉴에서 원하는 프로젝트가 포함된 조직을 선택합니다.

2. 아직 표시되지 않은 경우 탐색 표시줄의 Projects 메뉴에서 원하는 프로젝트를 선택합니다.

3. 아직 표시되지 않은 경우 사이드바에서 Clusters 을(를) 클릭합니다.

   Clusters(클러스터) 페이지가 표시됩니다.

클러스터의 Atlas Search 페이지로 이동합니다.

사이드바, Data Explorer 또는 클러스터 세부 정보 페이지에서 Atlas Search 페이지로 이동할 수 있습니다.

로 고 (Go)Search Tester 합니다.

쿼리할 인덱스 오른쪽에 있는 Query 버튼을 클릭합니다.

쿼리 구문을 보고 수정합니다.

Edit $search Query 을 클릭하면 JSON 형식의 기본 쿼리 구문 샘플을 볼 수 있습니다.

인덱싱된 필드에 대해 Atlas Search 쿼리를 실행합니다.

쿼리를 실행하려면 다음 쿼리를 복사하여 Query Editor 에 붙여넣은 다음 Search 클릭하세요.

다음 쿼리는 1921년 11월 11일 근처에 개봉된 영화를 검색합니다. 약 3개월의 origin 로부터의 pivot 기간을 지정합니다. genres, year 필드에 대한 메타데이터를 요청합니다. 쿼리는 다음을 카운트합니다.

• genres 문자열 배열 필드에 있는 각 장르의 영화 수입니다.

• 1910년부터 1939년까지의 영화 수(포함)

[
  {
    "$searchMeta": {
      "index": "facet-tutorial",
      "facet": {
        "operator": {
          "near": {
            "path": "released",
            "origin": ISODate("1921-11-01T00:00:00.000+00:00"),
            "pivot": 7776000000
          }
        },
        "facets": {
          "genresFacet": {
            "type": "string",
            "path": "genres"
          },
          "yearFacet" : {
            "type" : "number",
            "path" : "year",
            "boundaries" : [1910,1920,1930,1940]
          }
        }
      }
    }
  }
]

쿼리 결과를 확장합니다.

Search Tester이(가) 결과 내 필드에 대한 모든 값을 표시하지 않을 수 있습니다. 결과 내 필드에 대한 모든 값을 보려면 필드를 확장합니다.

Atlas Search은 페이지에 다음과 같은 결과를 표시합니다:

count: Object
  lowerBound: 20878
facet: Object
  genresFacet: Object
    buckets: Array (10)
      0: Object
         _id: "Drama"
         count: 12149
      1: Object
         _id: "Comedy"
         count: 6436
      2: Object
         _id: "Romance"
         count: 3274
      3: Object
         _id: "Crime"
         count: 2429
      4: Object
         _id: "Thriller"
         count: 2400
      5: Object
         _id: "Action"
         count: 2349
      6: Object
         _id: "Adventure"
         count: 1876
      7: Object
         _id: "Documentary"
         count: 1755
      8: Object
         _id: "Horror"
         count: 1432
      9: Object
         _id: "Biography"
         count: 1244
  yearFacet: Object
    buckets: Array (3)
      0: Object
         _id: 1910
         count: 14
      1: Object
         _id: 1920
         count: 47
      2: Object
         _id: 1930
         count: 238

에서 클러스터 mongosh에 연결합니다.

터미널 창에서 mongosh 를 열고 클러스터에 연결합니다. 연결에 대한 자세한 지침은 mongosh 를 통한 연결을 참조하세요.

sample_mflix 데이터베이스 를 사용합니다.

mongosh 프롬프트에서 다음 명령을 실행합니다.

use sample_mflix

장르 및 연도 필드를 버킷으로 그룹화하는 Atlas Search 패싯 쿼리를 실행합니다.

다음 쿼리는 1921년 11월 11일 근처에 개봉된 영화를 검색합니다. 약 3개월의 origin 로부터의 pivot 기간을 지정합니다. genres, year 필드에 대한 메타데이터를 요청합니다. 쿼리는 다음을 카운트합니다.

• genres 문자열 배열 필드에 있는 각 장르의 영화 수입니다.

• 1910년부터 1939년까지의 영화 수(포함)

db.movies.aggregate([
  {
    "$searchMeta": {
      "index": "facet-tutorial",
      "facet": {
        "operator": {
          "near": {
            "path": "released",
            "origin": ISODate("1921-11-01T00:00:00.000+00:00"),
            "pivot": 7776000000
          }
        },
        "facets": {
          "genresFacet": {
            "type": "string",
            "path": "genres"
          },
          "yearFacet" : {
            "type" : "number",
            "path" : "year",
            "boundaries" : [1910,1920,1930,1940]
          }
        }
      }
    }
  }
])

{
  "count" : {
    "lowerBound" : NumberLong(23026)
  },
  "facet" : {
    "genresFacet" : {
      "buckets" : [
        { "_id" : "Drama", "count" : NumberLong(13527) },
        { "_id" : "Comedy", "count" : NumberLong(6922) },
        { "_id" : "Romance", "count" : NumberLong(3615) },
        { "_id" : "Crime", "count" : NumberLong(2649) },
        { "_id" : "Thriller", "count" : NumberLong(2603) },
        { "_id" : "Action", "count" : NumberLong(2505) },
        { "_id" : "Documentary", "count" : NumberLong(2041) },
        { "_id" : "Adventure", "count" : NumberLong(2016) },
        { "_id" : "Horror", "count" : NumberLong(1662) },
        { "_id" : "Biography", "count" : NumberLong(1373) }
      ]
    },
    "yearFacet" : {
      "buckets" : [
        { "_id" : 1910, "count" : NumberLong(23) },
        { "_id" : 1920, "count" : NumberLong(89) },
        { "_id" : 1930, "count" : NumberLong(308) }
      ]
    }
  }
}

MongoDB Compass에서 cluster에 연결합니다.

MongoDB Compass를 열고 cluster에 연결합니다. 연결에 대한 자세한 내용은 Compass를 통한 연결을 참조하세요.

movies 데이터베이스 의 컬렉션 sample_mflix 을 사용합니다.

Database 화면에서 sample_mflix 데이터베이스를 클릭한 다음 movies collection을 클릭합니다.

장르 및 연도 필드를 버킷으로 그룹화하는 Atlas Search 패싯 쿼리를 실행합니다.

쿼리는 다음과 같은 searchMeta 연산자 절을 사용합니다.

• 1921년 11월 11일부터 약 3개월 이내에 개봉한 영화를 검색하기 위해 origin 에서 pivot 기간 내의 영화를 찾는 근처를 검색합니다.

• facets 는 genres 문자열 배열 필드에서 각 장르별 영화 수와 1910년부터 1939년까지의 연도에 해당하는 영화 수를 요청함

MongoDB Compass에서 이 쿼리를 실행하려면 다음 안내를 따르세요.

1. Aggregations 탭을 클릭합니다.

2. Select...를 클릭한 다음 드롭다운에서 단계를 선택하고 해당 단계에 대한 쿼리를 추가하여 다음 파이프라인 단계를 각각 구성합니다. 단계를 추가하려면 Add Stage을 클릭합니다.

   파이프라인 단계	쿼리
   $searchMeta	{ index: 'facet-tutorial', facet: { operator: { near: { path: 'released', origin: ISODate("1921-11-01T00:00:00.000+00:00"), pivot: 7776000000 } }, facets: { genresFacet: { type: 'string', path: 'genres' }, yearFacet: { type: 'number', path: 'year', boundaries: [1910,1920,1930,1940] } } } }

Auto Preview를 활성화한 경우 MongoDB Compass는 $searchMeta 파이프라인 단계 옆에 다음 문서를 표시합니다.

{
   count: { lowerBound: 23026 },
   facet: {
     genresFacet: {
       buckets: [
         { _id: "Drama", count: 13527 },
         { _id: "Comedy", count: 6922 },
         { _id: "Romance", count: 3615 },
         { _id: "Crime", count: 2649 },
         { _id: "Thriller", count: 2603 },
         { _id: "Action", count: 2505 },
         { _id: "Documentary", count: 2041 },
         { _id: "Adventure", count: 2016 },
         { _id: "Horror", count: 1662 },
         { _id: "Biography", count: 1373 }
       ]
     },
     yearFacet: {
       buckets: [
         { _id: 1910, count: 23 },
         { _id: 1920, count: 89 },
         { _id: 1930, count: 308 }
       ]
     }
   }
 }

쿼리에 대한 .NET/C# 프로젝트를 설정하고 초기화합니다.

1. facet-query-example라는 새 디렉토리를 만들고 dotnet new 명령으로 프로젝트를 초기화합니다.

   mkdir facet-query-example
   cd facet-query-example
   dotnet new console

2. .NET/C# 드라이버를 프로젝트에 종속성으로 추가합니다.

   dotnet add package MongoDB.Driver

파일 에 쿼리 Program.cs 를 만듭니다.

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

   다음 쿼리는 1921년 11월 11일 근처에 개봉된 영화를 검색합니다. 약 3개월의 origin 로부터의 pivot 기간을 지정합니다. genres, year 필드에 대한 메타데이터를 요청합니다. 쿼리는 다음을 카운트합니다.

   • genres 문자열 배열 필드에 있는 각 장르의 영화 수입니다.

   • 1910년부터 1939년까지의 영화 수(포함)

   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 FacetExample
   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
           // declare data for date and number fields
   23
           var originDate = new DateTime(1921, 11, 01, 0, 0, 0, DateTimeKind.Utc);
   24
   25
           // define and run pipeline
   26
           var results = moviesCollection.Aggregate()
   27
               .SearchMeta(Builders<MovieDocument>.Search.Facet(
   28
                       Builders<MovieDocument>.Search.Near(movie => movie.Released, originDate, 7776000000),
   29
                       Builders<MovieDocument>.SearchFacet.String("genresFacet", movie => movie.Genres, 10),
   30
                       Builders<MovieDocument>.SearchFacet.Number("yearFacet", movie => movie.Year, 1910, 1920, 1930, 1940)),
   31
                       indexName: "facet-tutorial")
   32
               .Single();
   33
   34
           // print results
   35
           Console.WriteLine(results.ToJson());
   36
       }
   37
   }
   38
   39
   [BsonIgnoreExtraElements]
   40
   public class MovieDocument
   41
   {
   42
       [BsonIgnoreIfDefault]
   43
       public ObjectId Id { get; set; }
   44
       public string [] Genres { get; set; }
   45
       public DateTime Released { get; set; }
   46
       public int Year { get; set; }
   47
   }

2. 샘플을 실행하기 전에 <connection-string>을 Atlas 연결 문자열로 바꿉니다. 연결 문자열에는 데이터베이스 사용자의 자격 증명이 포함되어 있어야 합니다. 자세한 내용은 드라이버를 통한 연결을 참조하세요.

파일 을 컴파일하고 Program.cs 실행 합니다.

dotnet run facet-query-example.csproj

{
  "count" : { "lowerBound" : NumberLong(23026), "total" : null },
  "facet" : {
    "genresFacet" : {
      "buckets" : [
        { "_id" : "Drama", "count" : NumberLong(13527) },
        { "_id" : "Comedy", "count" : NumberLong(6922) },
        { "_id" : "Romance", "count" : NumberLong(3615) },
        { "_id" : "Crime", "count" : NumberLong(2649) },
        { "_id" : "Thriller", "count" : NumberLong(2603) },
        { "_id" : "Action", "count" :  NumberLong(2505) },
        { "_id" : "Documentary", "count" : NumberLong(2041) },
        { "_id" : "Adventure", "count" : NumberLong(2016) },
        { "_id" : "Horror", "count" : NumberLong(1662) },
        { "_id" : "Biography", "count" : NumberLong(1373) }
      ]
    },
    "yearFacet" : {
      "buckets" : [
        { "_id" : 1910, "count" : NumberLong(23) },
        { "_id" : 1920, "count" : NumberLong(89) },
        { "_id" : 1930, "count" : NumberLong(308) }
      ]
    }
  }
}

장르 및 연도 필드를 버킷으로 그룹화하는 Atlas Search 패싯 쿼리를 실행합니다.

1. facet-query.go이라는 파일을 만듭니다.

2. 다음 코드를 복사하여 facet-query.go 파일에 붙여넣습니다.

   이 코드 예시에서는 다음 작업을 수행합니다:

   • mongodb 패키지 및 종속성을 가져옵니다.

   • Atlas 클러스터에 대한 연결을 설정합니다.

   • 다음 searchMeta 절을 사용하여 collection을 쿼리합니다:

     • 1921년 11월 11일부터 약 3개월 이내에 개봉한 영화를 검색하기 위해 origin 에서 pivot 기간 내의 영화를 찾는 근처를 검색합니다.

     • facets 는 genres 문자열 배열 필드에서 각 장르별 영화 수와 1910년부터 1939년까지의 연도에 해당하는 영화 수를 요청함

   • 커서 위를 반복하여 쿼리와 일치하는 문서를 인쇄합니다.

   1
   package main
   2
   3
   import (
   4
   	"context"
   5
   	"fmt"
   6
   	"time"
   7
   8
   	"go.mongodb.org/mongo-driver/bson"
   9
   	"go.mongodb.org/mongo-driver/mongo"
   10
   	"go.mongodb.org/mongo-driver/mongo/options"
   11
   )
   12
   13
   func main() {
   14
   	// connect to your Atlas cluster
   15
   	client, err := mongo.Connect(context.TODO(), 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{{"$searchMeta", bson.M{
   26
   		"index": "facet-tutorial",
   27
   		"facet": bson.M{
   28
   			"operator": bson.M{
   29
   				"near": bson.M{
   30
   					"path":   "released",
   31
   					"origin": time.Date(1921, time.November, 1, 0, 0, 0, 0, time.UTC),
   32
   					"pivot":  7776000000},
   33
   			},
   34
   			"facets": bson.M{
   35
   				"genresFacet": bson.M{
   36
   					"path": "genres",
   37
   					"type": "string"},
   38
   				"yearFacet": bson.M{
   39
   					"path":       "year",
   40
   					"type":       "number",
   41
   					"boundaries": bson.A{1910, 1920, 1930, 1940}},
   42
   			}}}}}
   43
   	// run pipeline
   44
   	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage})
   45
   	if err != nil {
   46
   		panic(err)
   47
   	}
   48
   49
   	// print results
   50
   	var results []bson.D
   51
   	if err = cursor.All(context.TODO(), &results); err != nil {
   52
   		panic(err)
   53
   	}
   54
   	for _, result := range results {
   55
   		fmt.Println(result)
   56
   	}
   57
   }

3. 샘플을 실행하기 전에 <connection-string>을 Atlas 연결 문자열로 바꿉니다. 연결 문자열에는 데이터베이스 사용자의 자격 증명이 포함되어 있어야 합니다. 자세한 내용은 드라이버를 통한 연결을 참조하세요.

4. 다음 명령을 실행하여 컬렉션을 쿼리합니다.

   go run facet-query.go

   출력 숨기기

   [{count [{lowerBound 23026}]}
    {facet [
      {genresFacet [
        {buckets [
         [{_id Drama} {count 13527}]
         [{_id Comedy} {count 6922}]
         [{_id Romance} {count 3615}]
         [{_id Crime} {count 2649}]
         [{_id Thriller} {count 2603}]
         [{_id Action} {count 2505}]
         [{_id Documentary} {count 2041}]
         [{_id Adventure} {count 2016}]
         [{_id Horror} {count 1662}]
         [{_id Biography} {count 1373}]]}]}
     {yearFacet [
       {buckets [
         [{_id 1910} {count 23}]
         [{_id 1920} {count 89}]
         [{_id 1930} {count 308}]]}]}]}]

CLASSPATH 에 다음 라이브러리가 포함되어 있는지 확인합니다.

장르 및 연도 필드를 버킷으로 그룹화하는 Atlas Search 패싯 쿼리를 실행합니다.

1. FacetQuery.java이라는 파일을 만듭니다.

2. 다음 코드를 복사하여 FacetQuery.java 파일에 붙여넣습니다.

   이 코드 예시에서는 다음 작업을 수행합니다:

   • mongodb 패키지 및 종속성을 가져옵니다.

   • Atlas 클러스터에 대한 연결을 설정합니다.

   • 다음 searchMeta 절을 사용하여 collection을 쿼리합니다:

     • 1921년 11월 11일부터 약 3개월 이내에 개봉한 영화를 검색하기 위해 origin 에서 pivot 기간 내의 영화를 찾는 근처를 검색합니다.

     • facets 는 genres 문자열 배열 필드에서 각 장르별 영화 수와 1910년부터 1939년까지의 연도에 해당하는 영화 수를 요청함

   • 커서 위를 반복하여 쿼리와 일치하는 문서를 인쇄합니다.

   1
   import com.mongodb.client.MongoClient;
   2
   import com.mongodb.client.MongoClients;
   3
   import com.mongodb.client.MongoCollection;
   4
   import com.mongodb.client.MongoDatabase;
   5
   import org.bson.Document;
   6
   7
   import java.time.Instant;
   8
   import java.util.Arrays;
   9
   import java.util.Date;
   10
   11
   public class FacetQuery {
   12
       public static void main(String[] args) {
   13
           // connect to your Atlas cluster
   14
           String uri = "<connection-string>";
   15
   16
           try (MongoClient mongoClient = MongoClients.create(uri)) {
   17
               // set namespace
   18
               MongoDatabase database = mongoClient.getDatabase("sample_mflix");
   19
               MongoCollection<Document> collection = database.getCollection("movies");
   20
               
   21
               // define pipeline
   22
               Document agg = new Document("$searchMeta", 
   23
                   new Document( "index", "facet-tutorial")
   24
                   .append("facet", 
   25
                       new Document("operator", 
   26
                           new Document("near", 
   27
                               new Document("path", "released")
   28
                               .append("origin", Date.from(Instant.parse("1921-11-01T00:00:00.000+00:00")))
   29
                               .append("pivot", 7776000000L)))
   30
                   .append("facets", 
   31
                       new Document("genresFacet", 
   32
                           new Document("type", "string").append("path", "genres"))
   33
                       .append("yearFacet",
   34
                           new Document("type", "number").append("path", "year")
   35
                           .append("boundaries", Arrays.asList(1910, 1920, 1930, 1940))
   36
                ))));
   37
               // run pipeline and print results
   38
               collection.aggregate(Arrays.asList(agg))
   39
                   .forEach(doc -> System.out.println(doc.toJson()));
   40
   41
           }
   42
       }
   43
   }

   참고

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

   package com.mongodb.drivers;

3. 샘플을 실행하기 전에 <connection-string>을 Atlas 연결 문자열로 바꿉니다. 연결 문자열에는 데이터베이스 사용자의 자격 증명이 포함되어 있어야 합니다. 자세한 내용은 드라이버를 통한 연결을 참조하세요.

4. FacetQuery.java 파일을 컴파일하고 실행합니다.

   javac FacetQuery.java
   java FacetQuery

   출력 숨기기

   {"count": {"lowerBound": 23026},
    "facet": {
      "genresFacet": {
        "buckets": [
          {"_id": "Drama", "count": 13527},
          {"_id": "Comedy", "count": 6922},
          {"_id": "Romance", "count": 3615},
          {"_id": "Crime", "count": 2649},
          {"_id": "Thriller", "count": 2603},
          {"_id": "Action", "count": 2505},
          {"_id": "Documentary", "count": 2041},
          {"_id": "Adventure", "count": 2016},
          {"_id": "Horror", "count": 1662},
          {"_id": "Biography", "count": 1373}]},
      "yearFacet": {
        "buckets": [
          {"_id": 1910, "count": 23},
          {"_id": 1920, "count": 89},
          {"_id": 1930, "count": 308}]}}}

프로젝트에 다음 종속성을 추가했는지 확인합니다.

장르 및 연도 필드를 버킷으로 그룹화하는 Atlas Search 패싯 쿼리를 실행합니다.

1. FacetQuery.kt이라는 파일을 만듭니다.

2. 다음 코드를 복사하여 FacetQuery.kt 파일에 붙여넣습니다.

   이 코드 예시에서는 다음 작업을 수행합니다:

   • mongodb 패키지 및 종속성을 가져옵니다.

   • Atlas 클러스터에 대한 연결을 설정합니다.

   • 다음 searchMeta 절을 사용하여 컬렉션을 쿼리합니다.

     • 1921년 11월 11일부터 약 3개월 이내에 개봉한 영화를 검색하기 위해 origin 에서 pivot 기간 내의 영화를 찾는 근처를 검색합니다.

     • facets 는 genres 문자열 배열 필드에서 각 장르별 영화 수와 1910년부터 1939년까지의 연도에 해당하는 영화 수를 요청함

   • AggregateFlow 인스턴스에서 쿼리와 일치하는 문서를 인쇄합니다.

   1
   import com.mongodb.kotlin.client.coroutine.MongoClient
   2
   import kotlinx.coroutines.runBlocking
   3
   import org.bson.Document
   4
   import java.time.Instant
   5
   import java.util.*
   6
   7
   fun main() {
   8
       // connect to your Atlas cluster
   9
       val uri = "<connection-string>"
   10
       val mongoClient = MongoClient.create(uri)
   11
       
   12
       // set namespace
   13
       val database = mongoClient.getDatabase("sample_mflix")
   14
       val collection = database.getCollection<Document>("movies")
   15
   16
       runBlocking {
   17
           // define pipeline
   18
           val agg = Document(
   19
               "\$searchMeta",
   20
               Document("index", "facet-tutorial")
   21
                   .append(
   22
                       "facet",
   23
                       Document(
   24
                           "operator",
   25
                           Document(
   26
                               "near",
   27
                               Document("path", "released")
   28
                                   .append("origin", Date.from(Instant.parse("1921-11-01T00:00:00.000+00:00")))
   29
                                   .append("pivot", 7776000000L)
   30
                           )
   31
                       )
   32
                           .append(
   33
                               "facets",
   34
                               Document(
   35
                                   "genresFacet",
   36
                                   Document("type", "string").append("path", "genres")
   37
                               )
   38
                                   .append(
   39
                                       "yearFacet",
   40
                                       Document("type", "number").append("path", "year")
   41
                                           .append("boundaries", listOf(1910, 1920, 1930, 1940))
   42
                                   )
   43
                           )
   44
                   )
   45
           )
   46
   47
           // run pipeline and print results
   48
           val resultsFlow = collection.aggregate<Document>(
   49
               listOf(agg)
   50
           )
   51
           resultsFlow.collect { println(it) }
   52
       }
   53
       mongoClient.close()
   54
   }

3. 샘플을 실행하기 전에 <connection-string>을 Atlas 연결 문자열로 바꿉니다. 연결 문자열에는 데이터베이스 사용자의 자격 증명이 포함되어 있어야 합니다. 자세한 내용은 드라이버를 통한 연결을 참조하세요.

4. FacetQuery.kt 파일을 실행합니다.

   IDE에서 FacetQuery.kt 프로그램을 실행하면 다음과 같은 결과가 출력됩니다.

   Document{{count=Document{{lowerBound=20878}},
   facet=Document{{genresFacet=Document{{buckets=[Document{{_id=Drama,
   count=12149}}, Document{{_id=Comedy, count=6436}},
   Document{{_id=Romance, count=3274}}, Document{{_id=Crime,
   count=2429}}, Document{{_id=Thriller, count=2400}},
   Document{{_id=Action, count=2349}}, Document{{_id=Adventure,
   count=1876}}, Document{{_id=Documentary, count=1755}},
   Document{{_id=Horror, count=1432}}, Document{{_id=Biography,
   count=1244}}]}},
   yearFacet=Document{{buckets=[Document{{_id=1910, count=14}},
   Document{{_id=1920, count=47}}, Document{{_id=1930,
   count=238}}]}}}}}}

장르 및 연도 필드를 버킷으로 그룹화하는 Atlas Search 패싯 쿼리를 실행합니다.

1. facet-query.js이라는 파일을 만듭니다.

2. 다음 코드를 복사하여 facet-query.js 파일에 붙여넣습니다.

   이 코드 예시에서는 다음 작업을 수행합니다:

   • MongoDB의 Node.js 드라이버인 mongodb를 가져옵니다.

   • MongoClient 클래스의 인스턴스를 만들어 Atlas 클러스터에 대한 연결을 설정합니다.

   • 다음 searchMeta 절을 사용하여 collection을 쿼리합니다:

     • 1921년 11월 11일부터 약 3개월 이내에 개봉한 영화를 검색하기 위해 origin 에서 pivot 기간 내의 영화를 찾는 근처를 검색합니다.

     • facets 는 genres 문자열 배열 필드에서 각 장르별 영화 수와 1910년부터 1939년까지의 연도에 해당하는 영화 수를 요청함

   • 커서 위를 반복하여 쿼리와 일치하는 문서를 인쇄합니다.

   1
   const { MongoClient } = require("mongodb");
   2
   3
   // connect to your Atlas cluster
   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 = [{$searchMeta: {
   19
             index: "facet-tutorial",
   20
             facet: {
   21
                   operator: {
   22
                     near: {path: "released", origin: new Date("1921-11-01T00:00:00.000Z"), pivot: 7776000000}
   23
                   },
   24
                   facets: {
   25
                     genresFacet: {type: "string", path: "genres"},
   26
                     yearFacet: {type: "number", path: "year",boundaries: [1910,1920,1930,1940]}
   27
                   }}}}];
   28
           // run pipeline
   29
           const result = coll.aggregate(agg);
   30
   31
           // print results
   32
           await result.forEach((doc) => console.dir(JSON.stringify(doc)));
   33
       } finally {
   34
           await client.close();
   35
       }
   36
   }
   37
   run().catch(console.dir);

3. 샘플을 실행하기 전에 <connection-string>을 Atlas 연결 문자열로 바꿉니다. 연결 문자열에는 데이터베이스 사용자의 자격 증명이 포함되어 있어야 합니다. 자세한 내용은 드라이버를 통한 연결을 참조하세요.

4. 다음 명령을 실행하여 컬렉션을 쿼리합니다.

   node facet-query.js

   출력 숨기기

   '{"count":{"lowerBound":23026},
     "facet":{
       "genresFacet":{
         "buckets":[
           {"_id":"Drama","count":13527},
           {"_id":"Comedy","count":6922},
           {"_id":"Romance","count":3615},
           {"_id":"Crime","count":2649},
           {"_id":"Thriller","count":2603},
           {"_id":"Action","count":2505},
           {"_id":"Documentary","count":2041},
           {"_id":"Adventure","count":2016},
           {"_id":"Horror","count":1662},
           {"_id":"Biography","count":1373}]},
       "yearFacet":{
         "buckets":[
           {"_id":1910,"count":23},
           {"_id":1920,"count":89},
           {"_id":1930,"count":308}]}}}'

장르 및 연도 필드를 버킷으로 그룹화하는 Atlas Search 패싯 쿼리를 실행합니다.

1. facet-query.py이라는 파일을 만듭니다.

2. 다음 코드를 복사하여 facet.py 파일에 붙여넣습니다.

   다음 코드 예제에서는:

   • pymongo, MongoDB의 Python 드라이버 및 dns 모듈을 가져옵니다. 이 모듈은 DNS 시드 리스트 연결 문자열을 사용하여 pymongo를 Atlas에 연결하는 데 필요합니다.

   • MongoClient 클래스의 인스턴스를 만들어 Atlas 클러스터에 대한 연결을 설정합니다.

   • 다음 searchMeta 절을 사용하여 collection을 쿼리합니다:

     • 1921년 11월 11일부터 약 3개월 이내에 개봉한 영화를 검색하기 위해 origin 에서 pivot 기간 내의 영화를 찾는 근처를 검색합니다.

     • facets 는 genres 문자열 배열 필드에서 각 장르별 영화 수와 1910년부터 1939년까지의 연도에 해당하는 영화 수를 요청함

   • 커서 위를 반복하여 쿼리와 일치하는 문서를 인쇄합니다.

   1
   import pymongo
   2
   import datetime
   3
   4
   # connect to your Atlas cluster
   5
   client = pymongo.MongoClient('<connection-string>')
   6
   7
   # define pipeline
   8
   pipeline = [{"$searchMeta": { 
   9
       "index": "facet-tutorial",
   10
       "facet": {
   11
           "operator": {
   12
             "near": {"path": "released", "origin": datetime.datetime(1921, 11, 1, 0, 0, 0, 0), "pivot": 7776000000}
   13
           },
   14
           "facets": {
   15
             "genresFacet": {"type": "string", "path": "genres"},
   16
             "yearFacet" : {"type" : "number", "path" : "year", "boundaries" : [1910,1920,1930,1940]}
   17
           }}}}]
   18
   # run pipeline
   19
   result = client["sample_mflix"]["movies"].aggregate(pipeline)
   20
   21
   # print results
   22
   for i in result:
   23
       print(i)

3. 샘플을 실행하기 전에 <connection-string>을 Atlas 연결 문자열로 바꿉니다. 연결 문자열에는 데이터베이스 사용자의 자격 증명이 포함되어 있어야 합니다. 자세한 내용은 드라이버를 통한 연결을 참조하세요.

4. 다음 명령을 실행하여 컬렉션을 쿼리합니다.

   python facet-query.py

   출력 숨기기

   {'count': {'lowerBound': 23026},
    'facet': {
      'genresFacet': {
        'buckets': [
          {'count': 13527, '_id': 'Drama'},
          {'count': 6922, '_id': 'Comedy'},
          {'count': 3615, '_id': 'Romance'},
          {'count': 2649, '_id': 'Crime'},
          {'count': 2603, '_id': 'Thriller'},
          {'count': 2505, '_id': 'Action'},
          {'count': 2041, '_id': 'Documentary'},
          {'count': 2016, '_id': 'Adventure'},
          {'count': 1662, '_id': 'Horror'},
          {'count': 1373, '_id': 'Biography'}]},
      'yearFacet': {
        'buckets': [
          {'count': 23, '_id': 1910},
          {'count': 89, '_id': 1920},
          {'count': 308, '_id': 1930}]}}}