/ /

쿼리 참조

운영자 & 수집가

Docs Home

개발

`facet` (MongoDB Search 연산자)

정의

facet

facet 수집기는 지정된 패싯 필드의 값 또는 범위별로 결과를 그룹화하고 해당 그룹 각각의 개수를 반환합니다.

You can use facet with both the $search and $searchMeta stages. MongoDB recommends using facet with the $searchMeta stage to retrieve metadata results only for the query. To retrieve metadata results and query results using the $search stage, you must use the $$SEARCH_META aggregation variable. See SEARCH_META Aggregation Variable to learn more.

storedSource를 embeddedDocuments 필드 유형 정의에 정의하면, returnScope와 returnStoredSource를 사용하여 객체 배열 내부의 중첩 필드를 패싯으로 지정할 수 있습니다. 그렇지 않으면 루트 embeddedDocuments 유형 필드에서만 패싯할 수 있습니다. 패싯의 예시는 다음과 같습니다.

Nested fields inside an array of objects, see returnScope Example.
Matching children of an embeddedDocuments array using embeddedDocument, see Embedded-Scoped Facet Example.
루트 embeddedDocuments 유형 필드, 패싯 쿼리를 참조하세요.

구문

facet 의 구문은 다음과 같습니다:

{
  "$searchMeta"|"$search": {
    "index": <index name>, // optional, defaults to "default"
    "facet": {
      "operator": {
        <operator-specifications>
      },
      "facets": {
        <facet-definitions>
      }
    },
    "returnScope": {
      "path": "<embedded-documents-field-to-query>"
    },
    "returnStoredSource": true
  }
}

필드

필드	유형	필수 사항입니다.	설명
`facets`	문서	네	Information for bucketing the data for each facet. You must specify at least one Facet Definition. Each facet definition can also specify Facet Aggregations to compute metrics for each bucket.
`operator`	문서	no	패싯 을 수행하는 데 사용하는 연산자입니다. 생략하면 MongoDB Search는 컬렉션 의 모든 문서에 대해 패싯 을 수행합니다.

메모리 요구 사항

Facet queries are memory-intensive, regardless of your cluster tier. Queries that specify Facet Aggregations or nested facets require more memory and disk than other facet queries. Before you use facets in production, confirm that your cluster has enough memory for your workload. To learn more, see Search Memory Management. To get sizing guidance for your workload, request support.

패싯 쿼리에 필요한 메모리는 패싯할 필드의 고유 값 수에 따라 달라지며, numBuckets 또는 boundaries을(를) 사용하여 요청하는 버킷 수에 따라 달라지지 않습니다. 예시를 들어, 500만개의 고유값을 가진 필드에서 20 개의 버켓을 요청하는 패싿은 여전히 모든 고유값을 계산하여 상위 20 개의 버켓을 결정합니다.

For nested facets, the total unique values computed in a query multiply based on the unique values across each level of nesting. Even when each individual field has low cardinality, the combination of values across nested paths can produce a large number of unique buckets. To learn more about how nested facets multiply buckets, see Nested Facets.

MongoDB Search는 각 쿼리에 대해 버킷 수를 별도로 추적하므로 총 메모리 사용량은 동시 패싯 쿼리 수에 따라 확장됩니다. 샤딩된 클러스터에서 MongoDB Search는 각 샤드의 버킷을 병합하기 위해 메모리도 필요로 하며, 이는 샤드 수와 버킷 수에 따라 확장됩니다.

패싯 정의

패싯 정의 문서 에는 패싯 이름과 패싯 유형별 옵션이 포함되어 있습니다. MongoDB Search는 다음 유형의 패싯을 지원합니다.

문자열 패싯
숫자 패싯
날짜 패싯

문자열 패싯

중요

stringFacet 은 이제 구식입니다. 대신 향상된 패싯을 제공하는 토큰을 사용합니다.

패싯에 대해 업데이트된 필드 유형과 오래된 필드 유형 간의 차이점에 대해 자세히 알아보려면 패싯의 필드 유형 비교를 참조하세요.

string 패싯을 사용하면 지정된 string 필드에서 가장 빈번한 string 값을 기준으로 MongoDB Search 결과의 범위를 좁힐 수 있습니다. string 필드는 토큰으로 인덱스되어야 합니다. 내장된 문서의 string 필드에 패싯을 수행하려면 상위 필드도 문서 유형으로 인덱싱해야 합니다. 배열 또는 내장된 문서의 문자열에 패싯을 적용할 때 MongoDB Search는 일치하는 루트 문서 수를 기반으로 패싯 개수를 반환합니다.

구문

문자열 패싯의 구문은 다음과 같습니다:

{
  "$searchMeta": {
    "facet":{
      "operator": {
        <operator-specification>
      },
      "facets": {
        "<facet-name>" : {
          "type" : "string",
          "path" : "<field-path>",
          "numBuckets" : <number-of-categories>,
          "embeddedDocument": { <embedded-document-scope> } // optional
        }
      }
    }
  }
}

옵션

옵션	유형	설명	필수 사항입니다.
`embeddedDocument`	객체	Scopes the facet's bucket counts to only the child documents of an `embeddedDocuments` array that match a query predicate. To learn more, see Facet on Matching Children of an Embedded Documents Array.	no
`numBuckets`	int	결과에 반환할 패싯 카테고리의 최대 개수입니다. 값은 `10000`보다 작거나 같아야 합니다. 지정한 경우, 데이터가 요청된 수보다 적은 카테고리로 그룹화되다면 MongoDB Search는 요청된 것보다 적은 카테고리를 반환할 수 있습니다. 생략하면 기본값은 `10` 으로, MongoDB Search는 개수 기준으로 상위 `10` 패싯 범주만 반환합니다.	no
`path`	문자열	패싯을 설정할 필드 경로입니다. 토큰으로 인덱싱되는 필드를 지정할 수 있습니다.	네
`type`	문자열	패싯의 유형입니다. 값은 `string`이어야 합니다.	네

예시

다음 예시는 sample_mflix.movies 컬렉션의 default라는 인덱스를 사용합니다. 컬렉션의 genres 필드는 토큰 유형으로 인덱싱되고 year 필드는 숫자 유형으로 인덱싱됩니다.

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "genres": {
        "type": "token"
      },
      "year": {
        "type": "number"
      }
    }
  }
}

이 쿼리는 $searchMeta 단계를 사용하여 movies 컬렉션의 year 필드에서 2000년부터 2015년까지의 영화를 검색하고 각 장르의 영화 수 개수를 검색합니다.

1 db.movies.aggregate([
2   {
3     "$searchMeta": {
4       "facet": {
5         "operator": {
6           "range": {
7             "path": "year",
8             "gte": 2000,
9             "lte": 2015
10           }
11         },
12         "facets": {
13           "genresFacet": {
14             "type": "string",
15             "path": "genres"
16           }
17         }
18       }
19     }
20   }
21 ])

1 [
2   {
3     count: { lowerBound: Long('12568') },
4     facet: {
5       genresFacet: {
6         buckets: [
7           { _id: 'Drama', count: Long('7079') },
8           { _id: 'Comedy', count: Long('3689') },
9           { _id: 'Romance', count: Long('1764') },
10           { _id: 'Thriller', count: Long('1584') },
11           { _id: 'Documentary', count: Long('1472') },
12           { _id: 'Action', count: Long('1471') },
13           { _id: 'Crime', count: Long('1367') },
14           { _id: 'Adventure', count: Long('1056') },
15           { _id: 'Horror', count: Long('866') },
16           { _id: 'Biography', count: Long('796') }
17         ]
18       }
19     }
20   }
21 ]

이러한 결과에 대해 자세히 알아보려면 패싯 결과를 참조하세요.

숫자 패싯

중요

numberFacet 은 이제 구식입니다. 대신 숫자 를 사용하면 향상된 패싯을 제공합니다.

패싯에 대해 업데이트된 필드 유형과 오래된 필드 유형 간의 차이점에 대해 자세히 알아보려면 패싯의 필드 유형 비교를 참조하세요.

숫자 패싯을 사용하면 결과를 별도의 숫자 범위로 나누어 검색 결과에서 숫자 값의 빈도를 결정할 수 있습니다. 배열이나 내장된 문서의 숫자를 패싯 경우 MongoDB Search는 일치하는 루트 문서 수를 기준으로 패싯 수를 반환합니다.

구문

숫자 패싯의 구문은 다음과 같습니다:

{
  "$searchMeta": {
    "facet":{
      "operator": {
        <operator-specification>
      },
      "facets": {
        "<facet-name>" : {
          "type" : "number",
          "path" : "<field-path>",
          "boundaries" : <array-of-numbers>,
          "default": "<bucket-name>",
          "embeddedDocument": { <embedded-document-scope> } // optional
        }
      }
    }
  }
}

옵션

