/ /

Referencia de query

Operadores y coleccionistas

Operadores y coleccionistas

`equals` (MongoDB Search Operador)

Definición

equals

El operador equals verifica si un campo coincide con un valor que especifiques. equals admite la consulta de los siguientes tipos de datos:

booleano
ObjectId
número, incluyendo int32, int64 y double
fecha
string, indexado como tipo de token de búsqueda de MongoDB token
uuid
null

Se puede usar el operador equals para consultar valores booleano, objectId, numéricos, fecha y string (indexados como el tipo token) en arreglos. Si al menos un elemento del arreglo coincide con el campo "value" del operador equals, MongoDB Search agrega el documento al conjunto de resultados.

Nota

El operador equals admite números de hasta 15 dígitos decimales. Dígitos decimales adicionales en documentos o consultas pueden causar problemas de precisión o inexactitud en las consultas.

Sintaxis

equals tiene la siguiente sintaxis:

{
   $search: {
      "index": <index name>, // optional, defaults to "default"
      "equals": {
         "path": "<field-to-search>",
         "value": <boolean-value>|<objectId>|<number>|<date>|<string>,
         "score": <score-options>,
         "doesNotAffect": "<facet-to-exclude>" | [<array-of-facets>]
      }
   }
}

opciones

equals utiliza los siguientes términos para construir una query:

Campo	Tipo	Descripción	¿Requerido?
`path`	string	Campo indexado para buscar.	Sí
`value`	booleano, ObjectId, número, fecha, string, uuid, o null.	Valor para query.	Sí
`score`	Objeto	Puntuación que se asigna a los resultados coincidentes con los términos de búsqueda. Utiliza una de las siguientes opciones para modificar la puntuación: `boost`Multiplica la puntuación resultante por el número dado. `constant`: reemplazar la puntuación del resultado por el número dado. `function`: reemplaza el resultado de la puntuación con la expresión dada. Para obtener información sobre cómo usar `score` en tu query, consulta Calificación de los Documentos en los Resultados.	no
`doesNotAffect`	string o arreglo de strings	Faceta o lista de facetas que se deben excluir del recálculo del recuento en función de esta query. El valor debe ser uno o más nombres de una faceta definida en `$search.facets` o `$searchMeta.facets`. El operador utiliza las facetas especificadas para filtrar documentos que coincidan con esta query, pero no recalcula las cuentas para ellas. Para obtener más información, consulta Facetas de selección múltiple.	no

Comportamiento de la puntuación

Por defecto, equals utiliza la puntuación constant. Cada documento coincidente recibe una puntuación de 1.

Cuando se consultan valores en arreglos, MongoDB Search asigna mayores puntuaciones si más valores en el arreglo coinciden con la query.

Ver el Sección Ejemplos para calificar ejemplos.

Ejemplos

Los siguientes ejemplos utilizan una colección de muestra users.

Colección de muestra

La colección users contiene los siguientes tres documentos:

 db.users.insertMany([
  {
    "_id" : ObjectId("5ed698faa1199b471010d70c"),
    "name" : "Jim Hall",
    "verified_user" : true,
    "account" : {
      "new_user" : true,
      "active_user" : true
    },
    "teammates" : [
      ObjectId("5ed6990aa1199b471010d70d"),
      ObjectId("59b99dbdcfa9a34dcd7885c8")
    ],
    "region" : "East",
    "account_created" : ISODate("2021-12-12T10:18:27.000+00:00"),
    "employee_number" : 257,
    "uuid" : UUID("fac32260-b511-4c69-8485-a2be5b7dda9e"),
    "job_title": "engineer"
  },
  {
    "_id" : ObjectId("5ed6990aa1199b471010d70d"),
    "name" : "Ellen Smith",
    "verified_user" : true,
    "account" : {
      "new_user" : false,
      "active_user" : true
    },
    "teammates" : [
      ObjectId("5a9427648b0beebeb69537a5"),
      ObjectId("59b99dbdcfa9a34dcd7881d1")
    ],
    "region" : "Southwest",
    "account_created" : ISODate("2022-05-04T05:01:08.000+00:00"),
    "employee_number" : 258,
    "job_title": null
  },
  {
    "_id" : ObjectId("5ed6994fa1199b471010d70e"),
    "name" : "Fred Osgood",
    "verified_user" : false,
    "account" : {
      "new_user" : false,
      "active_user" : false
    },
    "teammates" : [
      ObjectId("5a9427648b0beebeb69589a1"),
      ObjectId("59b99dbdcfa9a34dcd7897d3")
    ],
    "region" : "Northwest",
    "account_created" : ISODate("2022-01-19T08:22:15.000+00:00"),
    "employee_number" : 259,
    "job_title": null
  }
])

