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

Incluido en:
Mongoid::Criterios::Consultable
Definido en:
lib/mongoid/criterios/consultable/almacenable.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.

Este módulo encapsula métodos que escriben expresiones de consulta 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.

Colapso del resumen del método de instancia

Detalles del método de instancia

#add_field_expression(campo, valor) ⇒ Almacenable

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Agrega una expresión de campo a la consulta.

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 (Cadena) -

    El nombre del campo.

  • valor (Objeto) -

    El valor del campo.

Devuelve:

  • (Almacenable) —

    ser.



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

def agregar_expresión_de_campo(Campo, valor)
  a no ser que Campo.is_a?(String)
    propagar ArgumentError, "Elcampo debe ser una cadena: #{campo}"
  end

  Si Campo.empezar_con?('$')
    propagar ArgumentError, "Elcampo no puede ser un operador (es decir, comenzar con $): #{campo}"
  end

  Si selector[Campo]
    #Ya tenemos una restricción por el campo que estamos probando
    # para restringir, combinar las restricciones.
    Si valor.is_a?(Picadillo) && selector[Campo].is_a?(Picadillo) &&
      valor.claves.¿todo? { |clave|
        llaves = clave.a_s
        llaves.empezar_con?('$') && !selector[Campo].claves.map(Y:a_s).¿incluir?(llaves)
      }
    entonces
      # Se pueden combinar varios operadores en el mismo campo mediante
      # adding them to the existing hash.
      nuevo_valor = selector[Campo].unir(valor)
      selector.store(Campo, nuevo_valor)
    elsif selector[Campo] != valor
      add_operator_expression('$y ', [{Campo => valor}])
    end
  else
    selector.store(Campo, valor)
  end

  yo
end

#add_logical_operator_expression(operador, op_expr) ⇒ Almacenable

Este método forma parte de una API privada. Debe evitarlo 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 maneja operadores lógicos ($and, $nor y $or). Si se llama con otro operador, genera un error ArgumentError. Tenga en cuenta que en MQL, $not es un operador de campo, no de consulta; por lo tanto, este método no lo maneja.

Este método toma el operador y su expresión de valor por separado para comodidad de quienes lo llaman. Se puede considerar que gestiona el almacenamiento del hash {operator => op_expr}.

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

{'$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 valores (es decir, si el selector está vacío y el operador es $and, op_expr se escribe en el selector con $and, incluso si $and puede, en principio, omitirse). Se espera que dicha simplificación ya haya sido realizada por el código fuente.

This method mutates the receiver.

Parámetros:

  • operador (Cadena) -

    The operator to add.

  • op_expr (Matriz<Hash>) —

    Operator value to add.

Devuelve:

  • (Almacenable) —

    ser.



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
134
135
136
137
138
139
140
141
142
143
 
# Archivo 'lib/mongoid/criteria/queryable/storable.rb', línea 108

def agregar_expresión_de_operador_lógico(operador, op_expr)
  a no ser que operador.is_a?(String)
    propagar ArgumentError, "Operator must be a string: #{operator}"
  end

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

  a no ser que op_expr.is_a?(Arreglo)
    propagar Errors::Consulta no válida, "#{operador} el argumento debe ser una matriz: #{Errors::InvalidQuery.truncate_expr(op_expr)}"
  end

  Si selector.longitud == 1 && selector.claves.primera == operador
    nuevo_valor = selector.values.primera + op_expr
    selector.store(operador, nuevo_valor)
  elsif operador == '$y ' || 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
  else
    # Es necesario agregar otros operadores por separado
    Si selector[operador]
      agregar_expresión_de_operador_lógico('$y ', [operador => op_expr])
    else
      selector.store(operador, op_expr)
    end
  end

  yo
end

#add_one_expression(campo, valor) ⇒ Almacenable

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

    Nombre de campo o nombre de operador.

  • valor (Objeto) -

    Field value or operator expression.

Devuelve:

  • (Almacenable) —

    ser.



223
224
225
226
227
228
229
230
231
232
233
 
# Archivo 'lib/mongoid/criteria/queryable/storable.rb', línea 223

def add_one_expression(Campo, valor)
  a no ser que Campo.is_a?(String)
    propagar ArgumentError, "Elcampo debe ser una cadena: #{campo}"
  end

  Si Campo.empezar_con?('$')
    add_operator_expression(Campo, valor)
  else
    agregar_expresión_de_campo(Campo, valor)
  end
end

#add_operator_expression(operador, op_expr) ⇒ Almacenable

Este método forma parte de una API privada. Debe evitarlo 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 su expresión de valor por separado para comodidad de quienes lo llaman. Se puede considerar que gestiona el almacenamiento del hash {operator => op_expr}.

El valor del operador puede ser de cualquier tipo.

Si el selector ya contiene el operador especificado (en el nivel superior), la nueva condición dada en op_expr se añade a las condiciones existentes para el operador especificado. Esto es sencillo para $and; para otros operadores lógicos, este método añade las nuevas condiciones 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 de nivel de consulta no lógicos como $where y $text, si ya hay un operador de nivel superior con el mismo nombre, op_expr se agrega 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 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 $and puede, en principio, omitirse).

This method mutates the receiver.

Parámetros:

  • operador (Cadena) -

    The operator to add.

  • op_expr (Objeto) -

    Operator value to add.

Devuelve:

  • (Almacenable) —

    ser.



188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
# Archivo 'lib/mongoid/criteria/queryable/storable.rb', línea 188

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

  a no ser que operador.empezar_con?('$')
    propagar ArgumentError, "Eloperador debe comenzar con $: #{operador}"
  end

  Si %w($and $nor $or).¿incluir?(operador)
    return agregar_expresión_de_operador_lógico(operador, op_expr)
  end

  # For other operators, if the operator already exists in the
  # consulta, agregue la nueva condición con $and, de lo contrario agregue el
  # nueva condición al nivel superior.
  Si selector[operador]
    agregar_expresión_de_operador_lógico('$y ', [{operador => op_expr}])
  else
    selector.store(operador, op_expr)
  end

  yo
end