옵션	유형	설명	필수 사항입니다.
`boundaries`	숫자 배열	List of numeric values in ascending order that specify the boundaries for your buckets. You must specify between two and ten thousand (`[2, 10000]`) boundary values. Each adjacent pair of values defines a bucket with an inclusive lower bound and an exclusive upper bound. You can specify any combination of values of the following BSON types: 32비트 정수 (`int32`) 64비트 정수 (`int64`) 64비트 이진 부동 소수점(`double`)	네
`default`	문자열	지정된 경계에 속하지 않는 연산자 로부터 반환된 문서를 계산하는 추가 버킷의 이름입니다. 생략하면 MongoDB Search는 지정된 버킷에 속하지 않는 패싯 연산자 의 결과도 포함하지만 버킷 수에는 포함하지 않습니다.	no
`embeddedDocument`	객체	Scopes the facet's bucket counts to only the child documents of an `embeddedDocuments` array that match a query predicate. To learn more, see Facet on Matching Children of an Embedded Documents Array.	no
`path`	문자열	패싯을 설정할 필드 경로입니다. number 유형으로 인덱싱되는 필드를 지정할 수 있습니다.	네
`type`	문자열	패싯의 유형입니다. 값은 `number`이어야 합니다.	네

예시

다음 예시는 sample_mflix.movies 컬렉션의 default라는 인덱스를 사용합니다. 컬렉션의 year 필드는 number 유형으로 인덱싱됩니다.

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "year": [
        {
          "type": "number"
        }
      ]
    }
  }
}

이 쿼리는 $searchMeta 단계를 사용하여 movies 컬렉션의 year 필드에서 1980 년부터 2000 년 사이의 영화를 검색하고 쿼리에 대한 메타데이터 결과를 조회합니다. 쿼리는 3개의 버킷을 지정합니다.

1980이 버킷에 대한 포괄적인 하한값
19901980 버킷에 대한 배타적 상한과 이 버킷에 대한 포괄적 하한입니다.
20001990 버킷에 대한 배타적 상한

이 쿼리는 또한 지정된 경계에 속하지 않는 쿼리 결과를 검색하기 위해 other이라는 이름의 default 버킷을 지정합니다.

1 db.movies.aggregate([
2   {
3     "$searchMeta": {
4       "facet": {
5         "operator": {
6          "range": {
7             "path": "year",
8             "gte": 1980,
9             "lte": 2000
10           }
11         },
12         "facets": {
13           "yearFacet": {
14             "type": "number",
15             "path": "year",
16             "boundaries": [1980,1990,2000],
17             "default": "other"
18           }
19         }
20       }
21     }
22   }
23 ])

1 [
2   {
3     count: { lowerBound: Long('6095') },
4     facet: {
5       yearFacet: {
6         buckets: [
7           { _id: 1980, count: Long('1956') },
8           { _id: 1990, count: Long('3558') },
9           { _id: 'other', count: Long('581') }
10         ]
11       }
12     }
13   }
14 ]

이러한 결과에 대해 자세히 알아보려면 패싯 결과를 참조하세요.

날짜 패싯

중요

dateFacet 은 이제 구식입니다. 대신 날짜를 사용하여 향상된 패싯을 제공합니다.

패싯에 대해 업데이트된 필드 유형과 오래된 필드 유형 간의 차이점에 대해 자세히 알아보려면 패싯의 필드 유형 비교를 참조하세요.

날짜 패싯을 사용하면 날짜를 기준으로 검색 결과의 범위를 좁힐 수 있습니다. 배열이나 내장된 문서의 날짜를 패싯 경우 MongoDB Search는 일치하는 루트 문서 수를 기준으로 패싯 수를 반환합니다.

구문

날짜 패싯의 구문은 다음과 같습니다:

{
  "$searchMeta": {
    "facet":{
      "operator": {
        <operator-specification>
      },
      "facets": {
        "<facet-name>" : {
          "type" : "date",
          "path" : "<field-path>",
          "boundaries" : <array-of-dates>,
          "default": "<bucket-name>",
          "embeddedDocument": { <embedded-document-scope> } // optional
        }
      }
    }
  }
}

옵션

옵션	유형	설명	필수 사항입니다.
`boundaries`	숫자 배열	각 버킷의 경계를 지정하는 날짜 값 목록입니다. 다음을 지정해야 합니다: 만 이하인 경계 두 개 이상(`[2, 10000]`) 값이 오름차순으로 표시되며 가장 빠른 날짜가 먼저 표시됩니다. 각 인접한 값 쌍은 버킷의 포괄적인 하한과 배타적인 상한으로 작용합니다.	네
`default`	문자열	지정된 경계에 속하지 않는 연산자 로부터 반환된 문서를 계산하는 추가 버킷의 이름입니다. 생략하면 MongoDB Search는 지정된 버킷에 속하지 않는 패싯 연산자 의 결과도 포함하지만, MongoDB 수에는 이러한 결과가 포함되지 않습니다.	no
`embeddedDocument`	객체	Scopes the facet's bucket counts to only the child documents of an `embeddedDocuments` array that match a query predicate. To learn more, see Facet on Matching Children of an Embedded Documents Array.	no
`path`	문자열	패싯을 설정할 필드 경로입니다. date 유형으로 인덱싱된 필드를 지정할 수 있습니다.	네
`type`	문자열	패싯의 유형입니다. 값은 `date`이어야 합니다.	네

예시

다음 예시는 sample_mflix.movies 컬렉션의 default라는 인덱스를 사용합니다. 컬렉션의 released 필드는 date 유형으로 인덱싱됩니다.

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "released": [
        {
          "type": "date"
        }
      ]
    }
  }
}

이 쿼리는 $searchMeta 단계를 사용하여 movies 컬렉션의 released 필드에서 2000 년부터 2015 년 사이의 영화를 검색하고 쿼리에 대한 메타데이터 결과를 조회합니다. 쿼리는 4개의 버킷을 지정합니다:

2000-01-01이 버킷에 대한 포괄적인 하한값
2005-01-012000-01-01 버킷에 대한 배타적 상한과 이 버킷에 대한 포괄적 하한입니다.
2010-01-012005-01-01 버킷에 대한 배타적 상한과 이 버킷에 대한 포괄적 하한입니다.
2015-01-012010-01-01 버킷에 대한 배타적 상한

이 쿼리는 또한 지정된 경계에 속하지 않는 쿼리 결과를 검색하기 위해 other이라는 이름의 default 버킷을 지정합니다.

1 db.movies.aggregate([
2   {
3     "$searchMeta": {
4       "facet": {
5         "operator": {
6           "range": {
7             "path": "released",
8             "gte": ISODate("2000-01-01T00:00:00.000Z"),
9             "lte": ISODate("2015-01-31T00:00:00.000Z")
10           }
11         },
12         "facets": {
13           "yearFacet": {
14             "type": "date",
15             "path": "released",
16             "boundaries": [ISODate("2000-01-01"), ISODate("2005-01-01"), ISODate("2010-01-01"), ISODate("2015-01-01")],
17             "default": "other"
18           }
19         }
20       }
21     }
22   }
23 ])

1 [
2   {
3     count: { lowerBound: Long('11922') },
4     facet: {
5       yearFacet: {
6         buckets: [
7           {
8             _id: ISODate('2000-01-01T00:00:00.000Z'),
9             count: Long('3028')
10           },
11           {
12             _id: ISODate('2005-01-01T00:00:00.000Z'),
13             count: Long('3953')
14           },
15           {
16             _id: ISODate('2010-01-01T00:00:00.000Z'),
17             count: Long('4832')
18           },
19           { _id: 'other', count: Long('109') }
20         ]
21       }
22     }
23   }
24 ]

이러한 결과에 대해 자세히 알아보려면 패싯 결과를 참조하세요.

패싯의 필드 유형 비교

업데이트된 MongoDB 검색 필드 유형은 오래된 유형(stringFacet, numberFacet, dateFacet)에 비해 패싯을 지원하도록 개선된 기능을 제공합니다. 다음 표에는 기능의 주요 차이점이 간략하게 설명되어 있습니다.

패싯 범주	업데이트된 필드 유형	오래된 패싯 유형	주요 차이점
문자열	token	stringFacet (오래됨)	Normalizer Support: The `token` type supports normalizers that transform facet buckets. For example, with `normalizer: lowercase`, "ADIDAS" and "adidas" count toward the same bucket while `stringFacet` treats them as separate buckets.
숫자	숫자	numberFacet (오래됨)	Array Support: The `number` type considers values within arrays for facet buckets. For example, a document with an array value `[0, 10]` counts toward both buckets `[1, 5]` and `[6, 10]` while `numberFacet` ignores array values completely.
날짜	날짜	dateFacet (오래됨)	배열 지원: `date` 유형은 패싯 버킷에 대한 배열 내의 값을 고려합니다. 예시 를 들어 `dateFacet` 는 배열 값을 완전히 무시하는 반면 날짜가 포함된 배열 값은 여러 날짜 범위 버킷에 포함될 수 있습니다.

참고

오래된 필드 유형과 업데이트된 필드 유형이 모두 동일한 필드에 대해 정의된 경우 오래된 패싯 유형이 우선합니다. 예시 를 들어 token 및 stringFacet 가 필드 에 대해 모두 정의된 경우 패싯 계산은 stringFacet 매핑을 사용합니다.