{
   "_id" : ObjectId("5ed698faa1199b471010d70c"),
   "name" : "Jim Hall",
   "verified_user" : true,
   "account" : {
     "new_user" : true,
     "active_user" : true
   },
   "teammates" : [
     ObjectId("5ed6990aa1199b471010d70d"),
     ObjectId("59b99dbdcfa9a34dcd7885c8")
   ],
   "region" : "East",
   "account_created" : ISODate("2021-12-12T10:18:27.000+00:00"),
   "employee_number" : 257,
   "uuid" : UUID("fac32260-b511-4c69-8485-a2be5b7dda9e"),
   "job_title": "engineer"
}

{
   "_id" : ObjectId("5ed6990aa1199b471010d70d"),
   "name" : "Ellen Smith",
   "verified_user" : true,
   "account" : {
     "new_user" : false,
     "active_user" : true
   },
   "teammates" : [
     ObjectId("5a9427648b0beebeb69537a5"),
     ObjectId("59b99dbdcfa9a34dcd7881d1")
   ],
   "region" : "Southwest",
   "account_created" : ISODate("2022-05-04T05:01:08.000+00:00"),
   "employee_number" : 258,
   "job_title": null
}

{
   "_id" : ObjectId("5ed6994fa1199b471010d70e"),
   "name" : "Fred Osgood",
   "verified_user" : false,
   "account" : {
     "new_user" : false,
     "active_user" : false
   },
   "teammates" : [
     ObjectId("5a9427648b0beebeb69589a1"),
     ObjectId("59b99dbdcfa9a34dcd7897d3")
   ],
   "region" : "Northwest",
   "account_created" : ISODate("2022-01-19T08:22:15.000+00:00"),
   "employee_number" : 259,
   "job_title": null
}

Índice de muestra

La colección users está indexada con la siguiente definición de índice:

{
  "mappings": {
    "dynamic": true,
    "fields": {
      "name": {
        "type": "token",
        "normalizer": "lowercase"
      },
      "region": [
       {
         "type": "string"
       },
       {
         "type": "token"
       }
      ]
    }
  }
}

La definición del índice especifica lo siguiente:

Indexa automáticamente todos los campos indexables dinámicamente.
Indexar el campo name como tipo token para admitir la búsqueda de string mediante el operador equals.
Indexa el campo region como tipos string para soportar la búsqueda de string y token para soportar la búsqueda de facet.

Para aprender a crear un índice de búsqueda de MongoDB, consulta Administrar índices de búsqueda de MongoDB.

Consultas de ejemplos básicos

Ejemplos booleanos

El siguiente ejemplo utiliza el operador equals para buscar en la colección users documentos en los que el campo verified_user esté configurado en true.

db.users.aggregate([
  {
    "$search": {
      "equals": {
        "path": "verified_user",
        "value": true
      }
    }
  },
  {
    "$project": {
      "name": 1,
      "_id": 0,
      "score": { "$meta": "searchScore" }
    }
  }
])

La query anterior devuelve los siguientes resultados:

{ "name" : "Jim Hall", "score" : 1 }
{ "name" : "Ellen Smith", "score" : 1 }

Los documentos para "Jim Hall" y "Ellen Smith" reciben cada uno una puntuación de 1 porque esos documentos tienen el campo verified_user establecido en true.

En el siguiente ejemplo se utiliza el operador equals para buscar documentos en la colección users en los que el campo account.new_user contiene el valor booleano true.

db.users.aggregate([
  {
    "$search": {
      "equals": {
        "path": "account.new_user",
        "value": true
      }
    }
  }
])

