/ /

Operadores y coleccionistas

Docs Home

/ /

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

Puede usar el operador equals para consultar valores booleanos, objectIds, números, fechas y cadenas (indexadas como tipo token) en matrices. Si al menos un elemento de la matriz coincide con el campo "valor" del operador equals, MongoDB Search añade 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>
      }
   }
}

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`:reemplace la puntuación del resultado con 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

Comportamiento de la puntuación

De formaequals predeterminada, utiliza constant una puntuación de. Cada documento coincidente recibe una puntuación 1 de.

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 de ejemplos para ejemplos de puntuación.

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.
Indexe el campo name como tipo token para admitir la búsqueda de cadenas utilizando 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 de "Jim Hall" y "Ellen Smith" reciben cada uno una puntuación de 1 porque esos documentos tienen el campo verified_user establecido en true.

El siguiente ejemplo utiliza el operador equals para buscar en la colección users documentos 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 consulta anterior devuelve el documento "Jim Hall" porque ese documento contiene "new_user": true en el account objeto.

Ejemplo de ObjectId

El siguiente ejemplo utiliza el operador equals para buscar en la colección users documentos en los que el campo teammates contiene 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 consulta anterior devuelve el documento "Fred Osgood" porque ese documento "employee_number": 259 contiene.

Ejemplo de cadena

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 "Jim Hall" porque contiene Jim Hall en el name campo. MongoDB Search relaciona la consulta en minúsculas con el valor en mayúsculas del documento, ya que normaliza el término a minúsculas, como se especifica en la definición del índice del name campo.

Ejemplo de 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.

Consultas de ejemplo compuestas

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
Una de las siguientes debe ser verdadera:
- La teammates arreglo contiene el valor ObjectId("5ed6990aa1199b471010d70d")
- El campo region está establecido 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 ObjectID especificados en su matriz 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