`facet` (MongoDB Search 연산자)

정의

facet

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

facet을(를) $search, $searchMeta 단계 모두에 사용할 수 있습니다. MongoDB는 facet을(를) $searchMeta 단계와 함께 사용하여 쿼리에 대한 메타데이터 결과만 검색할 것을 권장합니다. 메타데이터 결과와 쿼리 결과를 $search 단계를 사용하여 검색하려면 $$SEARCH_META 집계 변수를 사용해야 합니다. SEARCH_META 집계 변수를 참조하세요.

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

객체 배열 내에 중첩 필드, returnScope 예시를 참조하세요.
embeddedDocument을 사용하여 embeddedDocuments 배열의 하위 항목을 일치시키는 방법은 Embedded-Scoped 패싯 예시를 참조하세요.
루트 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`	문서	네	각 패싯의 데이터를 버킷에 넣기 위한 정보 입니다. 패싯 정의는 하나 이상 지정해야 합니다. 각 패싯 정의는 각 버킷에 대한 지표를 계산하기 위해 패싯 집계를 지정할 수도 있습니다.
`operator`	문서	no	패싯 을 수행하는 데 사용하는 연산자입니다. 생략하면 MongoDB Search는 컬렉션 의 모든 문서에 대해 패싯 을 수행합니다.

메모리 요구 사항

패싯 쿼리는 클러스터 계층에 관계없이 메모리 집약적입니다. 패싯 집계 또는 중첩 패싯을 지정하는 쿼리는 다른 패싯 쿼리보다 더 많은 메모리와 디스크를 필요로 합니다. 프로덕션에서 패싯을 사용하기 전에 클러스터에 워크로드에 충분한 메모리가 있는지 확인하세요. 자세히 알아보려면 검색 메모리 관리를 참조하세요. 워크로드에 대한 크기 조정 지침을 받으려면 지원팀에 요청.

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

중첩된 패싯의 경우, 쿼리에서 계산된 총 고유 값은 각 중첩 수준의 고유 값을 기준으로 곱해집니다. 각 개별 필드의 카디널리티가 낮더라도 중첩된 경로에 걸친 값의 조합은 많은 수의 고유 버킷을 생성할 수 있습니다. 중첩된 패싯이 버킷을 곱하는 방법에 대해 자세히 알아보려면 중첩된 패싯을 참조하세요.

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`	객체	쿼리 조건자와 일치하는 `embeddedDocuments` 배열의 하위 문서로만 패싯의 버킷 수를 범위로 지정합니다. 자세한 내용은 내장된 문서 배열의 일치하는 하위 문서에 대한 패싯을 참조하세요.	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`	숫자 배열	버킷의 경계를 지정하는 오름차순의 숫자 값 목록입니다. 경계 값은 2개에서 10,000개(`[2, 10000]`)사이로 지정해야 합니다. 각 인접한 값 쌍은 포과적 하한과 배타적 상한을 갖는 버킷을 정의합니다. 다음 BSON types:의 값을 원하는 대로 조합하여 지정할 수 있습니다. 32비트 정수 (`int32`) 64비트 정수 (`int64`) 64비트 이진 부동 소수점(`double`)	네
`default`	문자열	지정된 경계에 속하지 않는 연산자 로부터 반환된 문서를 계산하는 추가 버킷의 이름입니다. 생략하면 MongoDB Search는 지정된 버킷에 속하지 않는 패싯 연산자 의 결과도 포함하지만 버킷 수에는 포함하지 않습니다.	no
`embeddedDocument`	객체	쿼리 조건자와 일치하는 `embeddedDocuments` 배열의 하위 문서로만 패싯의 버킷 수를 범위로 지정합니다. 자세한 내용은 내장된 문서 배열의 일치하는 하위 문서에 대한 패싯을 참조하세요.	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`	객체	쿼리 조건자와 일치하는 `embeddedDocuments` 배열의 하위 문서로만 패싯의 버킷 수를 범위로 지정합니다. 자세한 내용은 내장된 문서 배열의 일치하는 하위 문서에 대한 패싯을 참조하세요.	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`의 하위 항목이어야 합니다.	네

숫자 또는 날짜 패싯의 경우, 문서 인덱스 패싯과 동일한 규칙을 사용하여 default 버킷을 지정하면 해당 값이 구성된 boundaries 범위를 벗어나는 일치하는 하위 항목이 해당 버킷에 포함됩니다. 일치하는 하위 문서가 없는 루트 문서는 embeddedDocument범위의 패싯에는 기여하지 않지만, 동일한 쿼리에 있는 다른 범위가 지정되지 않은 패싯에는 여전히 기여할 수 있습니다.

중요

embeddedDocument범위의 패싯은 다른 여러 패싯 옵션과 결합할 수 없습니다. 자세한 내용은 제한 사항을 참조하세요.

예시는 Embedded-Scoped 패싯 예시.을 참조하세요.

패싯 집계

중요

패싯 집계는 미리 보기로 제공됩니다. 기능 및 관련 문서는 미리보기 기간 동안 언제든지 변경될 수 있습니다. 자세한 내용은 미리보기 기능을 참조하세요.

각 패싯 버킷에 대한 지표를 계산하려면 패싯 정의에 aggregations 문서를 추가합니다. MongoDB Search는 MongoDB Search 인덱스에서 지표를 계산하므로 파이프라인 뒷부분에서 $group 단계를 실행하는 것보다 훨씬 효율적입니다.

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

합계
평균
minimum
maximum
first
last

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

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

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

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

참고

메모리 요구 사항

aggregations 또는 중첩 패싯을 지정하는 패싯 쿼리는 다른 패싯 쿼리에 필요한 것보다 더 많은 메모리와 디스크를 MongoDB Search 인덱스에 요구합니다. 자세한 내용은 메모리 요구 사항을 참조하세요.

구문

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` 각 지표 유형에 대해 자세히 알아보려면 지표 유형을 참조하세요.	네