내장된 문서 배열의 일치하는 하위 항목에 대한 패싯

각 패싯 정의에는 쿼리 조건자와 일치하는 embeddedDocuments 배열의 하위 문서로만 패싯의 버킷 수를 제한하는 선택 사항인 embeddedDocument 필드가 포함될 수 있습니다. embeddedDocument 필드를 생략하면 패싯이 문서 인덱스됩니다.

embeddedDocument이 없으면 루트 문서는 해당 버킷에 속하는 하위 문서가 하나라도 있는 경우, 해당 하위 문서가 facet.operator 블록에 정의된 쿼리와 일치하지 않더라도 버킷에 포함됩니다. embeddedDocument 필드는 버킷 기여를 지정된 embeddedDocument.operator와 일치하는 하위 문서로만 제한합니다. 각 루트 문서를 버킷당 최대 한 번만 계산합니다.

embeddedDocument 필드는 다음 필드를 사용합니다.

필드	유형	설명	필수 사항입니다.
`path`	문자열	패싯의 범위를 지정할 인덱스 `embeddedDocuments` 유형 필드입니다. 패싯의 `path`은 이 필드의 하위 항목이어야 합니다.	네
`operator`	객체	`path`에 지정하는 `embeddedDocuments` 배열의 각 하위 문서에 대해 실행할 연산자 입니다. 이 연산자와 일치하는 하위 문서만 패싯의 버킷 수에 기여합니다. 이 연산자에서 참조되는 모든 경로는 `path`의 하위 항목이어야 합니다.	네

For a number or date facet, a matching child whose value falls outside the configured boundaries counts in the default bucket, if you specify one, using the same rule as a document-indexed facet. A root document with no matching child doesn't contribute to the embeddedDocument-scoped facet, but can still contribute to any other, unscoped facet in the same query.

중요

You can't combine an embeddedDocument-scoped facet with several other faceting options. To learn more, see Limitations.

For an example, see the Embedded-Scoped Facet Example.

패싯 집계

중요

Facet aggregations is in Preview. The feature and corresponding documentation might change at any time during the Preview period. To learn more, see Preview Features.

To compute metrics for each facet bucket, add an aggregations document to a facet definition. MongoDB Search computes the metrics from the MongoDB Search index, so it is much more efficient than running a $group stage later in your pipeline.

각 패싯 버킷에 대해, aggregations은 다음 값을 계산할 수 있습니다.

합계
평균
minimum
maximum
first
last

aggregations을 사용할 때는 다음을 수행해야 합니다.

각 지표에 대해 path에 지정한 필드를 token, number 또는 date으로 인덱싱합니다.
버킷 개수를 확인하려면 count 지표를 명시적으로 포함하세요.
중첩된 패싯의 리프 수준에서만 aggregations을(를) 지정하세요.

중간 그룹화에 대한 지표를 계산하려면 해당 그룹화를 aggregations이(가) 포함된 별도의 최상위 패싯으로 지정하고 중첩된 패싯은 지정하지 마세요.

MongoDB Search는 MongoDB Search 인덱스에 있는 데이터에 대해 aggregations을 계산합니다. 이는 결국적으로 일관적인.

참고

메모리 요구 사항

Facet queries that specify aggregations or nested facets increase the memory and disk that your MongoDB Search index requires beyond the requirements for other facet queries. To learn more, see Memory Requirements.

구문

aggregations 의 구문은 다음과 같습니다:

{
  "$searchMeta": {
    "facet": {
      "facets": {
        "<facet-name>": {
          "type": "<facet-type>",
          "path": "<field-path>",
          "aggregations": {
            "<aggregation-name>": {
              "type": "sum" | "min" | "max" | "avg" | "first" | "last",
              "path": "<field-path>"
            }
          }
        }
      }
    }
  }
}

aggregations 문서의 각 키는 사용자가 지정하는 집계 이름입니다. MongoDB Search는 사용자가 지정한 이름으로 버킷 문서의 각 집계를 반환합니다.

옵션

옵션	유형	설명	필수 사항입니다.
`path`	문자열	지표를 계산할 필드 경로입니다. 이는 `path`을 허용하지 않는 `count`을 제외한 모든 지표 유형에 필요합니다. 다른 모든 지표 유형은 두 번째 필드에서 값을 계산하므로 해당 필드의 이름을 지정해야 합니다. 예시, 버킷에 있는 문서의 평균 평점을 반환하려면 `rating`의 `path`과 함께 `avg`를 지정합니다. `count` 지표는 버킷의 문서를 계산하므로 두 번째 필드가 필요하지 않습니다.	조건부
`type`	문자열	계산할 지표의 유형입니다. 값은 다음 중 하나일 수 있습니다: `count` `sum` `avg` `min` `max` `first` `last` To learn more about each metric type, see Metric Types.	네

지표 유형

유형	필드 요구 사항	설명
`count`	none	버킷에 있는 문서 개수를 셉니다. 이 지표 유형에는 `path`을(를) 지정하지 마세요. 패싯 정의에서 `aggregations`을(를) 생략하면 MongoDB Search는 버킷에 대해 `count` 지표를 반환합니다. `aggregations`을(를) 지정하면 MongoDB Search는 `aggregations` 문서에 `count`을(를) 지정한 경우에만 `count` 지표를 반환합니다.
`sum`	숫자	버킷에 있는 문서의 지정된 필드 값을 더합니다.
`avg`	숫자	버킷에 있는 문서에 대해 지정된 필드 값의 평균을 반환합니다. 버킷의 어떤 문서에도 필드에 대한 값이 없으면 MongoDB Search는 `null`을(를) 반환합니다.
`min`	none	버킷 내 문서에 대해 지정된 필드의 최솟값을 반환합니다.
`max`	none	버킷 내 문서에 대해 지정된 필드의 가장 높은 값을 반환합니다.
`first`	none	쿼리 정렬 옵션이 정의하는 순서에 따라 버킷의 첫 번째 문서에 대해 지정된 필드의 값을 반환합니다. 쿼리에 정렬이 지정되지 않은 경우 순서는 임의적입니다. 정렬을 지정하는 방법을 학습하려면 MongoDB Search 결과 정렬을 참조하세요.
`last`	none	쿼리 정렬 옵션에 정의된 순서에 따라 버킷의 마지막 문서에 대해 지정된 필드의 값을 반환합니다. 쿼리에 정렬이 지정되지 않은 경우 순서는 임의적입니다. 정렬을 지정하는 방법을 학습하려면 MongoDB Search 결과 정렬을 참조하세요.

중요

min 및 max은(는) token을(를) 포함한 모든 필드 유형을 지원합니다. MongoDB Search가 이러한 지표를 계산할 때 필드가 지원되지 않는 유형으로 확인되는 문서는 건너뜁니다. MongoDB Search는 문서를 건너뛸 때 오류를 반환하지 않습니다. MongoDB Search가 버킷의 문서를 건너뛰었는지 확인하려면 동일한 aggregations 문서에 count 지표를 추가하고 예상되는 문서 수와 비교하십시오.

For values that MongoDB Search doesn't skip, min selects the smallest value in the bucket and max selects the largest. If the values aren't all of the same type, MongoDB Search applies BSON type comparison order to determine which value is smallest or largest.

배열 고려 사항

각 지표 유형은 배열과 같이 둘 이상의 값으로 확인되는 필드를 다르게 처리하다.

sum 그리고 avg 문서를 건너뛰세요.
min 그리고 max은(는) 문서의 대표 요소로 사용할 배열에서 가장 낮은 값과 가장 높은 값을 선택합니다.
first 그리고 last은(는) 모든 값을 배열로 반환합니다.

first 및 last의 경우, 반환된 배열은 다음 방식에서 원본 문서와 다릅니다.

값의 순서는 다를 수 있습니다. MongoDB Search는 인덱스에서 값을 읽는데, 이는 원본 문서의 순서를 유지하지 않습니다. 예를 들어, 문서에 ["red", "blue", "green"]이 포함된 경우 MongoDB Search는 ["blue", "green", "red"]을 반환할 수 있습니다.
MongoDB Search는 중복된 값의 인스턴스를 하나만 반환합니다.
MongoDB Search는 패싯을 지정할 수 없는 유형의 값을 포함하여 경로의 모든 값을 반환합니다. 예를 들어, 배열에 문자열과 불리언이 모두 포함된 경우 MongoDB Search는 문자열과 함께 불리언을 반환합니다.

소스 문서에 포함된 그대로 값을 반환하려면 인덱스 정의에서 필드에 대해 storedSource를 정의하고 쿼리에서 returnStoredSource를 true (으)로 설정합니다.

중첩 패싯

중요

Nested facets is in Preview. The feature and corresponding documentation might change at any time during the Preview period. To learn more, see Preview Features.

To group the documents in each bucket by additional fields, add a facets document to an existing facet definition. Each nested facet definition uses the same syntax as a top-level facet definition, so you can nest facets to build a tree of groupings. MongoDB Search returns the buckets for a nested facet inside each bucket of its parent facet.

