MongoDB O Operador

Mongodb O Operador



Tenemos diferentes operadores lógicos de consulta que están disponibles en MongoDB, y uno de ellos es el operador $or. El operador $or de MongoDB se usa para implementar una operación OR lógica en una matriz que contiene dos o más expresiones y recuperar solo aquellos documentos que coinciden con cualquiera de las expresiones especificadas en la matriz. El operador $or se utiliza para encontrar varias declaraciones en una sola consulta con un solo criterio de documento coincidente. El operador $or facilita la combinación de varias claves y valores.

Cómo usar el operador OR en MongoDB

El operador OR en MongoDB se representa en formato “$or”. El “$o” se utiliza para encerrar las múltiples expresiones entre corchetes en los que se realiza la operación lógica OR. Usamos el operador $or en la colección MongoDB. Creamos la colección MongoDB que se titula “Pacientes”. La colección “Pacientes” se inserta con los múltiples documentos sobre los que realizamos el operador $or. Los siguientes documentos se insertan en MongoDB invocando el método insertMany():

db.Patients.insertMany ( [
      {
          'Primer nombre' : 'Jennifer' ,
          'Apellido' : 'Josué' ,
              'Años' : 44 ,
          'Número de teléfono' : 43400517 ,
          'Cita' : 'Dentista' ,
            'Cargos' : 2000 ,
          'Prueba' : [ 'Radiografía' , 'Sangre' , 'pulpa' ]
      } ,
      {
          'Primer nombre' : 'Tomás' ,
          'Apellido' : 'steven' ,
                'Años' : 74 ,
          'Número de teléfono' : 39034694 ,
          'Día de la cita' : 'Cirujano' ,
          'Cargos' : 6000 ,
          'Prueba' : [ 'Electivo' , 'PPT' ]
      } ,
      {
          'Primer nombre' : 'Charles' ,
          'Apellido' : 'Daniel' ,
              'Años' : 35 ,
          'Número de teléfono' : 65712165 ,
          'Cita' : 'Médico cardiólogo' ,
          'Cargos' : 2000 ,
          'Prueba' : [ 'CONNECTICUT' , 'resonancia magnética' ]
      } ,
      {          
          'Primer nombre' : 'Michelle' ,
          'Apellido' : 'Pablo' ,
              'Años' : 51 ,
          'Número de teléfono' : 54399288 ,
          'Cita' : 'Dermatólogo' ,
          'Cargos' : 8000 ,
          'Prueba' : [ 'Biopsias de piel' , 'Luz de madera' , 'Raspado de piel' ]
              } ,

      {
          'Primer nombre' : 'Andrés' ,
          'Apellido' : 'Alemán' ,
                'Años' : 69 ,
          'Número de teléfono' : 6108100 ,
          'Cita' : 'Médico cardiólogo' ,
          'Cargos' : 7000 ,
          'Prueba' : [ 'ECG' , 'Glucosa en sangre' , 'Ultrasonido' ]
          }
  ] )

La salida de los documentos insertados previamente reconoce 'verdadero' y proporciona los valores 'insertedIds' para cada documento.









Ejemplo 1: Operador $OR de MongoDB para hacer coincidir los documentos

La consulta básica del operador $or de MongoDB se implementa aquí, lo que demuestra el funcionamiento de este operador en MongoDB. Aquí, definimos una consulta con el método find(). El método find() se especifica aún más con el operador $or. El operador $or toma dos campos, 'Cita' y 'Cargos', que se asignan con los valores. El operador $or hace coincidir el valor del campo y recupera solo aquellos documentos cuyos valores coinciden con los valores del campo. La estructura de consulta del operador $or se proporciona a continuación:



db.Pacientes.encontrar ( { $o : [ { Cita: 'Dermatólogo' } ,
                    { Cargos: 7000 } ] } ) .bastante ( )

Buscamos los documentos cuya “Cita” es con “Dermatólogo” y cuyos “Cargos” son “7000”. El operador $or encuentra resultados verdaderos de ambos valores de campo y devuelve los documentos coincidentes en la salida.





Ejemplo 2: Operador $OR de MongoDB para hacer coincidir los documentos inexistentes

En la consulta anterior del operador $or, buscamos los documentos coincidentes. Ahora, recuperamos el documento inexistente de la colección 'Paciente'. La siguiente consulta del operador $or toma el documento cuyo “FirstName” es “Charles” y la “Cita” es con el “Médico”. El operador $or hace coincidir estos valores de campo dentro de la colección 'Pacientes' y genera los resultados después de la coincidencia.



db.Pacientes.encontrar ( { $o : [ { 'Primer nombre' : 'Charles' } , { 'Cita' : 'Médico' } ] } ) .bastante ( )

El operador $or 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 operador $or solo devuelve el documento del campo coincidente que es 'Paciente' como salida.

Ejemplo 3: Operador $OR de MongoDB con varios argumentos

