/ /

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:

Nested fields inside an array of objects, see returnScope Example.
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.

A memória que uma query de faceta exige depende do número de valores únicos no campo em que você aplica a faceta, e não do número de buckets que você faz solicitação usando numBuckets ou boundaries. Por exemplo, uma faceta que solicita 20 buckets em um campo com cinco milhões de valores exclusivos ainda conta cada valor exclusivo para determinar os 20 principais 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.

O MongoDB Search acompanha as contagens de bucket separadamente para cada query, portanto, o uso total de memória é dimensionado com o número de queries de faceta simultâneas. Em um cluster sharded, o MongoDB Search também requer memória para mesclar os buckets de cada shard, que é dimensionada com o número de shards e o número de 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.

As facetas de string permitem restringir os resultados do MongoDB Search com base nos valores de string mais frequentes no campo de string especificado. O campo string deve ser índice como token. Para atribuir facetas aos campos string em documentos incorporados, você também deve criar um índice para os campos principais como o tipo de documento. Quando você usa facetas em strings, em arrays ou documentos incorporados, o MongoDB Search retorna contagens de facetas com base no número de documentos raiz correspondentes.

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	Número máximo de categorias de facetas para retornar nos resultados. O valor deve ser menor ou igual a `10000`. Se especificado, o MongoDB Search poderá retornar menos categorias do que o solicitado se os dados forem agrupados em menos categorias do que o número solicitado. Se omitido, padrão para `10`, o que significa que o MongoDB Search retornará somente as `10` principais categorias de faceta por contagem.	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"
        }
      ]
    }
  }
}

A query usa o estágio $searchMeta para pesquisar o campo year na coleção movies para filmes entre os anos 1980 e 2000 e recuperar resultados de metadados para a query. A query especifica três 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"
        }
      ]
    }
  }
}

A query usa o estágio $searchMeta para pesquisar o campo released na coleção movies para filmes entre os anos 2000 e 2015 e recuperar resultados de metadados para a query. A query especifica quatro 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)	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.
Numérico	número	numberFacet (desatualizado)	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.
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 .

Faceta em filhos correspondentes de um array de documento incorporado

Cada definição de faceta pode incluir um campo embeddedDocument opcional que limita as contagens de bucket da faceta apenas aos documentos filhos em um array embeddedDocuments que correspondem a um predicado de query. Se você omitir o campo embeddedDocument, a faceta será indexada por documento.

Sem embeddedDocument, um documento raiz conta em um bucket se ele tiver qualquer documento filho que se encaixe nesse bucket, mesmo que esse filho não corresponda à query definida no bloco facet.operator. O campo embeddedDocument restringe as contribuições do bucket apenas aos filhos que correspondem à embeddedDocument.operator especificada. Ele conta cada documento raiz no máximo uma vez por bucket.

O campo embeddedDocument usa os seguintes campos:

Campo	Tipo	Descrição	Obrigatório?
`path`	string	Campo com índice do tipo `embeddedDocuments` para definir o escopo da faceta. O `path` da faceta deve ser um descendente deste campo.	sim
`operator`	objeto	Operador para executar em cada documento filho no array `embeddedDocuments` que você especifica em `path`. Apenas documentos filho que correspondem a este operador contribuem para as contagens de bucket da faceta. Cada caminho referenciado neste operador deve ser um descendente de `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.

Agregações de faceta

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.

Para cada bucket de faceta, aggregations permite que você calcule os seguintes valores:

soma
média
minimum
maximum
primeiro
último

Ao usar aggregations, você deve:

Índice o campo que você especificar no path para cada métricas como token, number ou date.
Inclua explicitamente a métricas count se você quiser a contagem de buckets.
Especifique aggregations apenas no nível de folha de facetas aninhadas.

Se você quiser calcular métricas para um agrupamento intermediário, especifique esse agrupamento como uma faceta de nível superior separada com aggregations e sem faceta aninhada.

O MongoDB Search calcula aggregations sobre os dados no índice do MongoDB Search, que é eventualmente consistente.

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

Cada chave no documento aggregations é um nome de agregação que você especifica. O MongoDB Search retorna cada agregação nos documentos do bucket com o nome que você especificar.

Opções

Opção	Tipo	Descrição	Obrigatório?
`path`	string	Caminho do campo para calcular a métricas. Isso é necessário para todos os tipos de métricas, exceto `count`, que não aceita `path`. Todos os outros tipos de métricas calculam um valor a partir de um segundo campo, portanto, você deve nomear esse campo. Por exemplo, para retornar a classificação média dos documento em um bucket, especifique `avg` com um `path` de `rating`. A métricas `count` conta os documento no bucket, portanto, não precisa de um segundo campo.	condicional
`type`	string	Tipo de métricas a calcular. O valor pode ser um dos seguintes: `count` `sum` `avg` `min` `max` `first` `last` To learn more about each metric type, see Metric Types.	sim

Tipos de métricas

Tipo	Requisitos de campo	Descrição
`count`	none	Conta os documento no bucket. Não especifique um `path` para este tipo de métricas. Se você omitir `aggregations` de uma definição de faceta, o MongoDB Search retornará uma métrica `count` para o bucket. Se você especificar `aggregations`, o MongoDB Search retornará uma métrica `count` apenas se você especificar `count` no documento `aggregations`.
`sum`	número	Adiciona os valores do campo especificado para os documento no bucket.
`avg`	número	Retorna a média dos valores do campo especificado para os documentos no bucket. Se nenhum documento no bucket tiver um valor para o campo, o MongoDB Search retornará `null`.
`min`	none	Retorna o valor mais baixo do campo especificado para os documentos no bucket.
`max`	none	Retorna o valor mais alto do campo especificado para os documentos no bucket.
`first`	none	Retorna o valor do campo especificado para o primeiro documento no bucket, de acordo com a ordem que a opção de classificação da query define. Se a query não especificar uma classificação, a ordem será arbitrária. Para aprender como especificar uma classificação, consulte Classificar resultados do MongoDB Search.
`last`	none	Retorna o valor do campo especificado para o último documento no bucket, de acordo com a ordem que a opção de classificação da query define. Se a query não especificar uma classificação, a ordem será arbitrária. Para aprender como especificar uma classificação, consulte Classificar resultados do MongoDB Search.

Importante

min e max suportam todos os tipos de campo, incluindo token. Quando o MongoDB Search calcula essas métricas, ele ignora qualquer documento no qual o campo seja resolvido para um tipo não suportado. O MongoDB Search não retorna um erro quando ignora um documento. Para determinar se o MongoDB Search ignorou documentos em um bucket, adicione uma métrica count ao mesmo documento aggregations e compare-a com o número de documentos que você espera.

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

Cada tipo de métricas lida de forma diferente com um campo que é resolvido em mais de um valor, como um array:

sum e avg pular o documento.
min e max selecionam o menor e o maior valor no array para usar como um elemento representativo para o documento.
first e last retornam todos os valores como um array.

Para first e last, o array retornado difere do documento de origem das seguintes maneiras:

A ordem dos valores pode diferir. O MongoDB Search lê os valores do índice, que não preserva a ordem do documento de origem. Por exemplo, se um documento contiver ["red", "blue", "green"], o MongoDB Search poderá retornar ["blue", "green", "red"].
O MongoDB Search retorna apenas uma instância de um valor duplicado.
O MongoDB Search retorna todos os valores no caminho, incluindo valores de um tipo no qual você não pode criar facetas. Por exemplo, se um array contiver strings e um booleano, o MongoDB Search retornará o booleano com as strings.

Para retornar os valores exatamente como o documento de origem os contém, defina storedSource para o campo na definição do seu índice e defina returnStoredSource como true na sua query.

Facetas aninhadas

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.

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:

Você pode especificar aggregations apenas em uma faceta folha em uma árvore de facetas aninhadas. Uma definição de faceta que especifica facets não pode especificar aggregations também. Para calcular métricas para um agrupamento intermediário, especifique esse agrupamento como uma faceta de nível superior separada com aggregations e sem faceta aninhada.
You can't name a nested facet count. MongoDB Search reserves count for the document count of intermediate buckets.
O número total de buckets exclusivos que uma query pode retornar não pode exceder 100000. Para calcular os buckets que uma árvore de facetas produz, multiplique o número de buckets em cada nível de seu ramo de aninhamento. O número de buckets em um nível é numBuckets para uma faceta de string ou o número de buckets que boundaries e default definem para uma faceta de número ou data. Por exemplo, uma faceta que solicita 20 buckets e contém uma faceta aninhada que solicita 20 buckets produz 400 buckets exclusivos. Como cada nível multiplica esse total, fazer uma solicitação de mais buckets em cada nível reduz o número de níveis que você pode aninhar.

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 count field with the number of documents in the bucket, and 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

Cada bucket tem sua própria contagem de resultados. Quando você pesquisa pelo moderate cancellation_policy, as contagens para os quatro outros buckets Go para 0. Além disso, as contagens de buckets nas facetas room_type e accommodates se reduzem ao número de resultados em cada bucket que também têm um 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.

Você pode especificar doesNotAffect nos seguintes operadores:

Para excluir várias facetas, especifique um array de nomes de facetas. A maioria dos casos de uso exclui apenas a faceta que compartilha um caminho com o filtro. Por exemplo, um filtro equals no campo rating especifica o nome da faceta que usa rating como seu caminho.

Observação

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

Exemplo

Considere uma query na coleção sample_airbnb.listingsAndReviews para documentos com uma moderate cancellation_policy. Se você especificar um valor doesNotAffect de cancellation_policy, as contagens de buckets na faceta cancellation_policy não mudam, mas as contagens de resultados para os buckets de outras facetas se reduzem ao número de resultados em cada bucket que também têm um 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

Considere uma query na coleção sample_airbnb.listingsAndReviews para documento com um valor accommodates de 3. Se você especificar um valor doesNotAffect de cancellation_policy, as contagens de resultados para os buckets room_type serão reduzidas ao número de resultados em cada bucket que também acomodam 3 pessoas, mas as contagens de resultados para os buckets em cancellation_policy não serão afetadas.

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.

Limitações para facetas de escopo incorporado

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

Você não pode combinar uma opção returnScope de nível superior com uma faceta com escopo embeddedDocumentna mesma query.
Uma faceta com escopo embeddedDocumentretorna apenas uma contagem.
Não é possível combinar facetas drill-sideways (doesNotAffect) com uma faceta de escopo embeddedDocumentna mesma query.

Limitações para agregações de faceta

The following limitations apply to Facet Aggregations:

Você não pode usar as seguintes opções com 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.

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

A consulta a seguir pesquisa filmes lançados entre 01 de janeiro de 2000 e 31 de janeiro de 2015. Ela solicita metadados no campo directors e 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 ]

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.

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.

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:

Usa o text (operador do MongoDB Search) para pesquisar fundos angariados em 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.

A definição de índice na coleção sample_training.companies indexa o campo funding_rounds como o tipo embeddedDocuments, com os campos round_code e raised_currency_code em cada rodada de financiamento indexados como 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 e StumbleUpon têm várias rodadas de financiamento, das quais apenas algumas foram levantadas em 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 }
  ]
}

A query a seguir usa o operador in para restringir a faceta a essas três empresas e, em seguida, cria facetas em funding_rounds.round_code. A definição de roundFacet especifica um bloco embeddedDocument que limita a faceta apenas às rodadas de financiamento em que raised_currency_code é 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 ]

Cada empresa conta uma vez por código de rodada para o qual tem pelo menos uma rodada de financiamento captada em USD:

b contagens 3: KickApps, Topix e StumbleUpon têm, cada um, uma rodada b levantada em USD.
a contagens 1: apenas a KickApps tem uma rodada a levantada em USD. As rodadas a da Topix e da StumbleUpon não têm moeda registrada, portanto, não correspondem.
seed contagens 1: A rodada seed do StumbleUpon foi levantada em USD.

A rodada c da KickApps não contribui para um bucket c porque foi levantada em GBP, não em USD. Sem o bloco embeddedDocument, a criação de facetas em funding_rounds.round_code requer a indexação de funding_rounds como o tipo de documento, e uma faceta sem escopo também contaria a KickApps em um bucket c, porque o documento raiz tem um filho correspondente nesse bucket, independentemente de sua moeda.

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:

Faceta nos campos cancellation_policy, roomType e accommodates.

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 ]

As contagens para buckets em cancellationFacet não são reduzidas a zero, embora o filtro de queries em um valor de moderate.

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:

Pesquise listagens que incluam o texto new york city em seu description e que tenham um cancellation_policy de moderate.
Faceta nos campos cancellation_policy, roomType e accommodates.

Cada uma das facetas cancellation_policy e roomType tem três compartimentos, correspondendo aos três valores exclusivos desses campos em toda a coleção. A consulta divide a faceta accommodates em compartimentos 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
Defina a propriedade doesNotAffect no operador equals do compound.filter como accommodatesFacet. Isso exclui os buckets dentro da faceta accommodates do filtro. Como resultado, a filtragem na moderate cancellation_policy reduz as contagens de outros buckets na faceta cancellation_policy para 0 e reduz as contagens de buckets na faceta roomType, mas as contagens de buckets na faceta accommodates permanecem inalteradas. Isso permite que você compare o impacto do filtro em diferentes facetas.

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 ]

O exemplo a seguir usa um índice chamado default na coleção sample_airbnb.listingsAndReviews. Os campos property_type e amenities na coleção possuem um índice do tipo token e o campo accommodates possui um índice do tipo número.

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

A query usa o estágio $searchMeta para encontrar as listagens que oferecem pelo menos uma das comodidades especificadas e agrupá-las por property_type. Para cada tipo de propriedade, a query calcula o número de listagens e o menor e maior número de hóspedes que uma listagem acomoda.

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

O exemplo a seguir usa um índice chamado default na coleção sample_airbnb.listingsAndReviews. O campo property_type na coleção é indexado como o tipo token e os campos bedrooms e accommodates são indexados como o tipo número.

{
  "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).

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

Faceta em filhos correspondentes de um array de documento incorporado

Agregações de faceta

Sintaxe

Opções

Tipos de métricas

Considerações sobre arrays

Facetas aninhadas

Resultados de facet

Facetas de seleção múltipla

SEARCH_META Variável de agregação

Limitações

Limitações para facetas de escopo incorporado

Limitações para agregações de faceta

Exemplos

Exemplo de resultados de metadadosConclua as etapas anteriores do tutorial e instale as dependências

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

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

Exemplo de faceta com escopo incorporadoFaceta apenas nos filhos correspondentes de um array embeddedDocuments.

Exemplo de faceta de seleção múltiplaPesquise com doesNotAffect para um controle mais granular sobre o filtro de faceta.

Exemplo de exclusão de filtro entre facetasPesquise com doesNotAffect em uma faceta diferente do campo de query.

Exemplo de agregaçãoPesquise com agregações de facetas.

Exemplo de faceta aninhadaPesquise com facetas aninhadas.

Continuar aprendendo

Aprenda com cursos

Aprenda assistindo

`facet` ( Operador de pesquisa MongoDB )

`SEARCH_META` Variável de agregação