For each bucket of a facet that contains a nested facet, MongoDB Search also returns a count field with the number of documents in the bucket. You don't need to specify a count metric for these intermediate buckets.

You can nest facets without limit on the number of levels. However, the following restrictions apply:

중첩된 패싯 트리에서 리프 패싯에만 aggregations을 지정할 수 있습니다. facets을 지정하는 패싯 정의는 aggregations도 지정할 수 없습니다. 중간 그룹화에 대한 지표를 계산하려면 해당 그룹화를 aggregations이 포함된 별도의 최상위 패싯으로 지정하고 중첩된 패싯은 지정하지 마세요.
You can't name a nested facet count. MongoDB Search reserves count for the document count of intermediate buckets.
쿼리가 반환할 수 있는 고유 버킷의 총 개수는 100000개를 초과할 수 없습니다. 하나의 패싯 트리가 생성하는 버킷을 계산하려면 중첩 분기의 각 수준에 있는 버킷 수를 곱하십시오. 수준의 버킷 수는 string 패싯의 경우 numBuckets 이고, 숫자 또는 날짜 패싯의 경우 boundaries 및 default이 정의하는 버킷 수입니다. 예를 들어, 20 개의 버킷을 요청하고 20 개의 버킷을 요청하는 중첩 패싯을 포함하는 패싯은 400 개의 고유한 버킷을 생성합니다. 각 레벨이 이 합계를 곱하기 때문에 각 레벨에서 더 많은 버킷을 요청하면 중첩할 수 있는 레벨 수가 줄어듭니다.

패싯 결과

패싯 쿼리 의 경우 MongoDB Search는 정의된 패싯 이름을 결과의 해당 패싯 에 대한 버킷 배열 에 매핑합니다. 패싯 결과 문서 에는 패싯 에 대한 결과 버킷의 배열 인 buckets 옵션이 포함되어 있습니다. 배열 의 각 패싯 버킷 문서 에는 다음과 같은 필드가 있습니다.

옵션	유형	설명
`_id`	객체	이 패싯 버킷을 식별하는 고유 식별자입니다. 이 값은 패싯 처리되는 데이터 형식과 일치합니다.
`count`	int	이 패싯 버킷에 있는 문서 수입니다. `count` 필드에 대해 자세히 학습하려면 MongoDB 검색 결과 집계를 참조하세요.

If the facet definition specifies Facet Aggregations, each bucket document contains the metrics that you name in the aggregations document instead of the count field. If the facet definition specifies nested facets, each bucket document contains a count field with the number of documents in the bucket, and the results for the nested facet.

다중 선택 패싯

MongoDB Search를 사용하면 동일한 패싯 내의 여러 버킷을 동시에 보고 선택할 수 있습니다. 일반적으로 패싯 내에서 버킷을 선택하면 해당 선택 항목에 따라 검색 결과가 필터링되고 모든 패싯의 개수가 변경됩니다.

예시

sample_airbnb.listings 컬렉션 에 대한 인덱스 정의가 다음 필드에 대한 패싯을 지정한다고 가정해 보겠습니다.

cancellation_policy
room_type
accommodates

cancellation_policy 패싯 에는 다음과 같은 버킷이 있습니다.

flexible
moderate
strict_14_with_grace_period
super_strict_30
super_strict_60

각 버킷에는 고유한 결과 개수가 있습니다. moderate cancellation_policy을(를) 검색하면 다른 4개 버킷의 개수가 0(으)로 이동합니다. 또한, room_type 및 accommodates 패슷의 버킷 개수는 각 버킷에 flexible cancellation_policy도 있는 결과의 수로 줄어들어요.

패싯이 검색 결과 수에 미치는 영향을 보다 세밀하게 제어해야 하는 시나리오에서는 패싯 쿼리에서 doesNotAffect 속성 사용하여 다중 선택 패싯을 활성화 . 이러한 패싯은 여전히 결과를 필터하다 하지만 쿼리 결과 수를 변경하지 않습니다.

다음 연산자에서 doesNotAffect을 지정할 수 있습니다.

여러 패싯을 제외하려면 패싯 이름의 배열을 지정합니다. 대부분의 사용 사례에서는 필터와 경로를 공유하는 패싯만 제외합니다. 예시, rating 필드의 equals 필터는 rating을(를) 경로로 사용하는 패싯의 이름을 지정합니다.

참고

The doesNotAffect option doesn't work with facets that specify aggregations. To learn more, see Limitations.

예시

sample_airbnb.listingsAndReviews 컬렉션에 대한 쿼리를 고려하여 moderate cancellation_policy를 가진 문서를 찾습니다. doesNotAffect 값을 cancellation_policy로 지정하면 cancellation_policy 패싯의 버킷 개수는 변경되지 않지만, 다른 패싯의 버킷 결과 개수는 각 버킷에 moderate cancellation_policy도 있는 결과의 수로 줄어듭니다.

자세한 내용은 다중 선택 패싯 예시참조하세요.

You can't combine doesNotAffect with an embeddedDocument-scoped facet. To learn more, see Facet on Matching Children of an Embedded Documents Array.

마지막으로 패싧이 많은 사용 사례의 경우, 특정 패싧에 영향을 미치는 다른 필터를 제한할 수 있습니다. 다른 필드의 패싧을 포함하여 모든 필터의 doesNotAffect 속성에서 패싧을 지정함으로써 이 작업을 수행할 수 있습니다. 이를 통해 어떤 선택이 옵션의 폭을 더 많이 또는 더 적게 족히는지 한눈에 확인할 수 있습니다.

예시

sample_airbnb.listingsAndReviews 컬렉션에 대한 쿼리를 고려하여 accommodates 값이 3인 문서를 찾습니다. doesNotAffect 값을 cancellation_policy로 지정하면 room_type 버킷의 결과 수는 3 명을 수용하는 각 버킷의 결과 수로 줄어들지만 cancellation_policy의 버킷에 대한 결과 수는 영향을 받지 않습니다.

자세한 내용은 패싯 간 필터 제외 예시를 참조하세요.

`SEARCH_META` 집계 변수

When you run your query using the $search stage, MongoDB Search stores the metadata results in the $$SEARCH_META variable and returns only the search results. You can use the $$SEARCH_META variable in all the supported aggregation pipeline stages to view the metadata results for your $search query. You can also use the $$SEARCH_META variable with facet.aggregations.

MongoDB는 검색 결과와 메타데이터 결과가 모두 필요한 경우에만 $$SEARCH_META 변수를 사용할 것을 권장합니다. 해당 경우가 아니면 다음을 사용하세요.

$search 검색 결과만 표시하는 단계.
$searchMeta 메타데이터 결과만 표시하는 단계.

제한 사항

단일 필드에 대해서만 패싯 쿼리를 실행할 수 있습니다. 필드 그룹에 대해서는 패싯 쿼리를 실행할 수 없습니다.

임베디드 범위 패싯에 대한 제한 사항

The following limitations apply to Facet on Matching Children of an Embedded Documents Array:

동일 쿼리에서 최상위 returnScope 옵션과 embeddedDocument범위의 패슷을 결합할 수 없습니다.
embeddedDocument범위 패슷은 개수만 반환합니다.
동일한 쿼리에서 드릴 사이드웨이 패싯(doesNotAffect)과 embeddedDocument범위의 패싯을 결합할 수 없습니다.

패싯 집계에 대한 제한 사항

The following limitations apply to Facet Aggregations:

aggregations에서는 다음 옵션을 사용할 수 없습니다.
- returnScope
- doesNotAffect for Multi-Select Facets
You can't facet or compute aggregations on the following BSON types:
- binData
- bool
- decimal
- null
- objectId
- timestamp
To compute metrics over one of these types, use a view to convert the field to a supported type before you index it.

예시

The following examples use the sample data. The metadata results example demonstrates how to run a $searchMeta query with facet to retrieve only the metadata in the results. The metadata and search results example demonstrates how to run a $search query with facet and the $SEARCH_META aggregation variable to retrieve both the search and metadata results. The returnScope example demonstrates how to facet on nested fields in an array of objects dynamically indexed using the embeddedDocuments type. The embedded-scoped facet example demonstrates how to facet on only the matching children of an embeddedDocuments array. The multi-select and inter-facet filter exclusion examples demonstrate how to use doesNotAffect to control how facets affect each other's counts. The aggregation example demonstrates how to compute metrics for each facet bucket, and the nested facet example demonstrates how to group results by a second field and compute metrics for each bucket.

sample_mflix.movies 컬렉션의 인덱스 정의는 인덱싱할 필드에 대해 다음을 지정합니다.

필드 이름	데이터 유형
`directors`	token
`year`	숫자
`released`	날짜

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "directors": {
        "type": "token"
      },
      "year": {
        "type": "number"
      },
      "released": {
        "type": "date"
      }
    }
  }
}

다음 쿼리는 2000 년 1월 01일과 2015년 1월 31일 사이에 개봉한 영화를 검색합니다. directors 및 year 필드에 대한 메타데이터를 요청합니다.

