/ /

Operadores y coleccionistas

Docs Home

/ /

Referencia de query

Operadores y coleccionistas

Operadores y coleccionistas

`equals` (Operador de búsqueda de MongoDB)

Definición

equals

El operador equals comprueba si un campo coincide con un valor especificado. equals admite la consulta de los siguientes tipos de datos:

booleano
ObjectId
número, int32int64incluidos, y double
fecha
cadena, indexada como tipo de token de búsqueda de MongoDB
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. Los dígitos decimales adicionales en documentos o consultas pueden causar problemas de precisión o imprecisiones 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 consulta:

Campo	Tipo	Descripción	¿Obligatorio?
`path`	string	Campo indexado para buscar.	sí
`value`	booleano, objectId, número, fecha, cadena, uuid o nulo.	Valor a consultar.	sí
`score`	Objeto	Puntuación para asignar a los resultados de búsqueda coincidentes. Utilice una de las siguientes opciones para modificar la puntuación: `boost`:multiplica la puntuación del resultado por el número dado. `constant`:reemplace la puntuación del resultado con el número dado. `function`:reemplace la puntuación del resultado con la expresión dada. Para obtener información sobre el uso de `score` en su consulta,consulte Calificar los documentos en los resultados.	no

Comportamiento de puntuación

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

Al consultar valores de una matriz, MongoDB Search asigna puntuaciones más altas si más valores en la matriz coinciden con la consulta.

Vea 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 users colección 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:

Indexar 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.
Indexe el campo region como tipos string para admitir la búsqueda de cadenas y token para admitir la búsqueda facet.

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

Consultas de ejemplo básicas

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 consulta 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 consulta anterior devuelve el documento "Fred Osgood" porque ese documento contiene ObjectId("5a9427648b0beebeb69589a1") en la teammates matriz.

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 consulta anterior devuelve el documento "Ellen Smith" porque ese documento "account_created": 2022-05-04T05:01:08.000+00:00 contiene.

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 utiliza 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 consulta anterior devuelve los documentos de "Ellen Smith" y Fred Osgood porque esos documentos contienen el valor nulo en el job_title campo.

Consultas de ejemplo compuestas

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

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

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

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

El campo verified_user debe establecerse en true
Una de las siguientes debe ser verdadera:
- La matriz teammates 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 consulta 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.

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

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 consulta 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 consulta utiliza la etapa para recuperar la cantidad de regiones en las $searchMeta que verified_users es verdadero en la users colección.

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 consulta utiliza la variable de agregación $$SEARCH_META para devolver los metadatos y los resultados de una búsqueda para recuperar la cantidad 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