Módulo: Mongoid::Matcher::FieldExpression Privado

Definido en:
lib/mongoid/matcher/field_expression.rb

Overview

Este módulo es parte de una API privada. Deberías evitar usar este módulo si es posible, ya que puede ser removido o cambiado en el futuro.

Módulo singleton que se utiliza para evaluar si un valor dado en memoria coincide con una expresión de query MSQL relacionada con un campo específico.

Resumen del método de clase colapsar

Detalles del método de clase

.¿corresponden?(existe, valor, condición) ⇒ cierto | falso, Booleano

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Devuelve si un valor satisface una condición.

Parámetros:

  • exists (true | false) —

    Si el valor existe.

  • Valor (objeto) —

    El valor a comprobar.

  • condición (Hash | Objeto) —

    El predicado de condición.

Devuelve:

  • (true | false) —

    Si el valor coincide.

  • (booleano) 


18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# Archivo 'lib/mongoid/matcher/field_expression.rb', línea 18

module_function def coincide?(exists, Valor, condición)
  si condición.is_a?(encriptada)
    condición.¿todos? hacer |k, cond_v|
      k = k.to_s
      si k.start_with?('$')
        si %w[$regex $opciones].incluir?(k)
          a menos que condición.key?('$regex')
            propagar Errors::Consulta no válida, "$regex es necesario si se proporcionan $options: #{Errores::ConsultaNoVálida.truncate_expr(condition)}"
          end

          si k == '$regex'
            si opciones = condición['$options']
              cond_v = caso cond_v
                       cuando Regexp
                         BSON::Regexp::Raw.Nuevo(cond_v.Origen, opciones)
                       cuando BSON::Regexp::Raw
                         BSON::Regexp::Raw.Nuevo(cond_v.Patrón, opciones)
                       else
                         BSON::Regexp::Raw.Nuevo(cond_v, opciones)
                       end
            elsif cond_v.is_a?(String)
              cond_v = BSON::Regexp::Raw.Nuevo(cond_v)
            end

            Operador de campo.Obtener(k).coincide?(exists, Valor, cond_v)
          else
            # $options se comparan como parte de $regex
            true
          end
        else
          Operador de campo.Obtener(k).coincide?(exists, Valor, cond_v)
        end
      elsif Valor.is_a?(encriptada)
        sub_values = Concordante.extract_attribute(Valor, k)
        si sub_values.longitud > 0
          sub_values.any? hacer |sub_v|
            Eq.coincide?(true, sub_v, cond_v)
          end
        else
          Eq.coincide?(false, nulo, cond_v)
        end
      else
        false
      end
    end
  else
    caso condición
    cuando ::Regexp, BSON::Regexp::Raw
      regex.matches_array_or_scalar?(Valor, condición)
    else
      Eq.coincide?(exists, Valor, condición)
    end
  end
end