1 db.movies.aggregate([
2   {
3     "$searchMeta": {
4       "facet": {
5         "operator": {
6           "range": {
7             "path": "released",
8             "gte": ISODate("2000-01-01T00:00:00.000Z"),
9             "lte": ISODate("2015-01-31T00:00:00.000Z")
10           }
11         },
12         "facets": {
13           "directorsFacet": {
14             "type": "string",
15             "path": "directors",
16             "numBuckets" : 7
17           },
18           "yearFacet" : {
19             "type" : "number",
20             "path" : "year",
21             "boundaries" : [2000,2005,2010, 2015]
22           }
23         }
24       }
25     }
26   }
27 ])

1 [
2   {
3     count: { lowerBound: Long('11922') },
4     facet: {
5       yearFacet: {
6         buckets: [
7           { _id: 2000, count: Long('3064') },
8           { _id: 2005, count: Long('4035') },
9           { _id: 2010, count: Long('4553') }
10         ]
11       },
12       directorsFacet: {
13         buckets: [
14           { _id: 'Takashi Miike', count: Long('26') },
15           { _id: 'Johnnie To', count: Long('20') },
16           { _id: 'Steven Soderbergh', count: Long('18') },
17           { _id: 'Michael Winterbottom', count: Long('16') },
18           { _id: 'Ridley Scott', count: Long('15') },
19           { _id: 'Tyler Perry', count: Long('15') },
20           { _id: 'Clint Eastwood', count: Long('14') }
21         ]
22       }
23     }
24   }
25 ]

결과는 sample_mflix.movies 컬렉션에 있는 다음과 같은 것들의 개수를 표시합니다.

2000년(하한 포함)부터 2015(상한 제외)까지 MongoDB Search가 쿼리 에 대해 반환한 영화 수
MongoDB Search가 쿼리 에 대해 반환한 각 감독의 영화 수

이러한 결과에 대해 자세히 알아보려면 패싯 결과를 참조하세요.

sample_mflix.movies 컬렉션의 인덱스 정의는 인덱싱할 필드에 대해 다음을 지정합니다.

필드 이름	데이터 유형
`genres`	token
`released`	날짜

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "genres": {
        "type": "token"
      },
      "released": {
        "type": "date"
      }
    }
  }
}

The following query searches for movies released near July 01, 1999 using the $search stage. The query includes a $facet stage to process the input documents using the following sub-pipeline stages:

$project stage to exclude all fields in the documents except the title and released fields in the docs output field
$limit 단계를 사용하여 다음을 수행합니다.
- $search 단계 출력을 2개 문서로 제한합니다.
- meta 출력 필드에 있는 1개 문서로 출력을 제한합니다.
참고
결과를 16MB 문서에 맞추려면 제한이 작아야 합니다.
$replaceWith stage to include the metadata results stored in the $$SEARCH_META variable in the meta output field

The query also includes a $set stage to add the meta field.

참고

다음 쿼리 에 대한 메타데이터 결과 를 보려면 MongoDB Search 에서 쿼리 와 일치 하는 문서 를 반환 해야 합니다 .

1 db.movies.aggregate([
2  {
3    "$search": {
4      "facet": {
5        "operator": {
6          "near": {
7            "path": "released",
8            "origin": ISODate("1999-07-01T00:00:00.000+00:00"),
9            "pivot": 7776000000
10          }
11        },
12        "facets": {
13          "genresFacet": {
14            "type": "string",
15            "path": "genres"
16          }
17        }
18      }
19    }
20  },
21  { "$limit": 2 },
22  {
23    "$facet": {
24      "docs": [
25        { "$project":
26          {
27            "title": 1,
28            "released": 1
29          }
30        }
31      ],
32      "meta": [
33        {"$replaceWith": "$$SEARCH_META"},
34        {"$limit": 1}
35      ]
36    }
37  },
38  {
39    "$set": {
40      "meta": {
41        "$arrayElemAt": ["$meta", 0]
42      }
43    }
44  }
45 ])

1 [
2  {
3    docs: [
4      {
5        _id: ObjectId('573a1393f29313caabcde1ae'),
6        title: 'Begone Dull Care',
7        released: ISODate('1999-07-01T00:00:00.000Z')
8      },
9      {
10        _id: ObjectId('573a13a9f29313caabd2048a'),
11        title: 'Fara'                released: ISODate('1999-07-01T00:00:00.000Z')
12      }
13    ],
14    meta: {
15      count: { lowerBound: Long('20878') },
16      facet: {
17        genresFacet: {
18          buckets: [
19            { _id: 'Drama', count: Long('12149') },
20            { _id: 'Comedy', count: Long('6436') },
21            { _id: 'Romance', count: Long('3274') },
22            { _id: 'Crime', count: Long('2429') },
23            { _id: 'Thriller', count: Long('2400') },
24            { _id: 'Action', count: Long('2349') },
25            { _id: 'Adventure', count: Long('1876') },
26            { _id: 'Documentary', count: Long('1755') },
27            { _id: 'Horror', count: Long('1432') },
28            { _id: 'Biography', count: Long('1244') }
29          ]
30        }
31      }
32    }
33  }
34 ]

이러한 결과에 대해 자세히 알아보려면 패싯 결과를 참조하세요.

sample_training.companies 컬렉션의 인덱스 정의는 funding_rounds 필드를 embeddedDocuments 유형으로 인덱싱합니다. funding_rounds 객체 배열의 모든 필드를 동적으로 인덱싱하고 raised_currency_code 및 raised_amount 필드를 storedSource 옵션을 사용하여 funding_rounds 객체 배열에 저장합니다.

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "funding_rounds": {
        "type": "embeddedDocuments",
        "dynamic": true,
        "storedSource": {
          "include": [
            "raised_currency_code",
            "raised_amount"
          ]
        }
      }
    }
  }
}

다음 쿼리입니다:

USD에서 모금된 자금을 검색하기 위해 text (MongoDB Search 연산자)를 사용합니다.
returnScope 옵션을 사용하여 embeddedDocuments 필드 funding_rounds에 쿼리 컨텍스트를 설정합니다. returnScope 를 사용하려면 다음 쿼리를 입력합니다.
- 저장된 소스 필드를 반환하는 데 필요한 ReturnSoredSource 옵션을 지정합니다.
funding_rounds 객체 배열의 raised_amount 필드에 패싯합니다. 쿼리는 3개의 버킷을 지정합니다.
- 5000000, 이 버킷에 대한 포괄적인 하한값
- 5250000, 5000000 버킷의 상한 제외 및 이 버킷의 하한 포함
- 5500000, 5250000 버킷의 배타적 상한선

1 db.companies.aggregate([
2  {
3    "$searchMeta": {
4      "returnStoredSource": true,
5      "returnScope": {
6        "path": "funding_rounds"
7      },
8      "facet": {
9        "operator": {
10          "text": {
11            "path": "funding_rounds.raised_currency_code",
12            "query": "USD"
13          }
14        },
15        "facets": {
16          "raisedAmountFacet": {
17            "type": "number",
18            "path": "funding_rounds.raised_amount",
19            "boundaries": [5000000, 5250000, 5500000]
20          }
21        }
22      }
23    }
24  }
25 ])

1 [
2   {
3     count: { lowerBound: Long('5329') },
4     facet: {
5       raisedAmountFacet: {
6         buckets: [
7           { _id: 5000000, count: Long('251') },
8           { _id: 5250000, count: Long('32') }
9         ]
10       }
11     }
12   }
13 ]

이전 MongoDB 검색 결과에서 패싯 수는 상위 문서가 아닌 내장된 하위 문서를 기반으로 합니다.

sample_training.companies 컬렉션의 인덱스 정의는 funding_rounds 필드를 embeddedDocuments 유형으로 인덱싱하며, 각 펀딩 라운드의 round_code 및 raised_currency_code 필드는 token으로 인덱싱됩니다.

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "name": {
        "type": "token"
      },
      "funding_rounds": {
        "type": "embeddedDocuments",
        "dynamic": false,
        "fields": {
          "round_code": {
            "type": "token"
          },
          "raised_currency_code": {
            "type": "token"
          }
        }
      }
    }
  }
}

KickApps, Topix, StumbleUpon은 각각 여러 차례의 펀딩 라운드를 거쳤으며, 그중 일부만이 USD에서 조달되었습니다.

// KickApps
{ "name": "KickApps",
  "funding_rounds": [
    { "round_code": "a", "raised_currency_code": "USD" },
    { "round_code": "b", "raised_currency_code": "USD" },
    { "round_code": "c", "raised_currency_code": "GBP" }
  ]
}
// Topix
{ "name": "Topix",
  "funding_rounds": [
    { "round_code": "a", "raised_currency_code": null },
    { "round_code": "b", "raised_currency_code": "USD" }
  ]
}
// StumbleUpon
{ "name": "StumbleUpon",
  "funding_rounds": [
    { "round_code": "seed", "raised_currency_code": "USD" },
    { "round_code": "a", "raised_currency_code": null },
    { "round_code": "b", "raised_currency_code": "USD" },
    { "round_code": "angel", "raised_currency_code": null }
  ]
}

