Module: Mongoid::Criteria::Queryable::Storable Private

Incluido en:
Mongoid::Criteria::Queryable
Definido en:
lib/mongoid/criteria/queryable/storable.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 encapsula métodos que escriben expresiones de query en el selector de Criterios.

The query expressions must have already been expanded as necessary. The methods of this module do not perform processing on expression values.

Methods in this module do not handle negation - if negation is needed, it must have already been handled upstream of these methods.

Resumen del método de instancia colapsar

Detalles del método de instancia

#add_field_expression(campo, valor) ⇒ Storable

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.

Agrega una expresión de campo a la query.

field must be a field name, and it must be a string. The upstream code must have converted other field/key types to the simple string form by the time this method is invoked.

value puede ser de cualquier tipo, se escribe en el selector sin cambios.

This method performs no processing on the provided field value.

Mutates the receiver.

Parámetros:

  • Campo (string) —

    El nombre del campo.

  • Valor (objeto) —

    El valor del campo.

Devuelve:

Aumenta:

  • (ArgumentError) 


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
 
# Archivo 'lib/mongoid/criteria/queryable/storable.rb', línea 34

def add_field_expression(Campo, Valor)
  propagar ArgumentError, "El campo debe ser una string: #{campo}" a menos que Campo.is_a?(String)

  propagar ArgumentError, "El campo no puede ser un operador (es decir, comenzar con $): #{field}" si Campo.start_with?('$')

  si selector[Campo]
    # Ya tenemos una restricción por el campo que estamos intentando
    # para restringir, combine las restricciones.
    si Valor.is_a?(encriptada) && selector[Campo].is_a?(encriptada) &&
       Valor.claves.¿todos? hacer |llave|
         key_s = llave.to_s
         key_s.start_with?('$') && !selector[Campo].claves.map(&to_s).incluir?(key_s)
       end
      # Se pueden combinar múltiples operadores en el mismo campo mediante
      # adding them to the existing hash.
      nuevo valor = selector[Campo].fusionar(Valor)
      selector.store(Campo, nuevo valor)
    elsif selector[Campo] != Valor
      add_operator_expression('$and', [ { Campo => Valor } ])
    end
  else
    selector.store(Campo, Valor)
  end

  sí mismo
end

#add_logical_operator_expression(operator, op_expr) ⇒ Almacenable

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.

Adds a logical operator expression to the selector.

Este método solo gestiona operadores lógicos ($and, $nor, y $or). Genera un ArgumentError si se llama con otro operador. Ten en cuenta que en MQL, $not es un operador a nivel de campo y no a nivel de query, por lo que $not no se gestiona mediante este método.

Este método toma el operador y la expresión del valor del operador por separado para la conveniencia de los que llaman. Se puede considerar gestionar el almacenamiento del hash {operator => op_expr}.

Si el selector consiste en una sola condición que es el operador especificado (en el nivel superior), la nueva condición dada en op_expr se agrega a las condiciones existentes para el operador especificado. Por ejemplo, si el selector está actualmente en:

{'$or' => [{'hello' => 'world'}]}

