Módulo: Mongoid::Matcher::EqImpl Privado

Definido en:
lib/mongoid/matcher/eq_impl.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.

Este módulo es utilizado por $eq y otros operadores que necesitan realizar la coincidencia que realiza $eq (por ejemplo, $ne que niega el resultado de $eq). A diferencia de $eq, este módulo toma un operador original como argumento adicional para matches? con el fin de proporcionar los mensajes de excepción correctos que reflejen el operador que se invocó primero.

Resumen del método de clase colapsar

Detalles del método de clase

.matches?(_exists, value, condition, original_operator) ⇒ true | false, 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 cumple una expresión $eq (o similar).

Parámetros:

  • exists (true | false) —

    No se utiliza.

  • Valor (objeto) —

    El valor a comprobar.

  • condición (Objeto | Rango) —

    El predicado de la condición de igualdad.

  • operador original (string) —

    Operador para usar en los mensajes de excepció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
 
# Archivo 'lib/mongoid/matcher/eq_impl.rb', línea 21

module_function def coincide?(_exists, Valor, condición, operador original)
  caso condición
  cuando Rango
    # Dado que $ne invoca $eq, el mensaje de excepción necesita gestionar
    # ambos operadores.
    propagar Errors::Consulta no válida, "El rango no es compatible como argumento para '#{original_operator}'"
  #           if value.is_a?(arreglo)
  # valor.any? { |elt| condition.include?(elt) }
  #           else
  #             condition.include?(valor)
  #           end
  else
    # Al hacer una comparación con objetos de tiempo, compara usando precisión de milisegundos
    si Valor.is_a?(Tiempo) && condición.is_a?(Tiempo)
      time_eq?(Valor, condición)
    elsif Valor.is_a?(Arreglo) && condición.is_a?(Tiempo)
      Valor.map hacer |v|
        si v.is_a?(Tiempo)
          time_rounded_to_millis(v)
        else
          v
        end
      end.incluir?(time_rounded_to_millis(condición))
    else
      Valor == condición ||
        (Valor.is_a?(Arreglo) && Valor.incluir?(condición))
    end
  end
end

.time_eq?(time_a, time_b) ⇒ true | false, 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.

Según https://www.mongodb.com/es/docs/ruby-driver/upcoming/data-formats/bson/#time-instances,

Los tiempos en BSON (y MongoDB) solo pueden tener precisión en milisegundos. Cuando las instancias de Ruby Time se serializan a BSON o Extended JSON, los tiempos se redondean al milisegundo más cercano.

Debido a este piso, se recomienda encarecidamente que las aplicaciones realicen todos los cálculos temporales usando matemáticas enteras, ya que la inexactitud de los cálculos de punto flotante puede producir resultados inesperados.

Por lo tanto, realice una operación similar a la que realiza la gema bson-ruby.

Parámetros:

  • time_a (Time) —

    El primer valor de tiempo.

  • time_b (Time) —

    El segundo valor temporal.

Devuelve:

  • (true | false) —

    Si los dos tiempos son iguales al milisegundo.

  • (booleano) 


65
66
67
 
# Archivo 'lib/mongoid/matcher/eq_impl.rb', línea 65

module_function def time_eq?(time_a, time_b)
  time_rounded_to_millis(time_a) == time_rounded_to_millis(time_b)
end

.time_rounded_to_millis(time) ⇒ true | false

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.

Redondea un valor de tiempo al milisegundo más cercano.

Parámetros:

  • hora (Time) —

    El valor temporal.

Devuelve:

  • (true | false) —

    La hora redondeada al milisegundo.



74
75
76
 
# Archivo 'lib/mongoid/matcher/eq_impl.rb', línea 74

module_function def time_rounded_to_millis(hora)
  (hora._bson_to_i * 1000) + hora.usec.divmod(1000).primero
end