Proporcionamos dos argumentos en las consultas anteriores del operador $or. Aquí, pasamos más de dos argumentos como la expresión del operador $or. Recuperamos el documento que coincide con cualquiera de los valores del campo 'Edad' que se le asignan. El requisito del operador $or es el mismo para los múltiples argumentos de que una de las expresiones debe ser verdadera. La consulta de múltiples argumentos en el operador $or se da de la siguiente manera:

db.Pacientes.encontrar ( { 'Cita' : 'Médico cardiólogo' , $o : [ { 'Años' : 20 } , { 'Años' : 35 } , { 'Años' : 69 } ] } )

Allí tenemos dos resultados coincidentes que se obtienen del operador $or. Los valores de 'Edad' que son '35' y '69' se comparan con los documentos de 'Pacientes' que obtiene el operador $or y se muestran en el caparazón.

Ejemplo 4: Operador $OR de MongoDB con agregación

El método agregado en MongoDB combina los registros en una colección. Por lo tanto, se pueden utilizar para diferentes operaciones. Realizamos el operador $or en el método de agregación que evalúa una o más expresiones y devuelve verdadero si alguna de ellas se evalúa como verdadero. En caso contrario, la declaración se considera falsa.

Tengamos la consulta del operador de agregación $or donde primero invocamos el método de agregado() que luego implementa el $match y el $project que se especifica con el valor _id para que coincida con el documento. Luego, configuramos el campo “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 'Resultados' que tiene la operación $or. El operador $or toma la declaración condicional de $gt. La expresión “$gt:[“$Age”, 69]” da la edad cuyo valor es mayor que “69”. Los resultados de esta expresión se pasan al operador $or y el operador $or devuelve el documento que cumple la condición especificada.

db.Pacientes.agregado (
    [
      { $coincidencia : { _id: ID de objeto ( '6391c61a4c91e007fb4f0228' ) } } ,
      { $proyecto : {
_id: ID de objeto ( '6391c61a4c91e007fb4f0227' ) ,
Años: 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: el operador $OR de MongoDB invoca las condiciones

El operador $or de MongoDB es un operador lógico. Podemos usar este operador lógico con el operador condicional. El operador $or devuelve los resultados cuando se cumplen las condiciones. Además, podemos invocar más de una condición en el operador $or de las cuales una debe ser verdadera. Aquí tenemos una consulta del operador $or que se especifica con dos condiciones diferentes. La primera condición es '{Cargos:{$lt: 6000}}' que devuelve el documento que es menor que el valor de 'Cargos' de '6000'. La condición {Cargos:“$gt: 7000”} obtiene el documento que es mayor que el valor de “Cargos” de “7000”.

El operador $or proporciona el documento coincidente cuando se cumplen estas condiciones. Luego, especificamos los nombres de los campos que solo se muestran cuando el operador $or da el documento coincidente.

db.Pacientes.encontrar ( {
    $o : [
        { Cargos: { $lt : 6000 } } ,
        { Cargos: { $ gt : 7000 } }
    ]
} , {
Primer nombre: 1 ,
Cargos: 1
} )

La salida muestra solo los campos 'Nombre' y 'Cargos' para los documentos coincidentes.

Ejemplo 6: Operador MongoDB $OR sin argumento

Todas las consultas implementadas con el operador $or se pasan con el valor del argumento. Ahora, definimos la consulta del operador $or 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 la operación $or con la expresión vacía.

db.Pacientes.agregado (
    [
      { $coincidencia : { _identificación: { $ en : [ ID de objeto ( '6391c61a4c91e007fb4f0228' ) ] } } } ,
      { $proyecto : {
_id: ID de objeto ( '6391c61a4c91e007fb4f0227' ) ,
Resultado: { $o : [ ] } }
          }
    ]
)

Como el operador $or recibe un argumento vacío, los resultados indican un valor falso.

Ejemplo 7: el operador $OR de MongoDB coincide con los valores de la matriz

Insertamos la matriz 'Prueba' en los documentos que tienen diferentes valores. Usamos esa matriz para que el operador $or examine los resultados. El operador $or en la siguiente consulta se invoca dentro del método find(). El operador $or toma la matriz 'Prueba' como una expresión. La matriz 'Prueba' utiliza el operador $in para identificar los documentos cuyos valores de campo coinciden con los valores 'MRI' y 'CT' de la matriz.

db.Pacientes.encontrar ( { $o : [ { Prueba: { $ en : [ 'resonancia magnética' , 'CONNECTICUT' ] } } ] } ) .bastante ( )

Se muestra un documento en el shell cuando se ejecuta el operador de consulta $or, lo 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 operador $or de MongoDB para ejecutar las operaciones lógicas OR en una matriz que incluye dos o más expresiones, así como para recuperar los documentos que coinciden con al menos una de las expresiones. El operador $or se consulta en el shell de MongoDB para realizar diferentes operaciones. El operador $or se usa en operadores condicionales como una expresión y devuelve los documentos en función de las declaraciones condicionales.