다음 쿼리는 in 연산자를 사용하여 패싯을 이 세 회사로 제한한 다음 funding_rounds.round_code에 대해 패싯을 지정합니다. roundFacet 정의는 raised_currency_code가 USD인 펀딩 라운드로만 패싯 범위를 지정하는 embeddedDocument 블록을 지정합니다.

1 db.companies.aggregate([
2   {
3     "$searchMeta": {
4       "facet": {
5         "operator": {
6           "in": {
7             "path": "name",
8             "value": ["KickApps", "Topix", "StumbleUpon"]
9           }
10         },
11         "facets": {
12           "roundFacet": {
13             "type": "string",
14             "path": "funding_rounds.round_code",
15             "embeddedDocument": {
16               "path": "funding_rounds",
17               "operator": {
18                 "equals": {
19                   "path": "funding_rounds.raised_currency_code",
20                   "value": "USD"
21                 }
22               }
23             }
24           }
25         }
26       }
27     }
28   }
29 ])

1 [
2   {
3     count: { lowerBound: Long('3') },
4     facet: {
5       roundFacet: {
6         buckets: [
7           { _id: 'b', count: Long('3') },
8           { _id: 'a', count: Long('1') },
9           { _id: 'seed', count: Long('1') }
10         ]
11       }
12     }
13   }
14 ]

각 회사는 USD에서 최소 한 번의 투자 라운드를 유치한 라운드 코드당 한 번씩 집계됩니다.

b 3건: KickApps, Topix, StumbleUpon은 각각 USD에 b 라운드 투자를 유치했습니다.
a 1 건: KickApps만이 USD에 a 라운드를 유치했습니다. Topix와 StumbleUpon의 a 라운드는 기록된 통화가 없으므로 일치하지 않습니다.
seed counts 1: StumbleUpon의 seed 라운드는 USD에 모금되었습니다.

KickApps의 c 라운드는 USD이 아닌 GBP에서 조달되었으므로 c 버킷에 기여하지 않습니다. embeddedDocument 블록이 없으면 funding_rounds.round_code에 대한 패싯은 funding_rounds을(를) 문서 유형으로 대신 인덱싱해야 하며, 루트 문서에 통화와 관계없이 해당 버킷에 일치하는 자식이 있기 때문에 범위가 지정되지 않은 패싯도 KickApps를 c 버킷으로 계산합니다.

sample_airbnb.listingsAndReviews 컬렉션에 대한 다음 인덱스 정의는 동적으로 인덱싱할 수 있는 모든 필드의 인덱스를 자동으로 생성하고 패싯 검색을 위해 cancellation_policy, room_type, price 필드를 구성합니다.

{
  "mappings": {
    "dynamic": true,
    "fields": {
      "cancellation_policy": {
        "type": "token"
      },
      "room_type": {
        "type": "token"
      },
      "accommodates": {
        "type": "number"
      }
    }
  }
}

다음 쿼리는 $searchMeta 단계를 사용하여 다음 작업을 수행합니다.

cancellation_policy, roomType 및 accommodates 필드의 패싯입니다.

cancellation_policy 패싯 에는 다음과 같은 버킷이 있습니다.
- "strict_14_with_grace_period"
- "moderate"
- "flexible"
- "super_strict_30"
- "super_strict_60"
room_type 패싯 에는 다음과 같은 버킷이 있습니다.
- "Entire home/apt"
- "Private room"
- "Shared room"
쿼리 accommodates 패싯 다음에 대한 버킷으로 나눕니다.
- 1이 버킷에 대한 포괄적인 하한값
- 21 버킷에 대한 배타적 상한과 이 버킷에 대한 포괄적 하한입니다.
- 42 버킷에 대한 배타적 상한과 이 버킷에 대한 포괄적 하한입니다.
- 84 버킷에 대한 배타적 상한
연산자 검색 에 compound 텍스트를 포함해야 new york city 하는 목록에 description 대해 수행하고 이 포함된 목록에 대한 결과를 moderate cancellation_policy 필터링합니다. doesNotAffect 설정은 moderate cancellation_policy 로 필터링해도 패싯 에 있는 다른 버킷의 개수가 변경되지 않도록 합니다. "strict_14_with_grace_period", "flexible", "super_strict_30", "super_strict_60" 의 개수는 0이 아닌 값입니다.

1 db.listingsAndReviews.aggregate([
2   {
3     $searchMeta: {
4       facet: {
5         facets: {
6           accommodatesFacet: {
7             path: "accommodates",
8             type: "number",
9             boundaries: [1,2,4,8]
10           },
11           cancellationFacet: {
12             path: "cancellation_policy",
13             type: "string"
14           },
15           roomTypeFacet: {
16             path: "room_type",
17             type: "string"
18           }
19         },
20         operator: {
21           compound: {
22             must: [
23               {
24                 text: {
25                   path: "description",
26                   query: "new york city"
27                 },
28               },
29             ],
30             filter: [
31               {
32                 equals: {
33                   path: "cancellation_policy",
34                   value: "moderate",
35                   doesNotAffect:
36                     "cancellationFacet"
37                 }
38               }
39             ]
40           }
41         }
42       }
43     }
44   }
45 ])

1 [
2   {
3     count: { lowerBound: Long('531') },
4     facet: {
5       accommodatesFacet: {
6         buckets: [
7           { _id: 1, count: Long('25') },
8           { _id: 2, count: Long('270') },
9           { _id: 4, count: Long('204') }
10         ]
11       },
12       cancellationFacet: {
13         buckets: [
14           { _id: 'strict_14_with_grace_period', count: Long('849') },
15           { _id: 'moderate', count: Long('531') },
16           { _id: 'flexible', count: Long('380') },
17           { _id: 'super_strict_60', count: Long('25') },
18           { _id: 'super_strict_30', count: Long('11') }
19         ]
20       },
21       roomTypeFacet: {
22         buckets: [
23           { _id: 'Entire home/apt', count: Long('369') },
24           { _id: 'Private room', count: Long('159') },
25           { _id: 'Shared room', count: Long('3') }
26         ]
27       }
28     }
29   }
30 ]

cancellationFacet의 버킷에 대한 카운트는 moderate의 값에 대한 쿼리 필터가 있음에도 불구하고 0으로 줄어들지 않습니다.

sample_airbnb.listingsAndReviews 컬렉션 에 대한 다음 인덱스 정의는 cancellation_policy, room_type 및 price 필드를 인덱싱하여 패싯 검색 활성화합니다.

{
  "mappings": {
    "dynamic": true,
    "fields": {
      "cancellation_policy": {
        "type": "token"
      },
      "room_type": {
        "type": "token"
      },
      "accommodates": {
        "type": "number"
      }
    }
  }
}

다음 쿼리입니다:

description 에 new york city 텍스트가 포함되어 있고 cancellation_policy 가 moderate인 목록을 검색합니다.
cancellation_policy, roomType 및 accommodates 필드의 패싯입니다.

각 cancellation_policy 및 roomType 패싯에는 컬렉션 전체에 있는 해당 필드의 고유한 값 3개에 해당하는 세 개의 버킷이 있습니다. 쿼리는 accommodates 패싯을 다음과 같은 버킷으로 나눕니다.
- 1이 버킷에 대한 포괄적인 하한값
- 21 버킷에 대한 배타적 상한과 이 버킷에 대한 포괄적 하한입니다.
- 42 버킷에 대한 배타적 상한과 이 버킷에 대한 포괄적 하한입니다.
- 84 버킷에 대한 배타적 상한
compound.filter의 equals 연산자에서 doesNotAffect 속성을 accommodatesFacet(으)로 설정합니다. 이렇게 하면 accommodates 패싯 내의 버킷이 필터링에서 제외됩니다. 결과적으로 moderate cancellation_policy에서 필터링하면 cancellation_policy 패싯의 다른 버킷 수가 0(으)로 줄어들고 roomType 패싯의 버킷 수가 줄어들지만 accommodates 패싯의 버킷 수는 변경되지 않습니다. 이를 통해 다양한 패싯에 대한 필터링의 영향을 비교할 수 있습니다.

