/ /

Operadores e coletores

Página inicial do Docs

/ /

Referência de query

Operadores e coletores

Página inicial do Docs

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.

Você pode usar facet com os $search $searchMeta estágios e. O MongoDB recomenda usar facet com o estágio para recuperar resultados de metadados somente para a $searchMeta query. Para recuperar resultados de metadados e queries usando o estágio, use $search a $$SEARCH_META variável de agregação. SEARCH_META Consulte Variável de agregação para saber mais.

Se você definir storedSource na definição de tipo de campo embeddedDocuments, poderá usar returnScope com returnStoredSource para faceta campos aninhados dentro de uma array de objetos. Caso contrário, você só pode faceta o campo raiz embeddedDocuments . Para ver um exemplo de facet em:

Campos aninhados dentro de uma array de objetos, consulte Exemplo de returnScope.
embeddedDocuments campo de tipo raiz , consulte Query do Facet.

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	Informações para o agrupamento dos dados para cada faceta. Você deve especificar pelo menos uma Definição de faceta.
`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.

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 facet aprimorado.

Para saber mais sobre as diferenças entre os tipos de campo atualizados e desatualizados para faceta, consulte Comparação de tipos de campo para facet.

As facets de strings permitem limitar os resultados da MongoDB Search com base nos valores de strings mais frequentes no campo de string especificado. Observe que o campo de string deve ser indexado como token. Para faceta campos de string em documentos incorporados, você também deve indexar os campos pai como o tipo de documento. Quando você faceta strings 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 string têm a seguinte sintaxe:

{
  "$searchMeta": {
    "facet":{
      "operator": {
        <operator-specification>
      },
      "facets": {
        "<facet-name>" : {
          "type" : "string",
          "path" : "<field-path>",
          "numBuckets" : <number-of-categories>,
        }
      }
    }
  }
}

Opções

Opção	Tipo	Descrição	Obrigatório?
`numBuckets`	int	Número máximo de categorias faceta para retornar nos resultados. O valor deve ser menor ou igual a `1000`. Se especificado, a 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 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 facet melhorado.

Para saber mais sobre as diferenças entre os tipos de campo atualizados e desatualizados para faceta, consulte Comparação de tipos de campo para facet.

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

Opções

Opção	Tipo	Descrição	Obrigatório?
`boundaries`	array de números	Lista de valores numéricos, em ordem crescente, que especificam os limites para cada bloco. Você deve especificar pelo menos dois limites, que sejam menores ou iguais a mil (`[2, 1000]`). Cada par adjacente de valores age como o limite inferior inclusivo e o limite superior exclusivo para o bloco. Você pode especificar qualquer combinação de valores dos seguintes tipos de BSON: 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
`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 procurar o campo year na collection movies para filmes entre os anos 1980 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 facet melhorado.

