MongoDB $ Filter Operator
Cómo se usa el operador de filtro $ en MongoDB
El operador de filtro $ de MongoDB se utiliza para filtrar los datos de la matriz de acuerdo con la declaración condicional dada. El uso del operador de filtro $ funciona en los documentos que se insertan en la colección especificada de MongoDB. Aquí, implementamos la consulta InsertMany () de MongoDB para insertar tres documentos en la colección "Cricket". Cada registro contiene tres campos: "_id", "reproductor" y el "runsrecord", que se establecen como una matriz. El formato de inserción del documento se representa en lo siguiente:
db.Grillo.insertMany ([
"_id": 1,
"Jugador": "Ravi",
"RunSecord": [100, 50, 70],
"Partidos" :
"Match1": "WorldCup",
"Año": "2000"
,
"_id": 2,
"Jugador": "Andrew",
"RunSecord": [150, 90, 55]
,
"_id": 3,
"Jugador": "Smith",
"RunSecord": [80, 99, 45]
,
"_id": 4,
"Jugador": "Alex",
"RunSecord": []
])
Los documentos en la colección "Cricket" se insertan correctamente como se muestra en la siguiente salida:
Reconocido: True, InsertedIDS: '0': 1, '1': 2, '2': 3, '3': 4
Ejemplo 1: MongoDB usa el operador de filtro $ en MongoDB
El operador básico de filtro $ del ejemplo de MongoDB se da en esta sección. Establecemos una consulta donde se llama al operador de proyecto $ en el método agregado. Invocamos el operador de filtro $ dentro del operador de proyecto $. El operador de filtro $ se especifica más con su parámetro. El parámetro "entrada" se establece con el nombre del campo de matriz "$ runsrecord" con el signo "$" para extraer los datos de él. Luego, usamos el parámetro "AS" para dar el título a la variable de retorno, "RunScrecord". Luego se hace referencia a esta variable utilizando el parámetro "cond" con el signo de doble dólar, "$$". El siguiente es el parámetro "cond" donde se asigna la expresión como "$ gt: [" $$ runsrecord ", 50]". Las condiciones implican que el operador "$ GT" obtiene el elemento de matriz que es mayor que el valor de "50" en el campo de matriz "RunSecord".
db.Grillo.agregar([
$ Proyecto:
Highruns:
$ filtro:
Entrada: "$ runsrecord",
AS: "RunSecord",
cond: $ gt: ["$$ runsrecord", 50]
])
Los resultados de la siguiente consulta de filtro $ devuelven solo aquellos valores de la matriz que es mayor "50". El valor que es inferior a "50" es ignorado por el operador de filtro $.
[
_id: 1, Highruns: [100, 70],
_id: 2, Highruns: [150, 90, 55],
_id: 3, Highruns: [80, 99],
_id: 4, HighRuns: []
]
Ejemplo 2: MongoDB utiliza el operador de filtro $ para filtrar el campo de no existencia
Ahora, tomamos un caso en el que el operador de filtro $ se aplique al campo que no está presente en ningún documento de recolección insertado. Aquí, tenemos una consulta donde el operador de filtro $ se emplea con los parámetros. El parámetro de entrada se establece con el campo "$ salario" para filtrar el documento. Luego, utilizamos el parámetro opcional "AS" que también se da con el nombre de la variable, "Salario", que se usa en la matriz de entrada como elemento. Después de esto, tenemos una expresión condicional en el parámetro "cond" del filtro $. El operador de filtro $ filtra el elemento de matriz según la condición especificada que es "$ GTE: [" $$ salario ", 6000]".
db.Grillo.agregar([
$ Match: _id: $ in: [2]
,
$ Proyecto:
Highruns:
$ filtro:
Entrada: "$ salario",
AS: "Salario",
cond: $ gte: ["$$ salario", 6000]
])
Como sabemos, el campo "Salario" proporcionado no está presente en el documento cuyo "_id" es "2", por lo que la salida de la consulta anterior del operador de filtro $ proporciona un valor nulo.
[_id: 2, Highruns: Null]
Ejemplo 3: MongoDB usa el operador de filtro $ para filtrar la matriz vacía
El siguiente es el escenario en el que se emplea el filtro $ a través de la matriz vacía. El operador de filtro $ devuelve una matriz vacía establecida si uno de los documentos en la colección tiene una matriz vacía. Tenemos la siguiente consulta del operador de filtro $. Primero tenemos el operador $ Match donde se proporciona la expresión "_id: $ in: [4]". Cuando el operador $ en el operador encuentra el valor de "4" contra el campo "_id", el próximo operador procede. Luego, tenemos un operador de filtro $ que filtra la matriz de elementos en función de la condición dada que es "$ gt: [" $$ runsrecord ", 45]".
db.Grillo.agregar([
$ Match: _id: $ in: [4]
,
$ Proyecto:
Highruns:
$ filtro:
Entrada: "$ runsrecord",
AS: "RunSecord",
cond: $ gt: ["$$ runsrecord", 45]
])
El "_id: 4" tiene el campo de matriz "runSrecord" que está vacío. Es por eso que cuando se ejecuta la consulta, genera la matriz vacía de la siguiente manera:
[_id: 4, highruns: []]
Ejemplo 4: MongoDB utiliza el operador de filtro $ en MongoDB con el nombre de variable opcional
Establecemos un título de la variable en las instancias anteriores utilizando el argumento "AS". Si el argumento "AS" no está configurado con ningún nombre de variable, la variable "$ this" se establece de forma predeterminada por MongoDB. Tengamos el ejemplo de consulta para esta declaración. Hacemos que coincidamos con el documento llamando al operador $ Match donde tenemos un campo "_id" en el que se establecen los valores. Asignamos un operador de filtro $ al operador "$ proyecto" donde se llama al operador de filtro $ con los parámetros. Aquí, tenemos un parámetro de "entrada" con el nombre del campo de matriz "$ runsrecord". Luego, aplicamos el parámetro "cond" con la condición especificada. La condición se establece como "cond: $ lt: [" $$ this ", 80]". Esta vez, el operador de $ LT se usa para encontrar el valor que es menor que el valor de "80". Tenga en cuenta que en lugar de un nombre de la variable "$$ runSrecord", usamos el nombre de la variable predeterminado "$$ this" aquí que no afecta la salida resultante.
db.Grillo.agregar([
$ Match: _id: $ in: [1, 2, 3, 4]
,
$ Proyecto:
Highruns:
$ filtro:
Entrada: "$ runsrecord",
cond: $ lt: ["$$ this", 80]
])
El operador de filtro $ filtra la matriz especificada con el $ esta variable de la misma manera que con la variable especificada.
[
_id: 1, Highruns: [50, 70],
_id: 2, Highruns: [55],
_id: 3, Highruns: [45],
_id: 4, HighRuns: []
]
Ejemplo 5: MongoDB utiliza el operador de filtro $ para filtrar con múltiples condiciones
Podemos proporcionar más de una condición al operador de filtro $ para filtrar solo aquellos documentos que coinciden con la condición dada. Aquí, definimos el operador de filtro $ donde se utilizan los $ y el operador en el parámetro "cond". El $ y el operador se establecen con múltiples condiciones como "$ gte: [" $$ runsrecord ", 45]" y "$ lte: [" $$ runsrecord ", 99]". Se utilizan $ y operador que requieren ambas condiciones como verdaderas.
db.Grillo.agregar([
$ Proyecto:
Highruns:
$ filtro:
Entrada: "$ runsrecord",
AS: "RunSecord",
cond: $ y: [
$ GTE: ["$$ RunSrecord", 45],
$ lte: ["$$ runsrecord", 99]
]
])
Con las múltiples condiciones, filtramos el documento coincidente de la siguiente manera:
[
_id: 1, Highruns: [50, 70],
_id: 2, Highruns: [90, 55],
_id: 3, Highruns: [80, 99, 45],
_id: 4, HighRuns: []
]
Conclusión
Exploramos este artículo que se trata del operador de filtro $ de MongoDB. Aquí, proporcionamos la implementación del script MongoDB del operador de filtro $ para filtrar los datos especificados. Primero demostramos el uso básico del operador de filtro $. Luego, utilizamos el operador de filtro $ sobre el documento cuyo campo no se agrega en el documento. La caja de campo de matriz vacía también se implementa en el operador de filtro $ que recupera la matriz vacía. Además, el operador de filtro $ se usa con la variable $ esta variable predeterminada.