MongoDB u operador
Cómo usar el operador ort en MongoDB
El operador OR en MongoDB está representado en formato "$ o". El "$ o" se usa para encerrar las expresiones múltiples en los soportes cuadrados en los que se realiza la lógica u operación. Usamos el $ u operador en la colección MongoDB. Creamos la colección MongoDB titulada "Pacientes". La colección "Pacientes" se inserta con los múltiples documentos en los que realizamos los $ u operador. Los siguientes documentos se insertan en MongoDB invocando el método InsertMany ():
db.Pacientes.insertmany ([
"FirstName": "Jennifer",
"LastName": "Joshua",
"Age": 44,
"PhoneNumber": 43400517,
"Cita": "Dentista",
"Cargos": 2000,
"Test": ["Rayos X", "Blood", "Pulpal"]
,
"FirstName": "Thomas",
"LastName": "Steven",
"Age": 74,
"PhoneNumber": 39034694,
"Date de cita": "Cirujano",
"Cargos": 6000,
"Test": ["Elective", "PPT"]
,
"FirstName": "Charles",
"LastName": "Daniel",
"Age": 35,
"PhoneNumber": 65712165,
"Cita": "Médico de cardiología",
"Cargos": 2000,
"Prueba": ["CT", "MRI"]
,
"FirstName": "Michelle",
"LastName": "Paul",
"Edad": 51,
"PhoneNumber": 54399288,
"Cita": "Dermatólogo",
"Cargos": 8000,
"Test": ["Biopsias de piel", "Luz de madera", "raspado de la piel"]
,
"FirstName": "Andrew",
"LastName": "Jerry",
"Age": 69,
"PhoneNumber": 6108100,
"Cita": "Médico de cardiología",
"Cargos": 7000,
"Prueba": ["ECG", "Glucosa en sangre", "ultrasonido"]
])
La salida de los documentos previamente insertados reconoce "Verdadero" y proporciona los valores de "InsertedID" para cada documento.
Ejemplo 1: MongoDB $ u operador para que coincida con los documentos
Aquí se implementa la consulta básica del MongoDB $ u operador que demuestra el funcionamiento de este operador en MongoDB. Aquí, definimos una consulta con el método find (). El método find () se especifica más con el $ o el operador. El $ u operador toma dos campos, "cita" y "cargos", que se asignan con los valores. El $ u operador coincide con el valor de campo y recupera solo aquellos documentos cuyos valores coinciden con los valores de campo. La estructura de consulta del $ u operador se proporciona a continuación:
db.Pacientes.encontrar ($ o: [cita: "dermatólogo",
Cargas: 7000]).bonito()
Botamos los documentos cuya "cita" es con "dermatólogo" y cuyos "cargos" son "7000". El $ u operador encuentra resultados verdaderos de ambos valores de campo y devuelve los documentos coincidentes en la salida.
Ejemplo 2: MongoDB $ u operador para que coincida con los documentos inexistentes
En la consulta anterior de $ o operador, obtuvimos los documentos emparejados. Ahora, recuperamos el documento inexistente de la colección "paciente". La siguiente consulta de $ o operador toma el documento cuyo "nombre" es "Charles" y la "cita" es con el "médico". El $ u operador coincide con estos valores de campo dentro de la recolección de "pacientes" y genera los resultados después de coincidir.
db.Pacientes.find ($ o: ["FirstName": "Charles", "Nombramiento": "Médico"]).bonito()
El $ u operador tiene un resultado verdadero y el otro tiene un resultado falso. Como especificamos la "cita" con el valor "médico" que no coincide con ninguno de los documentos en la colección "paciente". Por eso, el $ u operador solo devuelve el documento del campo coincidente que es "paciente" como salida.
Ejemplo 3: MongoDB $ u operador con múltiples argumentos
Proporcionamos dos argumentos en las consultas anteriores de $ u operador. Aquí, pasamos más de dos argumentos como la expresión de $ o operador. Recuperamos el documento que coincide con cualquiera de los valores de campo de "edad" que se le dan. El requisito de $ u operador es el mismo para los múltiples argumentos de que una de las expresiones debería ser verdadera. La consulta de múltiples argumentos en el $ u operador se proporciona de la siguiente manera:
db.Pacientes.find ("cita": "médico de cardiología", $ o: ["edad": 20, "edad": 35, "edad": 69])
Allí, tenemos dos resultados coincidentes que se obtienen de los $ u operador. Los valores de "edad" que son "35" y "69" se comparan con los documentos de "pacientes" que obtienen el operador y se muestran en el shell.
Ejemplo 4: MongoDB $ u operador con agregación
El método agregado en MongoDB combina los registros en una colección. Por lo tanto, se pueden usar para diferentes operaciones. Realizamos los $ u operador en el método de agregación que evalúa una o más expresiones y devuelve verdadero si alguno de ellos se evalúa a verdadero. De lo contrario, la declaración se considera falsa.
Tengamos la consulta del operador $ o de agregación donde primero invocamos el método agregado () que luego implementa el proyecto $ y el proyecto $ que se especifica con el valor _id que se coincide con el documento. Luego, establecemos el campo de "edad" con el valor de "1" porque solo queremos que este campo se genere a partir de todos los documentos. Después de eso, definimos el atributo de "resultados" que tiene el $ u operación. El $ u operador toma la declaración condicional de $ GT. La expresión "$ GT: [" $ edad ", 69]" da la edad cuyo valor es mayor que "69". Los resultados para esta expresión se pasan a $ u operador y el $ u operador devuelve el documento que cumple con la condición especificada.
db.Pacientes.agregar(
[
$ Match: _id: ObjectId ("6391C61A4C91E007FB4F0228"),
$ Project:
_ID: ObjectId ("6391C61A4C91E007FB4F0227"),
Edad: 1,
Resultado: $ o: [
$ gt: ["$ edad", 69]
]
]
)
La "edad" que es mayor que "69" es "74" que se muestra en el shell de salida junto con los "resultados" que tiene el valor "verdadero".
Ejemplo 5: MongoDB $ u operador invoca las condiciones
El $ u operador de MongoDB es un operador lógico. Podemos usar este operador lógico con el operador condicional. El $ u operador devuelve los resultados cuando se cumplen las condiciones. Además, podemos invocar más de una condición en el $ u operador desde el cual uno debe ser cierto. Aquí, tenemos una consulta de $ u operador que se especifica con dos condiciones diferentes. La primera condición es "cargas: $ lt: 6000" que devuelve el documento que es menor que el valor de "cargos" de "6000". La condición cargas: "$ gt: 7000" obtiene el documento que es mayor que el valor de "cargos" de "7000".
El $ u operador proporciona el documento coincidente cuando estas condiciones están satisfechas. Luego, especificamos los nombres de los campos que solo se muestran cuando el $ u operador proporciona el documento coincidente.
db.Pacientes.encontrar(
$ o: [
Cargo: $ lt: 6000,
Cargo: $ GT: 7000
]
,
Primer nombre: 1,
Cargos: 1
)
La salida muestra solo los campos de "primer nombre" y "cargos" para los documentos coincidentes.
Ejemplo 6: MongoDB $ u operador sin argumento
Todas las consultas implementadas con el $ u operador se pasan con el valor del argumento. Ahora, definimos la consulta $ o del operador que no ingresa ningún argumento. Cuando se ejecuta el argumento vacío $ o la consulta del operador, evalúa los resultados falsos. Damos una consulta donde se pasa el $ u operación con la expresión vacía.
db.Pacientes.agregar(
[
$ Match: _id: $ in: [ObjectId ("6391C61A4C91E007FB4F0228")],
$ Project:
_ID: ObjectId ("6391C61A4C91E007FB4F0227"),
Resultado: $ o: []
]
)
Como resultado del $ u operador se suministra con un argumento vacío, los resultados indican un valor falso.
Ejemplo 7: MongoDB $ u operador coincide con los valores de la matriz
Insertamos la matriz de "prueba" en los documentos que tienen valores diferentes. Usamos esa matriz para el $ u operador para examinar los resultados. El $ u operador en la siguiente consulta se invoca dentro del método find (). El $ u operador toma la matriz de "prueba" como una expresión. La matriz de "prueba" utiliza el operador $ en el operador para identificar los documentos cuyos valores de campo coinciden con los valores "MRI" y "CT" en la matriz.
db.Pacientes.find ($ o: [test: $ in: ["mri", "ct"]]).bonito()
Se muestra un documento en el shell cuando se ejecuta el operador $ o consulta que muestra que el documento recuperado contiene los valores de matriz especificados.
Conclusión
Este artículo de MongoDB ilustra el uso de una consulta de MongoDB $ u operador para ejecutar la lógica u operaciones en una matriz que incluye dos o más expresiones, así como para recuperar los documentos que coinciden al menos una de las expresiones. El $ u operador se consulta en el shell MongoDB para realizar diferentes operaciones. El $ u operador se usa en operadores condicionales como expresión y devuelve los documentos en función de los estados condicionales.