facet (Operador do Atlas Search )

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.

Sintaxe

facet tem a seguinte sintaxe:

{
  "$searchMeta"|"$search": {
    "index": <index name>, // optional, defaults to "default"
    "facet": {
      "operator": {
        <operator-specifications>
      },
      "facets": {
        <facet-definitions>
      }
    }
  }
}

Campos

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

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

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

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
]

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

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

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
]

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

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

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
]

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:

SEARCH_META Variável de agregação

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

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 a collection sample_mflix.movies . 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 query de $search com facet e a variável de aggregation $SEARCH_META para recuperar os resultados de pesquisa e dos metadados.

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

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
]

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

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',
12
        released: ISODate('1999-07-01T00:00:00.000Z')
13
      }
14
    ],
15
    meta: {
16
      count: { lowerBound: Long('20878') },
17
      facet: {
18
        genresFacet: {
19
          buckets: [
20
            { _id: 'Drama', count: Long('12149') },
21
            { _id: 'Comedy', count: Long('6436') },
22
            { _id: 'Romance', count: Long('3274') },
23
            { _id: 'Crime', count: Long('2429') },
24
            { _id: 'Thriller', count: Long('2400') },
25
            { _id: 'Action', count: Long('2349') },
26
            { _id: 'Adventure', count: Long('1876') },
27
            { _id: 'Documentary', count: Long('1755') },
28
            { _id: 'Horror', count: Long('1432') },
29
            { _id: 'Biography', count: Long('1244') }
30
          ]
31
        }
32
      }
33
    }
34
  }
35
]

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

Continuar aprendendo

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

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