/ /

Referência de query

Operadores e coletores

Página inicial do Docs

Desenvolvimento

Pesquisa

Queries e índices

Referência de query

Operadores e coletores

`facet` ( Operador de pesquisa MongoDB )

Definição

facet

O coletor facet agrupa resultados por valores ou intervalos nos campos facetados especificados e retorna a contagem para cada um desses grupos.

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.

Se você definir storedSource na definição do tipo de campo embeddedDocuments, poderá usar returnScope com returnStoredSource para fazer facetas em campos aninhados dentro de um array de objetos. Caso contrário, você só poderá fazer facetas no campo-raiz do tipo embeddedDocuments. Para um exemplo de facetas em:

Campos aninhados dentro de um array de objetos, veja Exemplo de returnScope.
Matching children of an embeddedDocuments array using embeddedDocument, see Embedded-Scoped Facet Example.
Tipo de campo embeddedDocuments da raiz, consulte Query de faceta.

Sintaxe

facet tem a seguinte sintaxe:

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

Campos

Campo	Tipo	Obrigatório?	Descrição
`facets`	documento	sim	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`	documento	no	Operador para usar para executar a faceta . Se omitido, o MongoDB Search executa a faceta sobre todos os documentos na coleção.

Requisitos de memória

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.

The memory that a facet query requires depends on the number of unique values in the field that you facet on, not the number of buckets that you request using numBuckets or boundaries. For example, a facet that requests 20 buckets on a field with five million unique values still counts every unique value to determine the top 20 buckets.

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 tracks bucket counts separately for each query, so total memory use scales with the number of concurrent facet queries. On a sharded cluster, MongoDB Search also requires memory to merge the buckets from each shard, which scales with the number of shards and the number of buckets.

Definição de Facet

O documento de definição do faceta contém o nome do faceta e as opções específicas para um tipo de faceta. A pesquisa do MongoDB suporta os seguintes tipos de facetas:

Facets de String
Facets Numéricos
Facetas de data

Facets de String

Importante

stringFacet agora está desatualizado. Em vez disso, use o token, que fornece faceta aprimorada.

Para aprender mais sobre as diferenças entre os tipos de campo atualizados e desatualizados para faceta, consulte Comparando Tipos de Campo para Faceta.

String facets allow you to narrow down MongoDB Search results based on the most frequent string values in the specified string field. The string field must be indexed as token. To facet on string fields in embedded documents, you must also index the parent fields as the document type. When you facet on strings in arrays or embedded documents, MongoDB Search returns facet counts based on the number of matching root documents.

Sintaxe

Os facets de string têm a seguinte sintaxe:

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

Opções

Opção	Tipo	Descrição	Obrigatório?
`embeddedDocument`	objeto	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	Maximum number of facet categories to return in the results. Value must be less than or equal to `10000`. If specified, MongoDB Search may return fewer categories than requested if the data is grouped into fewer categories than your requested number. If omitted, defaults to `10`, which means that MongoDB Search returns only the top `10` facet categories by count.	no
`path`	string	Caminho do campo para a faceta. Você pode especificar um campo que é indexado como um token.	sim
`type`	string	Tipo de facet. O valor deve ser `string`.	sim

Exemplo

O exemplo a seguir usa um índice chamado default na coleção sample_mflix.movies. O campo genres na coleção é indexado como o tipo token e o campo year é indexado como o tipo número.

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

A query utiliza o estágio $searchMeta para pesquisar o campo year na coleção movies para filmes de 2000 a 2015 e recuperar uma contagem do número de filmes em cada gênero.

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 ]

Para saber mais sobre esses resultados, consulte Resultados de faceta.

Facets Numéricos

Importante

numberFacet agora está desatualizado. Em vez disso, use o número, que fornece faceta melhorada.

Para aprender mais sobre as diferenças entre os tipos de campo atualizados e desatualizados para faceta, consulte Comparando Tipos de Campo para Faceta.

As facets numéricas permitem determinar a frequência dos valores numéricos nos resultados da pesquisa, dividindo os resultados em intervalos separados de números. Quando você faceta números em arrays ou documentos incorporados, o MongoDB Search retorna contagens de faceta com base no número de documentos raiz correspondentes.

Sintaxe

Os facets numéricos têm a seguinte sintaxe:

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

Opções

Opção	Tipo	Descrição	Obrigatório?
`boundaries`	array de números	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: Inteiro de `int32` bits () Inteiro de 64 bits (`int64`) Ponto flutuante binário de 64 bits (`double`	sim
`default`	string	Nome de um compartimento adicional que conta os documentos retornados do operador que não se enquadram nos limites especificados. Se omitido, a Pesquisa do MongoDB também inclui os resultados do operador de faceta que não se enquadram em um bucket especificado, mas não o inclui em nenhuma contagem de bucket.	no
`embeddedDocument`	objeto	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`	string	Caminho do campo para a faceta. Você pode especificar um campo que é indexado como o tipo número.	sim
`type`	string	Tipo de facet. O valor deve ser `number`.	sim