1 db.listingsAndReviews.aggregate([
2   {
3     $searchMeta: {
4       facet: {
5         facets: {
6           accommodatesFacet: {
7             path: "accommodates",
8             type: "number",
9             boundaries: [1,2,4,8],
10           },
11           cancellationFacet: {
12             path: "cancellation_policy",
13             type: "string",
14           },
15           roomTypeFacet: {
16             path: "room_type",
17             type: "string",
18           }
19         },
20         operator: {
21           compound: {
22             must: [
23               {
24                 text: {
25                   path: "description",
26                   query: "new york city",
27                 },
28               },
29             ],
30             filter: [
31               {
32                 equals: {
33                   path: "cancellation_policy",
34                   value: "moderate",
35                   doesNotAffect:
36                     "accommodatesFacet",
37                 },
38               },
39             ],
40           },
41         },
42       },
43     },
44   },
45 ]

1 [
2   {
3     count: { lowerBound: Long('531') },
4     facet: {
5       accommodatesFacet: {
6         buckets: [
7           { _id: 1, count: Long('141') },
8           { _id: 2, count: Long('834') },
9           { _id: 4, count: Long('703') }
10         ]
11       },
12       cancellationFacet: {
13         buckets: [
14           { _id: 'moderate', count: Long('531') }
15         ]
16       },
17       roomTypeFacet: {
18         buckets: [
19           { _id: 'Entire home/apt', count: Long('369') },
20           { _id: 'Private room', count: Long('159') },
21           { _id: 'Shared room', count: Long('3') }
22         ]
23       }
24     }
25   }
26 ]

다음 예시는 sample_airbnb.listingsAndReviews 컬렉션의 default 라는 인덱스를 사용합니다. 컬렉션의 property_type 및 amenities 필드는 토큰 유형으로 인덱싱되고 accommodates 필드는 숫자 유형으로 인덱싱됩니다.

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "property_type": [
        {
          "type": "token"
        }
      ],
      "amenities": [
        {
          "type": "token"
        }
      ],
      "accommodates": [
        {
          "type": "number"
        }
      ]
    }
  }
}

이 쿼리는 $searchMeta 단계를 사용하여 지정된 편의 시설 중 하나 이상을 제공하는 리스팅을 찾고 property_type별로 그룹화합니다. 각 속성 유형에 대해 쿼리는 리스팅 수와 리스팅이 수용할 수 있는 최소 및 최대 게스트 수를 계산합니다.

1 db.listingsAndReviews.aggregate([
2   {
3     "$searchMeta": {
4       "facet": {
5         "operator": {
6           "in": {
7             "path": "amenities",
8             "value": ["Wifi", "Pets allowed", "Wheelchair accessible"]
9           }
10         },
11         "facets": {
12           "propertyTypeFacet": {
13             "type": "string",
14             "path": "property_type",
15             "aggregations": {
16               "listingCount": {
17                 "type": "count"
18               },
19               "minAccommodates": {
20                 "type": "min",
21                 "path": "accommodates"
22               },
23             "maxAccommodates": {
24                 "type": "max",
25                 "path": "accommodates"
26               }
27             }
28           }
29         }
30       }
31     }
32   }
33 ])

[
  {
    count: { lowerBound: Long('5355') },
    facet: {
      propertyTypeFacet: {
        buckets: [
          {
            _id: 'Apartment',
            listingCount: Long('3488'),
            minAccommodates: 1,
            maxAccommodates: 16
          },
          {
            _id: 'House',
            listingCount: Long('584'),
            minAccommodates: 1,
            maxAccommodates: 16
          },
          {
            _id: 'Condominium',
            listingCount: Long('386'),
            minAccommodates: 1,
            maxAccommodates: 12
          },
          {
            _id: 'Serviced apartment',
            listingCount: Long('182'),
            minAccommodates: 1,
            maxAccommodates: 16
          },
          {
            _id: 'Loft',
            listingCount: Long('139'),
            minAccommodates: 1,
            maxAccommodates: 16
          },
          {
            _id: 'Townhouse',
            listingCount: Long('104'),
            minAccommodates: 1,
            maxAccommodates: 16
          },
          {
            _id: 'Guest suite',
            listingCount: Long('79'),
            minAccommodates: 1,
            maxAccommodates: 8
          },
          {
            _id: 'Bed and breakfast',
            listingCount: Long('64'),
            minAccommodates: 1,
            maxAccommodates: 16
          },
          {
            _id: 'Boutique hotel',
            listingCount: Long('51'),
            minAccommodates: 1,
            maxAccommodates: 16
          },
          {
            _id: 'Guesthouse',
            listingCount: Long('49'),
            minAccommodates: 1,
            maxAccommodates: 8
          }
        ]
      }
    }
  }
]

다음 예시는 sample_airbnb.listingsAndReviews 컬렉션의 default 라는 인덱스를 사용합니다. 컬렉션의 property_type 필드는 토큰 유형으로 인덱싱되고 bedrooms 및 accommodates 필드는 숫자 유형으로 인덱싱됩니다.

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "property_type": [
        {
          "type": "token"
        }
      ],
      "bedrooms": [
        {
          "type": "number"
        }
      ],
      "accommodates": [
        {
          "type": "number"
        }
      ]
    }
  }
}

The query groups the listings by property_type, and then groups the listings in each property type by number of bedrooms (0, 2, or 4). The query computes the number of listings and the largest number of guests that a listing accommodates for each bedroom range.

1 db.listingsAndReviews.aggregate([
2   {
3     "$searchMeta": {
4       "facet": {
5         "facets": {
6           "propertyTypeFacet": {
7             "type": "string",
8             "path": "property_type",
9             "facets": {
10               "bedroomsFacet": {
11                 "type": "number",
12                 "path": "bedrooms",
13                 "boundaries": [0, 2, 4],
14                 "default": "other",
15                 "aggregations": {
16                   "listingCount": {
17                     "type": "count"
18                   },
19                   "maxAccommodates": {
20                     "type": "max",
21                     "path": "accommodates"
22                   }
23                 }
24               }
25             }
26           }
27         }
28       }
29     }
30   }
31 ])

[
  {
    count: { lowerBound: Long('5555') },
    facet: {
      propertyTypeFacet: {
        buckets: [
          {
            _id: 'Apartment',
            count: { total: Long('3626') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('2534'), maxAccommodates: 12 },
                { _id: 2, listingCount: Long('1006'), maxAccommodates: 13 },
                { _id: 'other', listingCount: Long('86'), maxAccommodates: 16 }
              ]
            }
          },
          {
            _id: 'House',
            count: { total: Long('606') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('312'), maxAccommodates: 16 },
                { _id: 2, listingCount: Long('183'), maxAccommodates: 16 },
                { _id: 'other', listingCount: Long('111'), maxAccommodates: 16 }
              ]
            }
          },
          {
            _id: 'Condominium',
            count: { total: Long('399') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('256'), maxAccommodates: 10 },
                { _id: 2, listingCount: Long('138'), maxAccommodates: 11 },
                { _id: 'other', listingCount: Long('5'), maxAccommodates: 12 }
              ]
            }
          },
          {
            _id: 'Serviced apartment',
            count: { total: Long('185') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('128'), maxAccommodates: 7 },
                { _id: 2, listingCount: Long('53'), maxAccommodates: 12 },
                { _id: 'other', listingCount: Long('4'), maxAccommodates: 16 }
              ]
            }
          },
          {
            _id: 'Loft',
            count: { total: Long('142') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('123'), maxAccommodates: 16 },
                { _id: 2, listingCount: Long('15'), maxAccommodates: 6 },
                { _id: 'other', listingCount: Long('4'), maxAccommodates: 16 }
              ]
            }
          },
          {
            _id: 'Townhouse',
            count: { total: Long('108') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('59'), maxAccommodates: 8 },
                { _id: 2, listingCount: Long('42'), maxAccommodates: 10 },
                { _id: 'other', listingCount: Long('7'), maxAccommodates: 16 }
              ]
            }
          },
          {
            _id: 'Guest suite',
            count: { total: Long('81') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('68'), maxAccommodates: 7 },
                { _id: 2, listingCount: Long('12'), maxAccommodates: 6 },
                { _id: 'other', listingCount: Long('1'), maxAccommodates: 8 }
              ]
            }
          },
          {
            _id: 'Bed and breakfast',
            count: { total: Long('69') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('61'), maxAccommodates: 12 },
                { _id: 2, listingCount: Long('6'), maxAccommodates: 9 },
                { _id: 'other', listingCount: Long('2'), maxAccommodates: 16 }
              ]
            }
          },
          {
            _id: 'Boutique hotel',
            count: { total: Long('53') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('47'), maxAccommodates: 16 },
                { _id: 2, listingCount: Long('5'), maxAccommodates: 6 },
                { _id: 'other', listingCount: Long('1'), maxAccommodates: 15 }
              ]
            }
          },
          {
            _id: 'Guesthouse',
            count: { total: Long('50') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('43'), maxAccommodates: 8 },
                { _id: 2, listingCount: Long('7'), maxAccommodates: 6 },
                { _id: 'other', listingCount: Long('0'), maxAccommodates: null }
              ]
            }
          }
        ]
      }
    }
  }
]

MongoDB Search returns the following information for each facet bucket:

The number of listings (count) in the bucket (such as Apartment, House, and so on).
The maximum number of guests that a listing in the bucket range (0 bedrooms, 2 bedrooms, and so on) accommodates (maxAccommodates).

학습 계속하기

자세한 학습은 MongoDB 검색에서 패싯을 사용하는 방법을 참조하세요.

You can learn more about facet (MongoDB Search Operator) in MongoDB Search with our course and video.

교육 과정으로 배우기

To learn more about using facets in MongoDB Search, take Unit 9 of the Intro To MongoDB Course on MongoDB University. The 1.5 hour unit includes an overview of MongoDB Search and lessons on creating MongoDB Search indexes, running $search queries using compound operators, and grouping results using facet.

보면서 배우기

