facet (Operador de búsqueda de MongoDB)

Definición

facet

El recopilador facet agrupa los resultados por valores o rangos en los campos facetados especificados y devuelve el recuento de cada uno de esos grupos.

Puedes usar facet con ambos Etapas$searchy$searchMeta. MongoDB recomienda usar facet con la etapa$searchMetapara recuperar los resultados de metadatos únicamente de la consulta. Para recuperar los resultados de metadatos y de la consulta con la etapa$search, debe usar la variable de agregación $$SEARCH_META. Consulte SEARCH_META Variable de agregación para obtener más información.

Si defines "storedSource" en la definición del tipo de campo embeddedDocuments, puedes usar "returnScope" con "returnStoredSource" para aplicar facetas a campos anidados dentro de un array de objetos. De lo contrario, solo puedes aplicar facetas al campo raíz de tipo embeddedDocuments. Para un ejemplo de aplicación de facetas en:

• Campos anidados dentro de una matriz de objetos, consulte el ejemplo de returnScope.

• Campo raíz de tipo embeddedDocuments, ver Consulta de Facetas.

Sintaxis

facet tiene la siguiente sintaxis:

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

Definición de faceta

El documento de definición de faceta contiene el nombre de la faceta y las opciones específicas de cada tipo. MongoDB Search admite los siguientes tipos de facetas:

• Facetas de cuerda

• Facetas numéricas

• Facetas de fecha

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

Para una consulta de faceta, MongoDB Search devuelve una asignación de los nombres de faceta definidos a una matriz de cubos para esa faceta en los resultados. El documento de resultados de la faceta contiene la opción buckets, que es una matriz de cubos resultantes para la faceta. Cada documento de cubo de faceta de la matriz tiene los siguientes campos:

SEARCH_META Variable de agregación

Al ejecutar su consulta con la etapa, MongoDB Search almacena los resultados de los metadatos en $search la $$SEARCH_META variable y devuelve únicamente los resultados de la búsqueda. Puede usar la $$SEARCH_META variable en todas las etapas de la canalización de agregación compatibles para ver los resultados de los metadatos de su $search consulta.

MongoDB recomienda usar la variable $$SEARCH_META solo si necesita tanto los resultados de la búsqueda como los de los metadatos. De lo contrario, use:

• $search escenario solo para los resultados de búsqueda.

• $searchMeta Etapa solo para los resultados de metadatos.

Limitaciones

Se aplican las siguientes limitaciones:

• Solo se pueden ejecutar consultas de facetas en un solo campo. No se pueden ejecutar consultas de facetas en grupos de campos.

Ejemplos

Los siguientes ejemplos usan los datos de muestra. El ejemplo de resultados de metadatos demuestra cómo ejecutar una $searchMeta query con facet para recuperar solo los metadatos en los resultados. El ejemplo de metadatos y resultados de búsqueda demuestra cómo ejecutar una $search query con facet y la variable de agregación $SEARCH_META para recuperar los resultados tanto de la búsqueda como de los metadatos. El ejemplo returnScope demuestra cómo aplicar facetas en campos anidados en un arreglo de objetos indexados dinámicamente usando el tipo embeddedDocuments.

{
  "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'                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
]

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

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
]

Continuar Aprendiendo

Para obtener más información, consulte Cómo usar facetas con la búsqueda de MongoDB.

Puede obtener más información sobre facet (operador de búsqueda MongoDB) en MongoDB Search con nuestro curso y video.