Exemplo

O exemplo a seguir usa um índice chamado default na coleção sample_mflix.movies. O campo year na coleção é indexado como o tipo número.

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

The query uses the $searchMeta stage to search the year field in the movies collection for movies between the years 1980 and 2000 and retrieve metadata results for the query. The query specifies three buckets:

1980, limite inferior inclusivo para este bucket
1990, limite superior exclusivo para o bucket 1980 e limite inferior inclusivo para este bucket
2000, limite superior exclusivo para o bucket 1990

A query também especifica um bucket de default chamado other para recuperar resultados da query que não se enquadram em nenhum dos limites especificados.

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 ]

Para saber mais sobre esses resultados, consulte Resultados de faceta.

Facetas de data

Importante

dateFacet agora está desatualizado. Em vez disso, use a data, que fornece faceta melhorada.

Para aprender mais sobre as diferenças entre os tipos de campo atualizados e desatualizados para faceta, consulte Comparando Tipos de Campo para Faceta.

As facets de datas permitem restringir resultados de pesquisa com base em uma data. Quando você faceta datas em arrays ou documentos incorporados, o MongoDB Search retorna contagens de faceta com base no número de documentos raiz correspondentes.

Sintaxe

Os facets de data têm a seguinte sintaxe:

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

Opções

Opção	Tipo	Descrição	Obrigatório?
`boundaries`	array de números	Lista de valores de data que especificam os limites para cada bucket. Você deve especificar: Pelo menos dois limites, que são menores ou iguais a dez mil (`[2, 10000]`) Valores em ordem crescente, com a data mais antiga primeiro Cada par adjacente de valores atua como o limite inferior inclusivo e o limite superior exclusivo para o bucket.	sim
`default`	string	Nome de um compartimento adicional que conta os documentos retornados do operador que não se enquadram nos limites especificados. Se omitido, o MongoDB Search incluirá os resultados do operador de faceta que também não se enquadram em um bucket especificado, mas o MongoDB Search não incluirá esses resultados em nenhuma contagem de bucket.	no
`embeddedDocument`	objeto	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`	string	Caminho do campo para a faceta. Você pode especificar um campo que é indexado como um tipo de data.	sim
`type`	string	Tipo de facet. O valor deve ser `date`.	sim

Exemplo

O exemplo a seguir usa um índice chamado default na coleção sample_mflix.movies. O campo released na coleção é indexado como tipo data.

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

The query uses the $searchMeta stage to search the released field in the movies collection for movies between the years 2000 and 2015 and retrieve metadata results for the query. The query specifies four buckets:

2000-01-01, limite inferior inclusivo para este bucket
2005-01-01, limite superior exclusivo para o bucket 2000-01-01 e limite inferior inclusivo para este bucket
2010-01-01, limite superior exclusivo para o bucket 2005-01-01 e limite inferior inclusivo para este bucket
2015-01-01, limite superior exclusivo para o bucket 2010-01-01

A query também especifica um bucket de default chamado other para recuperar resultados da query que não se enquadram em nenhum dos limites especificados.

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 ]

Para saber mais sobre esses resultados, consulte Resultados de faceta.

Comparação de tipos de campo para faceta

Os tipos de campo de pesquisa atualizados do MongoDB fornecem funcionalidade aprimorada para suporte a faceta em comparação com os tipos desatualizados (stringFacet, numberFacet, dateFacet). A tabela a seguir descreve as principais diferenças na funcionalidade:

Categoria faceta	Tipo de campo atualizado	Tipo de faceta desatualizado	Principais diferenças
String	token	stringFacet (desatualizado)	Suporte a normalizador: o tipo `token` oferece suporte a normalizadores que transformam buckets de faceta . Por exemplo, com `normalizer: lowercase`, "ADVIDAS" e "adidas" contam para o mesmo bucket, enquanto `stringFacet` os trata como buckets separados.
Numérico	número	numberFacet (desatualizado)	Suporte a array: o tipo `number` considera valores dentro de arrays para buckets de faceta. Por exemplo, um documento com um valor de array `[0, 10]` conta para os buckets `[1, 5]` e `[6, 10]`, enquanto `numberFacet` ignora completamente os valores de array.
Data	data	dateFacet (desatualizado)	Suporte a array: o tipo `date` considera valores dentro de arrays para buckets de faceta. Por exemplo, um valor de array com datas pode contribuir para várias faixas de intervalo de datas, enquanto o `dateFacet` ignora completamente os valores de array.

Observação

Quando os tipos de campo desatualizados e atualizados são definidos para o mesmo campo, os tipos de faceta desatualizados têm precedência. Por exemplo, se token e stringFacet forem definidos para um campo, o cálculo de faceta usará o mapeamento stringFacet .

Facet on Matching Children of an Embedded Documents Array

Each facet definition can include an optional embeddedDocument field that scopes the facet's bucket counts to only the child documents in an embeddedDocuments array that match a query predicate. If you omit the embeddedDocument field, the facet is document-indexed.

Without embeddedDocument, a root document counts in a bucket if it has any child document that falls into that bucket, even if that child doesn't match the query defined in the facet.operator block. The embeddedDocument field restricts bucket contributions to only the children that match the specified embeddedDocument.operator. It counts each root document at most once per bucket.

The embeddedDocument field takes the following fields:

Campo	Tipo	Descrição	Obrigatório?
`path`	string	Indexed `embeddedDocuments` type field to scope the facet into. The facet's `path` must be a descendant of this field.	sim
`operator`	objeto	Operator to run against each child document in the `embeddedDocuments` array that you specify in `path`. Only child documents that match this operator contribute to the facet's bucket counts. Every path referenced in this operator must be a descendant of `path`.	sim

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.

Importante

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

Importante

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.

For each facet bucket, aggregations allows you to compute the following values:

soma
média
minimum
maximum
primeiro
último

When using aggregations, you must:

Index the field that you specify in the path for each metric as token, number, or date.
Explicitly include the count metric if you want the bucket count.
Only specify aggregations at the leaf-level of nested facets.

If you want to compute metrics for an intermediate grouping, specify that grouping as a separate top-level facet with aggregations and no nested facet.

MongoDB Search computes aggregations over the data in the MongoDB Search index, which is eventually consistent.

Observação

Requisitos de memória

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.

Sintaxe

aggregations tem a seguinte sintaxe:

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

Each key in the aggregations document is an aggregation name that you specify. MongoDB Search returns each aggregation in the bucket documents under the name that you specify.

Opções

Opção	Tipo	Descrição	Obrigatório?
`path`	string	Field path to compute the metric over. This is required for all metric types except `count`, which doesn't accept a `path`. Every other metric type computes a value from a second field, so you must name that field. For example, to return the average rating of the documents in a bucket, specify `avg` with a `path` of `rating`. The `count` metric counts the documents in the bucket, so it doesn't need a second field.	condicional
`type`	string	Type of metric to compute. Value can be one of the following: `count` `sum` `avg` `min` `max` `first` `last` To learn more about each metric type, see Metric Types.	sim

Metric Types

Tipo	Field Requirements	Descrição
`count`	none	Counts the documents in the bucket. Don't specify a `path` for this metric type. If you omit `aggregations` from a facet definition, MongoDB Search returns a `count` metric for the bucket. If you specify `aggregations`, MongoDB Search returns a `count` metric only if you specify `count` in the `aggregations` document.
`sum`	número	Adds the values of the specified field for the documents in the bucket.
`avg`	número	Returns the average of the values of the specified field for the documents in the bucket. If no document in the bucket has a value for the field, MongoDB Search returns `null`.
`min`	none	Returns the lowest value of the specified field for the documents in the bucket.
`max`	none	Returns the highest value of the specified field for the documents in the bucket.
`first`	none	Returns the value of the specified field for the first document in the bucket, according to the order that the query sort option defines. If the query doesn't specify a sort, the order is arbitrary. To learn how to specify a sort, see Sort MongoDB Search Results.
`last`	none	Returns the value of the specified field for the last document in the bucket, according to the order that the query sort option defines. If the query doesn't specify a sort, the order is arbitrary. To learn how to specify a sort, see Sort MongoDB Search Results.

Importante

min and max support all field types, including token. When MongoDB Search computes these metrics, it skips any document in which the field resolves to an unsupported type. MongoDB Search doesn't return an error when it skips a document. To determine whether MongoDB Search skipped documents in a bucket, add a count metric to the same aggregations document and compare it to the number of documents that you expect.

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.

Considerações sobre arrays

Each metric type handles a field that resolves to more than one value, such as an array, differently:

sum and avg skip the document.
min and max select the lowest and highest value in the array to use as a representative element for the document.
first and last return all of the values as an array.

For first and last, the returned array differs from the source document in the following ways:

The order of the values might differ. MongoDB Search reads the values from the index, which doesn't preserve the order of the source document. For example, if a document contains ["red", "blue", "green"], MongoDB Search might return ["blue", "green", "red"].
MongoDB Search returns only one instance of a duplicate value.
MongoDB Search returns every value at the path, including values of a type that you can't facet on. For example, if an array contains both strings and a boolean, MongoDB Search returns the boolean with the strings.

To return the values exactly as the source document contains them, define storedSource for the field in your index definition and set returnStoredSource to true in your query.

Nested Facets

Importante

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. You can nest facets without limit on the number of levels. However, the following restrictions apply:

You can specify aggregations only on a leaf facet in a nested facet tree. A facet definition that specifies facets can't also specify aggregations. To compute metrics for an intermediate grouping, specify that grouping as a separate top-level facet with aggregations and no nested facet.
The total number of unique buckets that a query can return can't exceed 100000. To calculate the buckets that one facet tree produces, multiply the number of buckets at each level of its nesting branch. The number of buckets at a level is numBuckets for a string facet or the number of buckets that boundaries and default define for a number or date facet. For example, a facet that requests 20 buckets and contains a nested facet that requests 20 buckets produces 400 unique buckets. Because each level multiplies this total, requesting more buckets at each level reduces the number of levels that you can nest.

Resultados de facet

Para uma query de faceta , o MongoDB Search retorna um mapeamento dos nomes de faceta definidos para uma array de compartimentos para essa faceta nos resultados. O documento de resultado do faceta contém a opção buckets, que é uma array de buckets resultantes para o faceta. Cada documento de bucket de faceta na array tem os seguintes campos:

Opção	Tipo	Descrição
`_id`	objeto	Identificador único que identifica este bucket de facet. Este valor corresponde ao tipo de dados que está sendo facetado.
`count`	int	Contagem de documentos nesse bucket de faceta . Para saber mais sobre o campo `count`, consulte Resultados da pesquisa do MongoDB Search.

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 facet field with the results for the nested facet.

Facetas de seleção múltipla

O MongoDB Search permite visualizar e selecionar vários buckets dentro da mesma faceta simultaneamente. Normalmente, selecionar um bucket dentro de uma faceta filtra os resultados da pesquisa de acordo com essa seleção e altera as contagens de todas as facetas.

Exemplo

Suponha que uma definição de índice para a coleção sample_airbnb.listings especifique facetas para os seguintes campos:

cancellation_policy
room_type
accommodates

O faceta cancellation_policy tem os seguintes buckets:

flexible
moderate
strict_14_with_grace_period
super_strict_30
super_strict_60

Each bucket has its own result count. When you search for the moderate cancellation_policy, the counts for the four other buckets go to 0. Additionally, the counts for buckets in the room_type and accommodates facets reduce to the number of results in each bucket that also have a flexible cancellation_policy.

Em cenários em que você precise de um controle mais granular de como os facets afetam as contagens de resultados da pesquisa, habilite o facet de seleção múltipla com a propriedade doesNotAffect em suas queries facetadas. Essas facetas ainda filtram resultados, mas a query não altera suas contagens de resultados.

You can specify doesNotAffect in the following operators:

To exclude multiple facets, specify an array of facet names. Most use cases exclude only the facet that shares a path with the filter. For example, an equals filter on the rating field specifies the name of the facet that uses rating as its path.

Observação

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

Exemplo

Consider a query against the sample_airbnb.listingsAndReviews collection for documents with a moderate cancellation_policy. If you specify a doesNotAffect value of cancellation_policy, the counts for buckets in the cancellation_policy facet don't change, but the result counts for the buckets of other facets reduce to the number of results in each bucket that also have a moderate cancellation_policy.

Para obter mais informações, consulte o exemplo de faceta de Multi-Select.

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

Por fim, para casos de uso com muitas facetas, você pode limitar quais outros filtros afetam uma determinada faceta. Você pode fazer isso especificando qualquer faceta na propriedade doesNotAffect de qualquer filtro, inclusive facetas em outros campos. Isso permite que você observe de relance quais seleções restringem as opções mais ou menos rapidamente.

Exemplo

Consider a query against the sample_airbnb.listingsAndReviews collection for documents with an accommodates value of 3. If you specify a doesNotAffect value of cancellation_policy, the result counts for the room_type buckets reduce to the number of results in each bucket that also accommodate 3 people, but the result counts for the buckets in cancellation_policy are unaffected.

Para mais informações, consulte o Exemplo de exclusão de filtro inter-faceta.

`SEARCH_META` Variável de agregação

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.

O MongoDB recomenda utilizar a variável $$SEARCH_META somente se você precisar dos resultados da pesquisa e dos resultados de metadados. Caso contrário, use o:

$search estágio apenas para os resultados da pesquisa.
$searchMeta estágio apenas para os resultados dos metadados.

Limitações

Você pode executar queries de facets somente em um único campo. Não é possível executar queries de atributos em grupos de campos.

Limitations for Embedded-Scoped Facets

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

You can't combine a top-level returnScope option with an embeddedDocument-scoped facet in the same query.
An embeddedDocument-scoped facet returns only a count.
You can't combine drill-sideways faceting (doesNotAffect) with an embeddedDocument-scoped facet in the same query.

Limitations for Facet Aggregations

The following limitations apply to Facet Aggregations:

You can't use the following options with 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.

Exemplos

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.

Exemplo de resultados de metadados

Conclua as etapas anteriores do tutorial e instale as dependências

A definição do índice na coleção sample_mflix.movies especifica o seguinte para os campos a serem indexados:

Nome do campo	Tipo de Dados
`directors`	token
`year`	número
`released`	data

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

The following query searches for movies released between January 01, 2000 and January 31, 2015. It requests metadata on the directors and year fields.

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 ]

Os resultados mostram uma contagem dos seguintes itens na collection sample_mflix.movies:

Número de filmes do ano 2000, limite inferior inclusivo, até 2015, limite superior excluindo, que a Pesquisa MongoDB retornou para a query
Número de filmes para cada diretor que a Pesquisa MongoDB retornou para a consulta

Para saber mais sobre esses resultados, consulte Resultados de faceta.

Exemplo de metadados e resultados de pesquisa

Pesquise usando $search e recupere resultados de pesquisa e metadados usando a variável $$SEARCH_META.

A definição do índice na coleção sample_mflix.movies especifica o seguinte para os campos a serem indexados:

Nome do campo	Tipo de Dados
`genres`	token
`released`	data

{
  "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 estágio para fazer o seguinte:
- Limite a saída do estágio $search a 2 documentos
- Limite a saída ao documento 1 no campo de saída meta.
Observação
O limite deve ser pequeno para que os resultados caibam em um documento de 16 MB .
$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.

Observação

Para ver os resultados de metadados da seguinte query, o MongoDB Search deve retornar documentos que correspondam à query.

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 ]

Para saber mais sobre esses resultados, consulte Resultados de faceta.

Exemplo de returnScope

Faça pesquisa usando faceta e aplique faceta em campos secundários em embeddedDocuments.

A definição de índice na coleção sample_training.companies indexa o campo funding_rounds como o tipo embeddedDocuments. Ele indexa dinamicamente todos os campos do array funding_rounds de objetos e armazena os campos raised_currency_code e raised_amount no array funding_rounds de objetos usando a opção storedSource.

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

A seguinte query:

Uses the text (MongoDB Search Operator) to search for funds raised in USD.
Usa as opções returnScope para definir o contexto da query para o campo embeddedDocuments chamado funding_rounds. Para usar returnScope, a query:
- Especifica a opção returnStoredSource, que é necessária, para retornar os campos de origem armazenados.
Facetas no campo raised_amount no array funding_rounds de objetos. A query especifica três buckets:
- 5000000, limite inferior inclusivo para este bucket
- 5250000, limite superior exclusivo para o bucket 5000000 e limite inferior inclusivo para esse bucket
- 5500000, limite superior exclusivo para o bucket 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 ]

Nos resultados anteriores da MongoDB Search, as contagens de facetas são baseadas nos documentos secundários incorporados e não nos principais.

Embedded-Scoped Facet Example

Facet on only the matching children of an embeddedDocuments array.

The index definition on the sample_training.companies collection indexes the funding_rounds field as the embeddedDocuments type, with the round_code and raised_currency_code fields in each funding round indexed as 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, and StumbleUpon each have several funding rounds, only some of which were raised in 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 }
  ]
}

The following query uses the in operator to restrict the facet to these three companies, then facets on funding_rounds.round_code. The roundFacet definition specifies an embeddedDocument block that scopes the facet to only the funding rounds where raised_currency_code is USD.

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 ]

Each company counts once per round code for which it has at least one funding round raised in USD:

b counts 3: KickApps, Topix, and StumbleUpon each have a b round raised in USD.
a counts 1: only KickApps has an a round raised in USD. Topix's and StumbleUpon's a rounds have no recorded currency, so they don't match.
seed counts 1: StumbleUpon's seed round was raised in USD.

KickApps' c round doesn't contribute to a c bucket because it was raised in GBP, not USD. Without the embeddedDocument block, faceting on funding_rounds.round_code requires indexing funding_rounds as the document type instead, and an unscoped facet would also count KickApps in a c bucket, because the root document has a matching child in that bucket regardless of its currency.

Exemplo de faceta de seleção múltipla

Pesquise com DoesNotAffect para obter um controle mais granular sobre a filtragem de faceta .

A seguinte definição de índice na coleção sample_airbnb.listingsAndReviews indexa automaticamente todos os campos dinamicamente indexáveis e configura os campos cancellation_policy, room_type e price para a pesquisa facetada.

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

A seguinte consulta utiliza o estágio $searchMeta para executar as seguintes ações:

Facet on the cancellation_policy, roomType, and accommodates fields.

O faceta cancellation_policy tem os seguintes buckets:
- "strict_14_with_grace_period"
- "moderate"
- "flexible"
- "super_strict_30"
- "super_strict_60"
O faceta room_type tem os seguintes buckets:
- "Entire home/apt"
- "Private room"
- "Shared room"
A query divide o faceta accommodates em buckets para:
- 1, limite inferior inclusivo para este bucket
- 2, limite superior exclusivo para o bucket 1 e limite inferior inclusivo para este bucket.
- 4, limite superior exclusivo para o bucket 2 e limite inferior inclusivo para este bucket.
- 8, limite superior exclusivo para o bucket 4
Execute uma pesquisa do Operadorcompound para anúncios que devem conter o texto new york city no description e filtra os resultados para anúncios com um moderate cancellation_policy. A configuração doesNotAffect garante que a filtragem por um moderate cancellation_policy não altere as contagens de outros buckets no faceta; as contagens para "strict_14_with_grace_period", "flexible", "super_strict_30" e "super_strict_60" são valores diferentes de zero.

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 ]

The counts for buckets in cancellationFacet are not reduced to zero even though the query filters on a value of moderate.

Exemplo de exclusão de filtro interfacet

Pesquise com doesNotAffect em uma faceta diferente do campo de query.

A seguinte definição de índice na coleção sample_airbnb.listingsAndReviews indexa os campos cancellation_policy, room_type e price, permitindo a pesquisa facetada neles.

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

A seguinte query:

Search for listings that include the text new york city in their description and that have a cancellation_policy of moderate.
Facet on the cancellation_policy, roomType, and accommodates fields.

Each of the cancellation_policy and roomType facets has three buckets, corresponding to the three unique values of these fields across the collection. The query breaks the accommodates facet into buckets for:
- 1, limite inferior inclusivo para este bucket
- 2, limite superior exclusivo para o bucket 1 e limite inferior inclusivo para este bucket.
- 4, limite superior exclusivo para o bucket 2 e limite inferior inclusivo para este bucket.
- 8, limite superior exclusivo para o bucket 4
Set the doesNotAffect property in the equals operator of the compound.filter to accommodatesFacet. This excludes the buckets within the accommodates facet from filtering. As a result, filtering on the moderate cancellation_policy reduces the counts of other buckets in the cancellation_policy facet to 0, and reduces the counts of buckets in the roomType facet, but the counts of buckets in the accommodates facet are unchanged. This allows you to compare the impact of filtering on different facets.

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 ]

Exemplo de agregação

Search with facet aggregations.

The following example uses an index named default on the sample_airbnb.listingsAndReviews collection. The property_type and amenities fields in the collection are indexed as the token type and the accommodates field is indexed as the number type.

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

The query uses the $searchMeta stage to find the listings that offer at least one of the specified amenities and group them by property_type. For each property type, the query computes the number of listings and the smallest and largest number of guests that a listing accommodates.

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

Nested Facet Example

Search with nested facets.

The following example uses an index named default on the sample_airbnb.listingsAndReviews collection. The property_type field in the collection is indexed as the token type and the bedrooms and accommodates fields are indexed as the number type.

{
  "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. 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',
            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',
            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',
            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',
            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',
            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',
            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',
            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',
            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',
            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',
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('43'), maxAccommodates: 8 },
                { _id: 2, listingCount: Long('7'), maxAccommodates: 6 },
                { _id: 'other', listingCount: Long('0'), maxAccommodates: null }
              ]
            }
          }
        ]
      }
    }
  }
]

Continuar aprendendo

Para saber mais, consulte How to Use Facets with MongoDB Search.

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

Aprenda com cursos

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.

Aprenda assistindo

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.

Duração: 11 Minutos

Voltar

existe

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 ( Operador de pesquisa MongoDB )

Definição

Sintaxe

Campos

Requisitos de memória

Definição de Facet

Facets de String

Sintaxe

Opções

Exemplo

Facets Numéricos

Sintaxe

Opções

Exemplo

Facetas de data

Sintaxe

Opções

Exemplo

Comparação de tipos de campo para faceta

Facet on Matching Children of an Embedded Documents Array

Facet Aggregations

Sintaxe

Opções

Metric Types

Considerações sobre arrays

Nested Facets

Resultados de facet

Facetas de seleção múltipla

SEARCH_META Variável de agregação

Limitações

Limitations for Embedded-Scoped Facets

Limitations for Facet Aggregations

Exemplos

Exemplo de resultados de metadados

Exemplo de metadados e resultados de pesquisa

Exemplo de returnScope

Embedded-Scoped Facet Example

Exemplo de faceta de seleção múltipla

Exemplo de exclusão de filtro interfacet

Exemplo de agregação

Nested Facet Example

Continuar aprendendo

Aprenda com cursos

Aprenda assistindo

`facet` ( Operador de pesquisa MongoDB )

`SEARCH_META` Variável de agregação