Watch this video to learn about how you can create and use a numeric and string facet (MongoDB Search Operator) in your query to group results and retrieve a count of the results in the groups.

소요 시간: 11분

돌아가기

이 존재합니다

geoShape

1	db.movies.aggregate([
2	{
3	"$searchMeta": {
4	"facet": {
5	"operator": {
6	"range": {
7	"path": "year",
8	"gte": 2000,
9	"lte": 2015
10	}
11	},
12	"facets": {
13	"genresFacet": {
14	"type": "string",
15	"path": "genres"
16	}
17	}
18	}
19	}
20	}
21	])

1	[
2	{
3	count: { lowerBound: Long('12568') },
4	facet: {
5	genresFacet: {
6	buckets: [
7	{ _id: 'Drama', count: Long('7079') },
8	{ _id: 'Comedy', count: Long('3689') },
9	{ _id: 'Romance', count: Long('1764') },
10	{ _id: 'Thriller', count: Long('1584') },
11	{ _id: 'Documentary', count: Long('1472') },
12	{ _id: 'Action', count: Long('1471') },
13	{ _id: 'Crime', count: Long('1367') },
14	{ _id: 'Adventure', count: Long('1056') },
15	{ _id: 'Horror', count: Long('866') },
16	{ _id: 'Biography', count: Long('796') }
17	]
18	}
19	}
20	}
21	]

1	[
2	{
3	count: { lowerBound: Long('6095') },
4	facet: {
5	yearFacet: {
6	buckets: [
7	{ _id: 1980, count: Long('1956') },
8	{ _id: 1990, count: Long('3558') },
9	{ _id: 'other', count: Long('581') }
10	]
11	}
12	}
13	}
14	]

1	[
2	{
3	count: { lowerBound: Long('11922') },
4	facet: {
5	yearFacet: {
6	buckets: [
7	{
8	_id: ISODate('2000-01-01T00:00:00.000Z'),
9	count: Long('3028')
10	},
11	{
12	_id: ISODate('2005-01-01T00:00:00.000Z'),
13	count: Long('3953')
14	},
15	{
16	_id: ISODate('2010-01-01T00:00:00.000Z'),
17	count: Long('4832')
18	},
19	{ _id: 'other', count: Long('109') }
20	]
21	}
22	}
23	}
24	]

1	db.movies.aggregate([
2	{
3	"$search": {
4	"facet": {
5	"operator": {
6	"near": {
7	"path": "released",
8	"origin": ISODate("1999-07-01T00:00:00.000+00:00"),
9	"pivot": 7776000000
10	}
11	},
12	"facets": {
13	"genresFacet": {
14	"type": "string",
15	"path": "genres"
16	}
17	}
18	}
19	}
20	},
21	{ "$limit": 2 },
22	{
23	"$facet": {
24	"docs": [
25	{ "$project":
26	{
27	"title": 1,
28	"released": 1
29	}
30	}
31	],
32	"meta": [
33	{"$replaceWith": "$$SEARCH_META"},
34	{"$limit": 1}
35	]
36	}
37	},
38	{
39	"$set": {
40	"meta": {
41	"$arrayElemAt": ["$meta", 0]
42	}
43	}
44	}
45	])

1	[
2	{
3	docs: [
4	{
5	_id: ObjectId('573a1393f29313caabcde1ae'),
6	title: 'Begone Dull Care',
7	released: ISODate('1999-07-01T00:00:00.000Z')
8	},
9	{
10	_id: ObjectId('573a13a9f29313caabd2048a'),
11	title: 'Fara' released: ISODate('1999-07-01T00:00:00.000Z')
12	}
13	],
14	meta: {
15	count: { lowerBound: Long('20878') },
16	facet: {
17	genresFacet: {
18	buckets: [
19	{ _id: 'Drama', count: Long('12149') },
20	{ _id: 'Comedy', count: Long('6436') },
21	{ _id: 'Romance', count: Long('3274') },
22	{ _id: 'Crime', count: Long('2429') },
23	{ _id: 'Thriller', count: Long('2400') },
24	{ _id: 'Action', count: Long('2349') },
25	{ _id: 'Adventure', count: Long('1876') },
26	{ _id: 'Documentary', count: Long('1755') },
27	{ _id: 'Horror', count: Long('1432') },
28	{ _id: 'Biography', count: Long('1244') }
29	]
30	}
31	}
32	}
33	}
34	]

1	db.companies.aggregate([
2	{
3	"$searchMeta": {
4	"returnStoredSource": true,
5	"returnScope": {
6	"path": "funding_rounds"
7	},
8	"facet": {
9	"operator": {
10	"text": {
11	"path": "funding_rounds.raised_currency_code",
12	"query": "USD"
13	}
14	},
15	"facets": {
16	"raisedAmountFacet": {
17	"type": "number",
18	"path": "funding_rounds.raised_amount",
19	"boundaries": [5000000, 5250000, 5500000]
20	}
21	}
22	}
23	}
24	}
25	])

1	[
2	{
3	count: { lowerBound: Long('5329') },
4	facet: {
5	raisedAmountFacet: {
6	buckets: [
7	{ _id: 5000000, count: Long('251') },
8	{ _id: 5250000, count: Long('32') }
9	]
10	}
11	}
12	}
13	]

1	[
2	{
3	count: { lowerBound: Long('3') },
4	facet: {
5	roundFacet: {
6	buckets: [
7	{ _id: 'b', count: Long('3') },
8	{ _id: 'a', count: Long('1') },
9	{ _id: 'seed', count: Long('1') }
10	]
11	}
12	}
13	}
14	]

1	db.listingsAndReviews.aggregate([
2	{
3	$searchMeta: {
4	facet: {
5	facets: {
6	accommodatesFacet: {
7	path: "accommodates",
8	type: "number",
9	boundaries: [1,2,4,8]
10	},
11	cancellationFacet: {
12	path: "cancellation_policy",
13	type: "string"
14	},
15	roomTypeFacet: {
16	path: "room_type",
17	type: "string"
18	}
19	},
20	operator: {
21	compound: {
22	must: [
23	{
24	text: {
25	path: "description",
26	query: "new york city"
27	},
28	},
29	],
30	filter: [
31	{
32	equals: {
33	path: "cancellation_policy",
34	value: "moderate",
35	doesNotAffect:
36	"cancellationFacet"
37	}
38	}
39	]
40	}
41	}
42	}
43	}
44	}
45	])

1	[
2	{
3	count: { lowerBound: Long('531') },
4	facet: {
5	accommodatesFacet: {
6	buckets: [
7	{ _id: 1, count: Long('25') },
8	{ _id: 2, count: Long('270') },
9	{ _id: 4, count: Long('204') }
10	]
11	},
12	cancellationFacet: {
13	buckets: [
14	{ _id: 'strict_14_with_grace_period', count: Long('849') },
15	{ _id: 'moderate', count: Long('531') },
16	{ _id: 'flexible', count: Long('380') },
17	{ _id: 'super_strict_60', count: Long('25') },
18	{ _id: 'super_strict_30', count: Long('11') }
19	]
20	},
21	roomTypeFacet: {
22	buckets: [
23	{ _id: 'Entire home/apt', count: Long('369') },
24	{ _id: 'Private room', count: Long('159') },
25	{ _id: 'Shared room', count: Long('3') }
26	]
27	}
28	}
29	}
30	]

facet (MongoDB Search 연산자)

정의

구문

필드

메모리 요구 사항

패싯 정의

문자열 패싯

구문

옵션

예시

숫자 패싯

구문

옵션

예시

날짜 패싯

구문

옵션

예시

패싯의 필드 유형 비교

내장된 문서 배열의 일치하는 하위 항목에 대한 패싯

패싯 집계

구문

옵션

지표 유형

배열 고려 사항

중첩 패싯

패싯 결과

다중 선택 패싯

SEARCH_META 집계 변수

제한 사항

임베디드 범위 패싯에 대한 제한 사항

패싯 집계에 대한 제한 사항

예시

메타데이터 결과 예시튜토리얼의 이전 단계를 완료한 후 종속성을 설치합니다.

메타데이터 및 검색 결과 예시$검색를 사용하여 검색하고 $$검색_META 변수를 사용하여 검색 결과와 메타데이터 결과를 모두 조회합니다.

returnScope 예시embeddedDocuments의 자식 필드에 대한 패싯과 패싯을 사용하여 검색합니다.

임베디드 범위 패싯 예시embeddedDocuments 배열의 일치하는 하위 항목에만 패싯을 적용합니다.

다중 선택 패싯 예시패싯 필터링을 보다 세분화하여 제어하려면 dosNotAffect로 검색하세요.

패싯 간 필터 제외 예시쿼리된 필드 이외의 다른 패싯에서 doesNotAffect를 사용하여 검색합니다.

집계 예시패싯 집계를 사용하여 검색합니다.

중첩 패싯 예시중첩 패싯으로 검색합니다.

학습 계속하기

교육 과정으로 배우기

보면서 배우기

`facet` (MongoDB Search 연산자)

`SEARCH_META` 집계 변수