La query anterior devuelve el documento de "Jim Hall" porque dicho documento incluye "new_user": true en el objeto account.

Ejemplo de ObjectId

El siguiente ejemplo utiliza el operador equals para buscar en la colección users documentos en los que el campo teammates contenga el valor ObjectId("5a9427648b0beebeb69589a1").

db.users.aggregate([
  {
    "$search": {
      "equals": {
        "path": "teammates",
        "value": ObjectId("5a9427648b0beebeb69589a1")
      }
    }
  }
])

La query anterior devuelve el documento de "Fred Osgood" porque ese documento contiene ObjectId("5a9427648b0beebeb69589a1") en el arreglo teammates.

Ejemplo de fecha

El siguiente ejemplo utiliza el operador equals para buscar en la colección users documentos en los que el campo account_created contiene el valor que coincide con ISODate("2022-05-04T05:01:08.000+00:00").

db.users.aggregate([
  {
    "$search": {
      "equals": {
        "path": "account_created",
        "value": ISODate("2022-05-04T05:01:08.000+00:00")
      }
    }
  }
])

La query anterior devuelve el documento para "Ellen Smith" porque ese documento contiene "account_created": 2022-05-04T05:01:08.000+00:00.

Ejemplo de número

El siguiente ejemplo utiliza el operador equals para buscar en la colección users documentos en los que el campo employee_number contiene el valor que coincide con 259.

db.users.aggregate([
  {
    "$search": {
      "equals": {
        "path": "employee_number",
        "value": 259
      }
    }
  }
])

La query anterior devuelve el documento de "Fred Osgood" porque ese documento contiene "employee_number": 259.

Ejemplo de string

El siguiente ejemplo utiliza el operador equals para buscar en la colección users documentos en los que el campo name contiene el valor que coincide con Jim Hall.

db.users.aggregate([
  {
    "$search": {
      "equals": {
        "path": "name",
        "value": "jim hall"
      }
    }
  }
])

La consulta anterior devuelve el documento para "Jim Hall" porque ese documento contiene Jim Hall en el campo name. MongoDB Search compara la query en minúsculas con el valor en mayúsculas del documento porque normaliza el término en minúsculas como se especifica en la definición de índice para el campo name.

Ejemplo UUID

El siguiente ejemplo usa el operador equals para buscar en la colección users documentos en los que el campo uuid contiene el valor que coincide con un UUID específico.

db.users.aggregate([
  {
    "$search": {
      "equals": {
        "path": "uuid",
        "value": UUID("fac32260-b511-4c69-8485-a2be5b7dda9e")
      }
    }
  }
])

La query anterior devuelve el documento para "Jim Hall" porque ese documento contiene la UUID especificada en el campo uuid.

Ejemplo nulo

El siguiente ejemplo utiliza el operador equals para buscar en la colección users documentos en los que el campo job_title contiene el valor nulo.

db.users.aggregate([
  {
    $search: {
      "equals": {
        "path": "job_title",
        "value": null
      }
    }
  }
])

La query anterior devuelve los documentos para "Ellen Smith" y Fred Osgood porque esos documentos contienen el valor nulo en el campo job_title.

Queries de ejemplo compuesto

El siguiente ejemplo utiliza el operador compuesto junto con must, mustNot y equals para buscar documentos en los que el campo region sea Southwest y el campo verified_user no sea false.

db.users.aggregate([
  {
    "$search": {
      "compound": {
        "must": {
          "text": {
            "path": "region",
            "query": "Southwest"
          }
        },
        "mustNot": {
          "equals": {
            "path": "verified_user",
            "value": false
          }
        }
      }
    }
  }
])

La query anterior devuelve el documento de "Ellen Smith", que es el único en la colección que cumple con los criterios de búsqueda.

La siguiente query de ejemplo tiene estos criterios de búsqueda:

El campo verified_user debe configurarse en true
Debe cumplirse una de las siguientes condiciones:
- La teammates arreglo contiene el valor ObjectId("5ed6990aa1199b471010d70d")
- El campo region se establece en Northwest