...y el operador es '$or' y op_expr es [{'test' => 123'}], el selector resultante será:

{'$or' => [{'hello' => 'world'}, {'test' => 123}]}

This method always adds the new conditions as additional requirements; in other words, it does not implement the ActiveRecord or/nor behavior where the receiver becomes one of the operands. It is expected that code upstream of this method implements such behavior.

Este método no simplifica los valores (es decir, si el selector está actualmente vacío y el operador es $and, op_expr se escribe en el selector con $and incluso si el $and, en principio, podría omitirse). También se espera que tal simplificación ya haya sido realizada por el código ascendente.

This method mutates the receiver.

Parámetros:

  • operador (string) —

    The operator to add.

  • op_expr (arreglo<Hash>) —

    Operator value to add.

Devuelve:

Aumenta:

  • (ArgumentError) 


101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# Archivo 'lib/mongoid/criteria/queryable/storable.rb', línea 101

def add_logical_operator_expression(operador, op_expr)
  propagar ArgumentError, "Operator must be a string: #{operator}" a menos que operador.is_a?(String)

  a menos que %w[$and $nor $or].incluir?(operador)
    propagar ArgumentError,
          "This method only handles logical operators ($and, $nor, $or). Operator given: #{operator}"
  end

  a menos que op_expr.is_a?(Arreglo)
    propagar Errors::Consulta no válida, "#{operador} el argumento debe ser un arreglo: #{Errores::ConsultaInválida.expr_truncada(exp_op)}"
  end

  si selector.longitud == 1 && selector.claves.primero == operador
    nuevo valor = selector.values.primero + op_expr
    selector.store(operador, nuevo valor)
  elsif operador == '$and' || selector.¿vacío?
    # $and can always be added to top level and it will be combined
    # with whatever other conditions exist.
    si current_value = selector[operador]
      nuevo valor = current_value + op_expr
      selector.store(operador, nuevo valor)
    else
      selector.store(operador, op_expr)
    end
  elsif selector[operador]
    # Es necesario agregar otros operadores por separado
    add_logical_operator_expression('$and', [ { operador => op_expr } ])
  else
    selector.store(operador, op_expr)
  end

  sí mismo
end

#add_one_expression(campo, valor) ⇒ Storable

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.

Adds an arbitrary expression to the query.

El campo puede ser un nombre de campo o un operador.

Mutates the receiver.

Parámetros:

  • Campo (string) —

    Nombre de campo o nombre de operador.

  • Valor (objeto) —

    Field value or operator expression.

Devuelve:

Aumenta:

  • (ArgumentError) 


207
208
209
210
211
212
213
214
215
 
# Archivo 'lib/mongoid/criteria/queryable/storable.rb', línea 207

def add_one_expression(Campo, Valor)
  propagar ArgumentError, "El campo debe ser una string: #{campo}" a menos que Campo.is_a?(String)

  si Campo.start_with?('$')
    add_operator_expression(Campo, Valor)
  else
    add_field_expression(Campo, Valor)
  end
end

#add_operator_expression(operator, op_expr) ⇒ Almacenable

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.

Adds an operator expression to the selector.

Este método toma el operador y la expresión del valor del operador por separado para la conveniencia de los que llaman. Se puede considerar gestionar el almacenamiento del hash {operator => op_expr}.

El valor del operador puede ser de cualquier tipo.

Si el selector ya tiene el operador especificado en él (en el nivel superior), la nueva condición indicada en op_expr se añade a las condiciones existentes para el operador especificado. Esto es sencillo para $and; para otros operadores lógicos, el comportamiento de este método es agregar las condiciones nuevas al operador existente. Por ejemplo, si el selector está actualmente:

{'foo' => 'bar', '$or' => [{'hello' => 'world'}]}

...y el operador es '$or' y op_expr es {'test' => 123'}, el selector resultante será:

{'foo' => 'bar', '$or' => [{'hello' => 'world'}, {'test' => 123}]}

This does not implement an OR between the existing selector and the new operator expression - handling this is the job of upstream methods. This method simply stores op_expr into the selector on the assumption that the existing selector is the correct left hand side of the operation already.

Para operadores no lógicos a nivel de query como $where y $text, si ya existe un operador de nivel superior con el mismo nombre, el op_expr se añade al selector a través de un operador $and de nivel superior, produciendo así un selector que tiene ambos valores de operador.

Este método no simplifica los valores (es decir, si el selector está actualmente vacío y el operador es $and, op_expr se escribe en el selector con $and incluso si el $and, en principio, podría omitirse).

This method mutates the receiver.

Parámetros:

  • operador (string) —

    The operator to add.

  • op_expr (objeto) —

    Operator value to add.

Devuelve:

Aumenta:

  • (ArgumentError) 


178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
 
# Archivo 'lib/mongoid/criteria/queryable/storable.rb', línea 178

def add_operator_expression(operador, op_expr)
  propagar ArgumentError, "Operator must be a string: #{operator}" a menos que operador.is_a?(String)

  propagar ArgumentError, "El operador debe comenzar con $: #{operador}" a menos que operador.start_with?('$')

  return add_logical_operator_expression(operador, op_expr) si %w[$and $nor $or].incluir?(operador)

  # For other operators, if the operator already exists in the
  # query, agregar la nueva condición con $and, de lo contrario agregar la
  # nueva condición al nivel superior.
  si selector[operador]
    add_logical_operator_expression('$and', [ { operador => op_expr } ])
  else
    selector.store(operador, op_expr)
  end

  sí mismo
end