Para saber mais sobre as diferenças entre os tipos de campo atualizados e desatualizados para faceta, consulte Comparação de tipos de campo para facet.

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

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 mil (`[2, 1000]`) 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
`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 filmes entre os anos 2000 a 2015 no campo released na collection movies e recuperar resultados de metadados para a string de 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 facet

Os tipos de campo de pesquisa atualizados do MongoDB fornecem funcionalidade aprimorada para suportar facet 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 facet desatualizado	Principais diferenças
String	token	stringFacet (desatualizado)	Suporte a normalizador: o `token` tipo oferece suporte a normalizadores que transformam buckets de faceta . Por exemplo,`normalizer: lowercase` com, "ADVIDAS" e "adidas" contam para o mesmo bucket, enquanto `stringFacet` os trata como buckets separados.
Numérico	número	numberFacet (desatualizado)	Suporte a arrays: o `number` tipo 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 arrays: o `date` tipo considera valores dentro de arrays para buckets de faceta . Por exemplo, um valor de array com datas pode contribuir para vários buckets 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 .

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.

`SEARCH_META` Variável de agregação

Quando você executa sua query utilizando o estágio $search, o MongoDB Search armazena os resultados de metadados na variável $$SEARCH_META e retorna somente os resultados da pesquisa. Você pode usar a variável $$SEARCH_META em todos os estágios de pipeline de agregação compatíveis para visualizar os resultados de metadados da sua $search query.

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

Aplicam-se as seguintes 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.
Não é possível executar queries de faceta em collections fragmentadas em clusters.

Exemplos

Os exemplos a seguir usam os dados de amostra. O exemplo de resultados de metadados demonstra como executar uma query de $searchMeta com facet para recuperar somente os metadados nos resultados. O exemplo de metadados e os resultados da pesquisa demonstram como executar uma $search query de com facet e a $SEARCH_META variável de agregação para recuperar os resultados de pesquisa e dos metadados. O returnScope exemplo demonstra como faceta em campos aninhados em uma array de objetos indexados dinamicamente usando o embeddedDocuments tipo.

Exemplo de resultados de metadados

Conclua as etapas anteriores do tutorial e instale dependências

A definição de índice na coleção sample_mflix.movies especifica o seguinte para os campos indexarem:

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

As pesquisas de query a seguir para filmes lançados entre 1º 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.

Exemplo de metadados e resultados de pesquisa

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

A definição de índice na coleção sample_mflix.movies especifica o seguinte para os campos indexarem:

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

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

A query a seguir pesquisa filmes lançados perto de 01 de julho de 1999 usando o estágio $search . A consulta inclui um estágio $facet para processar os documentos de entrada usando os seguintes estágios de subpipeline:

Etapa $project para excluir todos os campos nos documentos, exceto os campos title e released no campo de saída docs.
$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 .
o estágio $replaceWith para incluir os resultados de metadados armazenados na variável $$SEARCH_META no campo de saída meta

A query também inclui um estágio $set para adicionar o campo meta.

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

Pesquise usando faceta e faceta em campos filhos de embeddedDocuments.

A definição de índice na sample_training.companies coleção indexa o funding_rounds campo como o tipo embeddedDocuments. Ele indexa dinamicamente todos os campos na funding_rounds array de objetos e armazena os raised_currency_code raised_amount campos e na funding_rounds array 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:

Utiliza o text (Operador de Pesquisa MongoDB ) para pesquisar fundos levantados USD no.
Utiliza opções returnScope para definir o contexto de consulta para o embeddedDocuments campo funding_rounds denominado. Para returnScope usar, a query:
- Especifica a opção returnStoredSource, que é obrigatória, para retornar os campos de origem armazenados.
Facetas no campo raised_amount na 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 do MongoDB Search, as contagens de faceta são baseadas nos documentos filhos incorporados e não nos pais.

Continuar aprendendo

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

Você pode aprender mais sobre facet (Operador de Pesquisa do MongoDB) na Pesquisa do MongoDB com nosso curso e vídeo.

Aprenda com cursos

Para saber mais sobre o uso de facets no MongoDB Search, faça a Unidade 9 do Curso de Introdução ao MongoDB na MongoDB University. A unidade de hora do 1.5 inclui uma visão geral do MongoDB Search e lições sobre como criar índices do MongoDB Search, executar consultas do$search utilizando operadores compostos e agrupar resultados utilizando o facet.

Aprenda assistindo

Acompanhe este vídeo para saber como criar e usar um numérico e de cadeia de caracteres (operador de facet pesquisa do MongoDB ) em sua query para agrupar resultados e recuperar uma contagem dos resultados nos grupos.

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	]

Definição

Sintaxe

Campos

Definição de Facet

Facets de String

Importante

Sintaxe

Opções

Exemplo

Exemplo

Facets Numéricos

Importante

Sintaxe

Opções

Exemplo

Exemplo

Facetas de data

Importante

Sintaxe

Opções

Exemplo

Exemplo

Comparação de tipos de campo para facet

Observação

Resultados de facet

SEARCH_META Variável de agregação

Limitações

Exemplos

Exemplo de resultados de metadados

Exemplo de metadados e resultados de pesquisa

Observação

Observação

Exemplo de returnScope

Continuar aprendendo

Aprenda com cursos

Aprenda assistindo

`SEARCH_META` Variável de agregação