db.users.aggregate([
  {
    "$search": {
      "compound": {
        "must": {
          "equals": {
            "path": "verified_user",
            "value": true
          }
        },
        "should": [
          {
            "equals": {
              "path": "teammates",
              "value": ObjectId("5ed6990aa1199b471010d70d")
            }
          },
          {
            "text": {
              "path": "region",
              "query": "Northwest"
            }
          }
        ],
        "minimumShouldMatch": 1
        }
      }
    },
    {
      "$project": {
        "name": 1,
        "_id": 0,
        "score": { "$meta": "searchScore" }
      }
    }
])

La query anterior devuelve los siguientes resultados:

{ "name" : "Jim Hall", "score" : 2 }

El documento para "Jim Hall" obtiene una puntuación de 2 porque cumple los requisitos para la cláusula must y la primera de las dos cláusulas should.

Puedes buscar varios ObjectIDs con una query compuesta. La siguiente query de ejemplo utiliza el operador compound con una cláusula should para buscar tres ObjectID diferentes, de los cuales al menos dos deben aparecer para satisfacer la query.

db.users.aggregate([
  {
    "$search": {
      "compound": {
        "should": [
          {
            "equals": {
              "path": "teammates",
              "value": ObjectId("5a9427648b0beebeb69537a5")
            }
          },
          {
            "equals": {
              "path": "teammates",
              "value": ObjectId("59b99dbdcfa9a34dcd7881d1")
            }
          },
          {
            "equals": {
              "path": "teammates",
              "value": ObjectId("5a9427648b0beebeb69579d0")
            }
          }
        ],
        "minimumShouldMatch": 2
        }
      }
    },
    {
      "$project": {
        "name": 1,
        "_id": 0,
        "score": { "$meta": "searchScore" }
      }
    }
])

La query anterior devuelve los siguientes resultados:

{ "name" : "Ellen Smith", "score" : 2 }

El documento de "Ellen Smith" recibe una puntuación de 2 porque contiene dos de los ObjectIDs especificados en su arreglo de teammates.

Ejemplos de metadatos

La siguiente query utiliza la etapa $searchMeta para recuperar el número de regiones en las que verified_users es verdadero en la colección users.

db.users.aggregate([
  {
    "$searchMeta": {
      "facet": {
        "operator": {
          "equals": {
            "path": "verified_user",
            "value": true
          }
        },
        "facets": {
          "regionFacet": {
            "type": "string",
            "path": "region"
          }
        }
      }
    }
  }
])

[
  {
    count: { lowerBound: Long('2') },
    facet: {
      regionFacet: {
        buckets: [
          { _id: 'East', count: Long('1') },
          { _id: 'Southwest', count: Long('1') }
        ]
      }
    }
  }
]

La siguiente query usa la variable de agregación $$SEARCH_META para devolver tanto los metadatos como los resultados de la búsqueda para una búsqueda que recupere el número de regiones en las que verified_users es verdadero en la colección users.

db.users.aggregate([
  {
    "$search": {
      "facet": {
        "operator": {
          "equals": {
            "path": "verified_user",
            "value": true
          }
        },
        "facets": {
          "regionFacet": {
            "type": "string",
            "path": "region"
          }
        }
      }
    }
  },
  { "$limit": 2 },
  {
    "$facet": {
      "docs": [
        { "$project":
          {
            "type": 1,
            "description": 1
          }
        }
      ],
      "meta": [
        {"$replaceWith": "$$SEARCH_META"},
        {"$limit": 1}
      ]
    }
  },
  {
    "$set": {
      "meta": {
        "$arrayElemAt": ["$meta", 0]
      }
    }
  }
])

[
  {
    docs: [
      {
        _id: ObjectId('5ed698faa1199b471010d70c'),
        name: 'Jim Hall',
        region: 'East'
      },
      {
        _id: ObjectId('5ed6990aa1199b471010d70d'),
        name: 'Ellen Smith',
        region: 'Southwest'
      }
    ],
    meta: {
      count: { lowerBound: Long('2') },
      facet: {
        regionFacet: {
          buckets: [
            { _id: 'East', count: Long('1') },
            { _id: 'Southwest', count: Long('1') }
          ]
        }
      }
    }
  }
]

Volver

embeddedDocument

exists