지표 유형

유형	필드 요구 사항	설명
`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 지표를 추가하고 예상되는 문서 수와 비교하십시오.

MongoDB Search가 건너뛰지 않는 값의 경우, min은 버킷에서 가장 작은 값을 선택하고 max은 가장 큰 값을 선택합니다. 값의 유형이 모두 동일하지 않은 경우, MongoDB Search는 BSON 유형 비교 순서를 적용하여 가장 작거나 큰 값을 결정합니다.

배열 고려 사항

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

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 (으)로 설정합니다.

중첩 패싯

중요

중첩 패싯은 미리보기 상태입니다. 해당 기능과 관련 문서는 미리보기 기간 동안 언제든지 변경될 수 있습니다. 자세한 내용은 미리보기 기능을 참조하세요.

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을(를) 경로로 사용하는 패싯의 이름을 지정합니다.

참고

doesNotAffect 옵션은 집계를 지정하는 패슷과 함께 작동하지 않습니다. 자세한 내용은 제한 사항을 참조하세요.

예시

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

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

doesNotAffect을(를) embeddedDocument범위의 패싯과 결합할 수 없습니다. 자세한 내용은 내장된 문서 배열의 일치하는 하위 항목에 대한 패싯을 참조하세요.

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

예시

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

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

`SEARCH_META` 집계 변수

$search 단계를 사용하여 쿼리를 실행하면 MongoDB Search는 메타데이터 결과를 $$SEARCH_META 변수에 저장하고 검색 결과만 반환합니다. 지원되는 모든 집계 파이프라인 단계에서 $$SEARCH_META 변수를 사용하여 $search 쿼리에 대한 메타데이터 결과를 볼 수 있습니다. $$SEARCH_META 변수를 패싯.집계.와 함께 사용할 수도 있습니다.

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

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

제한 사항

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

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

다음 제한은 내장된 문서 배열의 일치하는 하위 요소에 대한 패싯:에 적용됩니다.

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

패싯 집계에 대한 제한 사항

패싯 집계:에는 다음과 같은 제한 사항이 적용됩니다.

aggregations에서는 다음 옵션을 사용할 수 없습니다.
- returnScope
- doesNotAffect 다중 선택 패싯의 경우
다음 BSON types에 대해서는 패싯을 지정하거나 집계를 계산할 수 없습니다.
- binData
- bool
- decimal
- null
- objectId
- timestamp
이러한 유형에 대해 지표를 계산하려면 뷰를 사용하여 필드를 인덱싱하기 전에 지원되는 유형으로 변환하세요.

예시

다음 예시에서는 샘플 데이터를 사용합니다. 메타데이터 결과 예시에서는 $searchMeta 을 사용하여 쿼리를 facet 실행해 결과에서 메타데이터만 조회하는 방법을 보여 줍니다. 메타데이터 및 검색 결과 예시에서는 $search 쿼리를 facet 및 $SEARCH_META 집계 변수를 사용하여 검색 및 메타데이터 결과를 모두 조회하는 방법을 보여 줍니다. returnScope 예시는 embeddedDocuments 유형을 사용하여 동적으로 인덱싱된 객체 배열의 중첩 필드에 대해 패싯을 적용하는 방법을 보여줍니다. 임베디드 범위 패싯 예시는 embeddedDocuments 배열의 일치하는 하위 항목에 대해서만 패싯을 적용하는 방법을 보여줍니다. 다중 선택 및 패싯 간 필터 제외 예시는 doesNotAffect를 사용하여 패싯이 서로의 개수에 영향을 미치는 방식을 제어하는 방법을 보여줍니다. 집계 예시는 각 패싯 버킷에 대한 지표를 계산하는 방법을 보여주고, 중첩 패싯 예시는 결과를 두 번째 필드로 그룹화하고 각 버킷에 대한 지표를 계산하는 방법을 보여줍니다.

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

다음 쿼리는 $search 단계를 사용하여 1999년 7월 01일 경에 개봉된 영화를 검색합니다. 쿼리에는 다음 하위 파이프라인 단계를 사용하여 입력 문서를 처리하는 $facet 단계가 포함됩니다.

$project 단계에서 docs 출력 필드의 title 및 released 필드를 제외한 문서의 모든 필드를 제외합니다.
$limit 단계를 사용하여 다음을 수행합니다.
- $search 단계 출력을 2개 문서로 제한합니다.
- meta 출력 필드에 있는 1개 문서로 출력을 제한합니다.
참고
결과를 16MB 문서에 맞추려면 제한이 작아야 합니다.
$replaceWith 스테이지를 사용하여 $$SEARCH_META 변수에 저장된 메타데이터 결과를 meta 출력 필드에 포함시킵니다.

쿼리에는 meta 필드를 추가하는 $set 단계도 포함되어 있습니다.

참고

다음 쿼리 에 대한 메타데이터 결과 를 보려면 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 검색에서 패싯을 사용하는 방법을 참조하세요.

교육 과정과 동영상을 통해 MongoDB Search의( MongoDB Search facet 연산자)에 대해자세히 학습 수 있습니다.

교육 과정으로 배우기

MongoDB Search에서 패싯을 사용하는 방법에 대해 자세히 학습하려면 MongoDB University 의 Intro To MongoDB 과정의 단원 9 을 수강하세요. 1.5 시간 단위로, MongoDB Search에 대한 개요와 MongoDB Search 인덱스 만들기, 복합 연산자를 사용한 $search 쿼리 실행, facet를 사용한 결과 그룹화에 대한 강의가 포함되어 있습니다.

보면서 배우기

이 동영상을 보고 쿼리에서 숫자와 string facet (MongoDB Search 연산자) 를 만들고 사용하여 결과를 그룹하고 그룹 내 결과의 개수를 조회하는 방법을 학습합니다.

소요 시간: 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 집계 변수

제한 사항

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

패싯 집계에 대한 제한 사항

예시

Metadata Results ExampleComplete the previous steps in the tutorial and install dependencies

Metadata and Search Results ExampleSearch using $search and retrieve both search and metadata results using $$SEARCH_META variable.

returnScope ExampleSearch using facet and facet on child fields in embeddedDocuments.

Embedded-Scoped Facet ExampleFacet on only the matching children of an embeddedDocuments array.

Multi-Select Faceting ExampleSearch with doesNotAffect for more granular control over facet filtering.

Inter-Facet Filter Exclusion ExampleSearch with doesNotAffect on a facet other than the queried field.

Aggregation ExampleSearch with facet aggregations.

Nested Facet ExampleSearch with nested facets.

학습 계속하기

교육 과정으로 배우기

보면서 배우기

`facet` (MongoDB Search 연산자)

`SEARCH_META` 집계 변수