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

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

Overview

Este módulo forma parte de una API privada. Debe evitar su uso siempre que sea posible, ya que podría eliminarse o modificarse 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

.¿coincide?(existe, valor, condición) ⇒ verdadero | falso, booleano

Este método forma parte de una API privada. Debe evitarlo 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) 


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
72
73
74
 
# Archivo 'lib/mongoid/matcher/field_expression.rb', línea 21

module_function def coincide?(exists, Valor, condición)
  si condición.is_a?(Picadillo)
    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 String === cond_v
              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 Picadillo === Valor
        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