/ /

/ /

$eq (operador de predicado de query)

$eq: Especifica la condición de igualdad. Los $eq El operador coincide con documentos donde el valor de un campo es igual al valor especificado.

Compatibilidad

Puedes usar $eq para implementaciones alojadas en los siguientes entornos:

MongoDB Atlas: El servicio totalmente gestionado para implementaciones de MongoDB en la nube

MongoDB Enterprise: La versión basada en suscripción y autogestionada de MongoDB
MongoDB Community: La versión de MongoDB con código fuente disponible, de uso gratuito y autogestionada.

Sintaxis

El operador $eq tiene el siguiente formato:

{ <field>: { $eq: <value> } }

El $eq operador es equivalente a la { field: <value> } forma, excepto cuando <value> es una expresión regular. Vea ejemplos a continuación.

Comportamiento

Orden de comparación

Para la comparación de diferentes valores de tipo BSON, consulta el orden de comparación especificado de BSON.

Coincidir un valor de documento

Si <value> es un documento, el orden de los campos en el documento es importante.

Hacer coincidir un valor de un arreglo

Si <value> es un arreglo, MongoDB busca documentos donde <field> coincida exactamente con el arreglo o <field> contenga un elemento que coincida exactamente con el arreglo. El orden de los elementos importa. Para obtener un ejemplo, consulta Equivale a un valor de arreglo.

Coincidir una expresión regular

La expresión { field: <value> } especifica implícitamente una coincidencia en <value>. MongoDB traduce la coincidencia implícita a una forma más explícita.

Cuando <value> es fijo, como una cadena particular, la expresión es equivalente a utilizar el operador $eq { field: { $eq: <value> } }.

Si <value> es una expresión regular, MongoDB expande la declaración para utilizar el operador $regex { field: { $regex: <value> } }.

Para ejemplos, consulta Comportamiento de coincidencia de expresiones regulares.

Implicaciones de seguridad

Utiliza siempre la forma explícita { field: { $eq: <value> } } con la entrada proporcionada por el usuario para evitar problemas con queries formadas de manera maliciosa.

Ejemplos

Los ejemplos usan la colección inventory:

db.inventory.insertMany( [
   { _id: 1, item: { name: "ab", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] },
   { _id: 2, item: { name: "cd", code: "123" }, qty: 20, tags: [ "B" ] },
   { _id: 3, item: { name: "ij", code: "456" }, qty: 25, tags: [ "A", "B" ] },
   { _id: 4, item: { name: "xy", code: "456" }, qty: 30, tags: [ "B", "A" ] },
   { _id: 5, item: { name: "mn", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }
] )

Es igual a un valor especificado

Este ejemplo selecciona todos los documentos de la colección inventory donde el valor del campo qty es igual a 20:

db.inventory.find( { qty: { $eq: 20 } } )

La query es equivalente a:

db.inventory.find( { qty: 20 } )

Ambas queries coinciden con los siguientes documentos:

[
   { _id: 2, item: { name: "cd", code: "123" }, qty: 20, tags: [ "B" ] },
   { _id: 5, item: { name: "mn", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }
]

El campo en un documento incrustado es igual a un valor

El siguiente ejemplo selecciona todos los documentos en la colección inventory donde el valor del campo item.name es igual a "ab". Para especificar una condición en un campo dentro de un documento incrustado, utiliza la notación de puntos.

db.inventory.find( { "item.name": { $eq: "ab" } } )

La query es equivalente a:

db.inventory.find( { "item.name": "ab" } )

Ambas queries coinciden con el siguiente documento:

[ { _id: 1, item: { name: "ab", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } ]

Tip

Consulta documentos incrustados

El elemento de arreglo es igual a un valor

El siguiente ejemplo selecciona todos los documentos en la colección inventory donde el arreglo tags contiene un elemento con el valor "B" [1]:

db.inventory.find( { tags: { $eq: "B" } } )

La query es equivalente a:

db.inventory.find( { tags: "B" } )

Ambas queries coinciden con los siguientes documentos:

[
   { _id: 1, item: { name: "ab", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] },
   { _id: 2, item: { name: "cd", code: "123" }, qty: 20, tags: [ "B" ] },
   { _id: 3, item: { name: "ij", code: "456" }, qty: 25, tags: [ "A", "B" ] },
   { _id: 4, item: { name: "xy", code: "456" }, qty: 30, tags: [ "B", "A" ] }
]

Tip

[1]	La query también coincidirá con documentos donde el valor del campo `tags` es la string `"B"`.

Es igual a un valor de arreglo

Este ejemplo selecciona todos los documentos de la colección inventory donde la matriz tags es igual a la matriz especificada o contiene un elemento que es igual a la matriz [ "A", "B" ].

db.inventory.find( { tags: { $eq: [ "A", "B" ] } } )

La query es equivalente a:

db.inventory.find( { tags: [ "A", "B" ] } )

Ambas queries coinciden con los siguientes documentos:

[
   { _id: 3, item: { name: "ij", code: "456" }, qty: 25, tags: [ "A", "B" ] },
   { _id: 5, item: { name: "mn", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }
]

Comportamiento de coincidencia de expresiones regulares

Los siguientes ejemplos muestran la diferencia entre la coincidencia implícita y explícita de expresiones regulares. Considera una colección con estos documentos:

db.companies.insertMany( [
   { _id: 001, company: "MongoDB" },
   { _id: 002, company: "MongoDB2" }
] )

$eq Coincidencia en una cadena

Las cadenas devuelven los mismos valores independientemente de si se utiliza una coincidencia implícita o un uso explícito de $eq. Las siguientes consultas devuelven el mismo resultado:

db.collection.find( { company: "MongoDB" }, {_id: 0 })
db.collection.find( { company: { $eq: "MongoDB" } }, {_id: 0 } )

El resultado es:

[ { company: "MongoDB" } ]

coincidencia de $eq en una expresión regular

Una query explícita que usa $eq y una expresión regular solo coincide con un objeto que también sea una expresión regular. La query de ejemplo no devuelve resultados porque los valores en el campo company son cadenas de texto.

db.companies.find( { company: { $eq: /MongoDB/ } }, {_id: 0 } )

Coincidencias de expresiones regulares

Una query con una coincidencia implícita con una expresión regular equivale a una query que utiliza el operador $regex. Las siguientes consultas devuelven el mismo resultado:

db.companies.find( { company: /MongoDB/ }, {_id: 0 })
db.companies.find( { company: { $regex: /MongoDB/ } }, {_id: 0 } )

Los resultados son:

[
   { company: "MongoDB" },
   { company: "MongoDB2" }
]

Volver

Comparación

$gt