Módulo: Mongoid::Criteria::Queryable::Selectable

Ampliado por:
Macrosable
Definido en:
lib/mongoid/criterios/consultable/seleccionable.rb

Overview

Un seleccionable consultable es seleccionable, ya que permite seleccionar documentos de la base de datos. El módulo seleccionable le proporciona toda la funcionalidad relacionada con la creación de selectores de MongoDB.

Colapso delresumen constante

CADENA DE LÍNEA =

Constante para una geometría LineString.

"LineString"
PUNTO =

Constante para un punto $geometría.

"Punto"
POLÍGONO =

Constante para una $geometry Polígono.

"Polígono"

Colapso delresumen de atributos de instancia

Colapso delresumen del método de clase

Colapso del resumen del método de instancia

Métodos incluidos en Macroable

clave

Detalles de los atributos de instancia

#negando ⇒ Objeto

Devuelve el valor del atributo negado.



25
26
27
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 25

def negando
  @negando
end

#negando Si se niega la siguiente expresión.(Si) ⇒ Objeto 



25
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 25

attr_accessor :negando, :selector

#selector ⇒ Objeto

Devuelve el valor del selector de atributos.



25
26
27
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 25

def selector
  @selector
end

#selector El selector de consultas.(Thequeryselector.) ⇒ Objeto 



25
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 25

attr_accessor :negando, :selector

Detalles del método de clase

.forwardables ⇒ Matriz<Símbolo><Symbol>

Obtenga los métodos en el seleccionable que se pueden reenviar desde un modelo.

Ejemplos:

Obtenga los métodos reenviables.

Selectable.forwardables

Devuelve:

  • (Matriz<Símbolo><Symbol>) —

    Los nombres de los métodos reenviables.



945
946
947
948
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 945

def reenviables
  public_instance_methods(false) -
    [ :negando, :negando=, :¿negando?, :selector, :selector= ]
end

Detalles del método de instancia

#todos(*criterios) ⇒ Seleccionable También conocido como: all_in

Añade el criterio $all.

Ejemplos:

Añade el criterio.

selectable.all(field: [ 1, 2 ])

Ejecuta un $all en una query donde.

selectable.where(:field.all => [ 1, 2 ])

Parámetros:

  • *criterios (Hachís...) —

    El par(es) clave-valor para la coincidencia de $all.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



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

def todos(*criterios)
  Si criterios.¿vacío?
    return clon.grifo hacer |Consulta|
      Consulta.reset_strategies!
    end
  end

  criterios.inyectar(clon) hacer |Consulta, condición|
    Si condición.nil?
      propagar Errors::CriteriosArgumentoRequerido, : Todos
    end

    condición = expandir_condición_a_valores_de_matriz(condición)

    Si estrategia
      Enviar(estrategia, condición, "$todos")
    else
      condición.inyectar(Consulta) hacer |_consulta, (Campo, valor)|
        v = {'$all' => valor}
        Si ¿negando?
          v = {' $no ' => v}
        end
        _consulta.agregar_expresión_de_campo(Campo.a_s, v)
      end
    end
  end.reset_strategies!
end

#y(*criterios) ⇒ Seleccionable También conocido como: all_of

Agrega el criterio $and.

Ejemplos:

Añade el criterio.

selectable.and({ field: value }, { other: value })

Parámetros:

  • *criterios ([ Hash | Criterios | Matriz<Hash | Criterios> ]...) —

    Coincidencias de múltiples pares clave/valor u objetos Criterios que deben coincidir todos para devolver resultados.

Devuelve:

  • (Seleccionable) —

    El nuevo seleccionable.



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 78

def y (*criterios)
  _matrices aplanadas mongoid(criterios).inyectar(yo.clon) hacer |C, noticias|
    Si noticias.is_a?(Seleccionable)
      noticias = noticias.selector
    end
    normalizado = _teclas de expansión de mongoid(noticias)
    normalizado.cada hacer |k, v|
      k = k.a_s
      Si C.selector[k]
        #Ya existe una condición en k.
        # Si v es un operador y todas las condiciones existentes son
        # también operadores, y v no está presente en las condiciones existentes,
        # podemos añadir a las condiciones existentes.
        # De lo contrario, utilice $and.
        Si v.is_a?(Picadillo) &&
          v.longitud == 1 &&
          (nuevo_k = v.claves.primera).empezar_con?('$') &&
          (existing_kv = C.selector[k]).is_a?(Picadillo) &&
          !existing_kv.key?(nuevo_k) &&
          existing_kv.claves.¿todo? { |sub_k| sub_k.empezar_con?('$') }
        entonces
          fusionado_v = C.selector[k].unir(v)
          C.selector.store(k, fusionado_v)
        else
          C = C.Enviar(:__multi__, [k => v], '$y ')
        end
      else
        C.selector.store(k, v)
      end
    end
    C
  end
end

#any_of(*criteria) ⇒ Selectable

Añade una disyunción de los argumentos como una restricción adicional a los criterios ya existentes en el receptor.

Utilice or para hacer que el receptor sea uno de los operandos de disyunción.

Cada argumento puede ser un hash, un objeto Criteria, un array de objetos hash o Criteria, o un array anidado. Los arrays anidados se aplanarán y podrán tener cualquier profundidad. Pasar arrays está obsoleto.

Ejemplos:

Agregue la selección $or donde ambos campos deben tener los valores especificados.

selectable.any_of(field: 1, field: 2)

Agregue la selección $or donde cualquiera de los valores coincida es suficiente.

selectable.any_of({field: 1}, {field: 2})

Igual que el ejemplo anterior pero utilizando el ajuste de matriz obsoleto.

selectable.any_of([{field: 1}, {field: 2}])

Igual que el ejemplo anterior, también obsoleto.

selectable.any_of([{field: 1}], [{field: 2}])

Parámetros:

  • *criterios ([ Hash | Criterios | Matriz<Hash | Criterios> ]...) —

    Coincidencias con múltiples pares clave-valor u objetos Criterios, o matrices de estos. El paso de matrices está obsoleto.

Devuelve:

  • (Seleccionable) —

    El nuevo seleccionable.



674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 674

def any_of(*criterios)
  criterios = _matrices aplanadas mongoid(criterios)
  caso criterios.longitud
  Cuando 0
    clon
  Cuando 1
    # Cuando tenemos un único criterio, any_of se comporta como y.
    # Nota: los criterios pueden ser un objeto de consulta, lo cual no hace el método where.
    # no es compatible.
    yo.y (*criterios)
  else
    # Cuando tenemos varios criterios, combínalos todos con $or
    # y agrega el resultado a sí mismo.
    expresiones = criterios.map hacer |criterion|
      Si criterion.is_a?(Seleccionable)
        _teclas de expansión de mongoid(criterion.selector)
      else
        Picadillo[criterion.map hacer |k, v|
          Si k.is_a?(Símbolo)
            [k.a_s, v]
          else
            [k, v]
          end
        end]
      end
    end
    yo.y ('$o ' => expresiones)
  end
end

#between(criterio) ⇒ Seleccionable

Añade la selección de rango.

Ejemplos:

Coincidencia de resultados dentro de un único rango.

selectable.between(field: 1..2)

Coincidencia de resultados entre múltiples rangos.

selectable.between(field: 1..2, other: 5..7)

Parámetros:

  • criterion (Hash) —

    Múltiples pares de clave/rango.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



124
125
126
127
128
129
130
131
132
133
134
135
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 124

def entre(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :entre
  end

  selección(criterion) hacer |selector, Campo, valor|
    selector.store(
      Campo,
      { "$gte" => valor.min, "$lte" => valor.máximo }
    )
  end
end

#elem_match(criterio) ⇒ Seleccionable

Seleccione con un $elemMatch.

Ejemplos:

Añadir criterio para una única coincidencia.

selectable.elem_match(field: { name: "value" })

Añadir criterio para coincidencias múltiples.

selectable.elem_match(
  field: { name: "value" },
  other: { name: "value"}
)

Ejecute un $elemMatch en una consulta where.

selectable.where(:field.elem_match => { name: "value" })

Parámetros:

  • criterion (Hash) —

    Los pares campo/partido.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



154
155
156
157
158
159
160
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 154

def coincidencia de elementos(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :elem_match
  end

  y_con_operador(criterion, "$elemMatch")
end

#eq(criterio) ⇒ Seleccionable

Añade el criterio $eq al selector.

Ejemplos:

Añade el criterio $eq.

selectable.eq(age: 60)

Ejecutar un $eq en una consulta where.

selectable.where(:field.eq => 10)

Parámetros:

  • criterion (Hash) —

    Los pares campo/valor a comprobar.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



257
258
259
260
261
262
263
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 257

def eq(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :eq
  end

  y_con_operador(criterion, "$eq")
end

#existe(criterio) ⇒ Seleccionable

Agregue la selección $exists.

Ejemplos:

Añade una única selección.

selectable.exists(field: true)

Añadir múltiples selecciones.

selectable.exists(field: true, other: false)

Ejecutar un $exists en una consulta where.

selectable.where(:field.exists => true)

Parámetros:

  • criterion (Hash) —

    Comprobación de existencia del campo/booleano.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



177
178
179
180
181
182
183
184
185
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 177

def exists(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :existe
  end

  anulación tipificada(criterion, "$existe") hacer |valor|
    Mongoid::Booleano.evolucionar(valor)
  end
end

#geo_spatial(criterio) ⇒ Seleccionable

Nota:

Las únicas formas geométricas válidas para un $geoIntersects son::intersects_line, :intersects_point y :intersects_polygon.

Nota:

Las únicas opciones válidas para una consulta $geoWithin son la forma de la geometría :within_polygon y el operador :within_box.

Nota:

El operador :within_box de la consulta $geoWithin requiere el par de coordenadas inferior izquierda (suroeste) como primer argumento y el superior derecha (noreste) como segundo. Importante: Al pasar la latitud y la longitud, se espera que la longitud sea el primer elemento del par de coordenadas. Fuente: www.mongodb.com/es/docs/manual/reference/operator/query/box

Agregue una selección $geoIntersects o $geoWithin. Para expandir los criterios, utilice los operadores de símbolo como se muestra en los ejemplos.

Ejemplos:

Agregar un criterio de intersección geográfica para una línea.

query.geo_spatial(:location.intersects_line => [[ 1, 10 ], [ 2, 10 ]])

Agregar un criterio de intersección geográfica para un punto.

query.geo_spatial(:location.intersects_point => [[ 1, 10 ]])

Agregar un criterio de intersección geográfica para un polígono.

query.geo_spatial(:location.intersects_polygon => [[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]])

Añade un criterio geográfico para un polígono.

query.geo_spatial(:location.within_polygon => [[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]])

Añade un criterio geográfico para un cuadro.

query.geo_spatial(:location.within_box => [[ 1, 10 ], [ 2, 10 ])

Parámetros:

  • criterion (Hash) —

    El criterio.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



224
225
226
227
228
229
230
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 224

def geo_espacial(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :geo_espacial
  end

  __unir__(criterion)
end

#gt(criterio) ⇒ Seleccionable

Añade el criterio $gt al selector.

Ejemplos:

Añade el criterio $gt.

selectable.gt(age: 60)

Ejecute un $gt en una consulta where.

selectable.where(:field.gt => 10)

Parámetros:

  • criterion (Hash) —

    Los pares campo/valor a comprobar.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



277
278
279
280
281
282
283
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 277

def gt(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :gt
  end

  y_con_operador(criterion, "$gt")
end

#gte(criterio) ⇒ Seleccionable

Añade el criterio $gte al selector.

Ejemplos:

Añade el criterio $gte.

selectable.gte(age: 60)

Ejecutar un $gte en una consulta where.

selectable.where(:field.gte => 10)

Parámetros:

  • criterion (Hash) —

    Los pares campo/valor a comprobar.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



297
298
299
300
301
302
303
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 297

def gte(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :gte
  end

  y_con_operador(criterion, "$gte")
end

#en(condición) ⇒ Seleccionable También conocido como: any_in

Agrega la selección $in a lo seleccionable.

Ejemplos:

Agregue $in selección en una matriz.

selectable.in(age: [ 1, 2, 3 ])

Agregue $in selección en un rango.

selectable.in(age: 18..24)

Ejecuta un $in en una consulta where.

selectable.where(:field.in => [ 1, 2, 3 ])

Parámetros:

  • condición (Hash) —

    Los pares de criterios campo/valor.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 320

def in(condición)
  Si condición.nil?
    propagar Errors::CriteriosArgumentoRequerido, :en
  end

  condición = expandir_condición_a_valores_de_matriz(condición)

  Si estrategia
    Enviar(estrategia, condición, "$en")
  else
    condición.inyectar(clon) hacer |Consulta, (Campo, valor)|
      v = {'$in' => valor}
      Si ¿negando?
        v = {' $no ' => v}
      end
      Consulta.agregar_expresión_de_campo(Campo.a_s, v)
    end.reset_strategies!
  end
end

#lt(criterio) ⇒ Seleccionable

Añade el criterio $lt al selector.

Ejemplos:

Agregar el criterio $lt.

selectable.lt(age: 60)

Ejecute un $lt en una consulta where.

selectable.where(:field.lt => 10)

Parámetros:

  • criterion (Hash) —

    Los pares campo/valor a comprobar.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



353
354
355
356
357
358
359
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 353

def es(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :lt
  end

  y_con_operador(criterion, "$lt")
end

#lte(criterio) ⇒ Seleccionable

Añade el criterio $lte al selector.

Ejemplos:

Añade el criterio $lte.

selectable.lte(age: 60)

Ejecutar un $lte en una consulta where.

selectable.where(:field.lte => 10)

Parámetros:

  • criterion (Hash) —

    Los pares campo/valor a comprobar.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



373
374
375
376
377
378
379
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 373

def lte(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :lte
  end

  y_con_operador(criterion, "$lte")
end

#distancia_máxima(criterio) ⇒ Seleccionable

Añade una selección $maxDistance a lo seleccionable.

Ejemplos:

Agregue la selección $maxDistance.

selectable.max_distance(location: 10)

Parámetros:

  • criterion (Hash) —

    Los pares campo/distancia.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



390
391
392
393
394
395
396
397
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 390

def distancia máxima(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :distancia máxima
  end

  # $maxDistance debe proporcionarse junto con $near
  __agregar__(criterion, "$DistanciaMáxima")
end

#mod(criterio) ⇒ Seleccionable

Agrega la selección $mod a lo seleccionable.

Ejemplos:

Añade la selección $mod.

selectable.mod(field: [ 10, 1 ])

Ejecutar un $mod en una consulta where.

selectable.where(:field.mod => [ 10, 1 ])

Parámetros:

  • criterion (Hash) —

    Las selecciones de campo/mod.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



410
411
412
413
414
415
416
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 410

def mod(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :mod
  end

  y_con_operador(criterion, "$mod")
end

#ne(criterio) ⇒ Seleccionable También conocido como: excluye

Agrega una selección $ne a lo seleccionable.

Ejemplos:

Consulta de un valor $ne para algo.

selectable.ne(field: 10)

Ejecutar un $ne en una consulta where.

selectable.where(:field.ne => "value")

Parámetros:

  • criterion (Hash) —

    Las selecciones de campo/ne.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



430
431
432
433
434
435
436
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 430

def ne(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :ne
  end

  y_con_operador(criterion, "$ne")
end

#cerca(criterio) ⇒ Seleccionable

Agrega un criterio $near a una selección geográfica.

Ejemplos:

Añade la selección $near.

selectable.near(location: [ 23.1, 12.1 ])

Ejecute un $near en una consulta where.

selectable.where(:field.near => [ 23.2, 12.1 ])

Parámetros:

  • criterion (Hash) —

    El par campo/ubicación.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



451
452
453
454
455
456
457
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 451

def near(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :cerca
  end

  y_con_operador(criterion, "$cerca")
end

#near_sphere(criterio) ⇒ Seleccionable

Agrega un criterio $nearSphere a una selección geográfica.

Ejemplos:

Agregue la selección $nearSphere.

selectable.near_sphere(location: [ 23.1, 12.1 ])

Ejecute un $nearSphere en una consulta where.

selectable.where(:field.near_sphere => [ 10.11, 3.22 ])

Parámetros:

  • criterion (Hash) —

    El par campo/ubicación.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



471
472
473
474
475
476
477
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 471

def cerca_de_la_esfera(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :near_sphere
  end

  y_con_operador(criterion, "$nearSphere")
end

#¿negando? ⇒ verdadero | falso

¿El elemento seleccionable actual está negando la siguiente selección?

Ejemplos:

¿La selección es negadora?

selectable.negating?

Devuelve:

  • (verdadero | falso) —

    Si el campo seleccionable está negando.



535
536
537
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 535

def ¿negando?
  !!negando
end

#nin(condición) ⇒ Seleccionable También conocido como: not_in

Agrega la selección $nin a lo seleccionable.

Ejemplos:

Agregue la selección $nin en una matriz.

selectable.nin(age: [ 1, 2, 3 ])

Agregue la selección $nin en un rango.

selectable.nin(age: 18..24)

Ejecutar un $nin en una consulta where.

selectable.where(:field.nin => [ 1, 2, 3 ])

Parámetros:

  • condición (Hash) —

    Los pares de criterios campo/valor.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 494

def nin(condición)
  Si condición.nil?
    propagar Errors::CriteriosArgumentoRequerido, :nin
  end

  condición = expandir_condición_a_valores_de_matriz(condición)

  Si estrategia
    Enviar(estrategia, condición, "$nin")
  else
    condición.inyectar(clon) hacer |Consulta, (Campo, valor)|
      v = {'$nin' => valor}
      Si ¿negando?
        v = {' $no ' => v}
      end
      Consulta.agregar_expresión_de_campo(Campo.a_s, v)
    end.reset_strategies!
  end
end

#ninguno_de(*criterios) ⇒ Seleccionable

Niega los argumentos, restringiendo la consulta sólo a aquellos documentos que NO coinciden con los argumentos.

Ejemplos:

Excluir un solo criterio.

selectable.none_of(name: /Bob/)

Excluir múltiples criterios.

selectable.none_of(name: /Bob/, country: "USA")

Excluir múltiples criterios como una matriz.

selectable.none_of([{ name: /Bob/ }, { country: "USA" }])

Parámetros:

  • *criterios ([ Hash | Criterios ]...) —

    El par clave/valor coincide con los objetos Criterios que se van a negar.

Devuelve:

  • (Seleccionable) —

    El nuevo seleccionable.



601
602
603
604
605
606
607
608
609
610
611
612
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 601

def ninguno_de(*criterios)
  criterios = _matrices aplanadas mongoid(criterios)
  return dup Si criterios.¿vacío?

  expresiones = criterios.map hacer |criterion|
    _teclas de expansión de mongoid(
        criterion.is_a?(Seleccionable) ?
          criterion.selector : criterion)
  end

  yo.y ('$nor' => expresiones)
end

#ni(*criterios) ⇒ Seleccionable

Agrega la selección $nor a lo seleccionable.

Ejemplos:

Agregue la selección $nor.

selectable.nor(field: 1, field: 2)

Parámetros:

  • *criterios ([ Hash | Criterios | Matriz<Hash | Criterios> ]...) —

    Coincidencias de múltiples pares clave/valor u objetos Criterios.

Devuelve:

  • (Seleccionable) —

    El nuevo seleccionable.



525
526
527
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 525

def ni(*criterios)
  _mongoid_add_operación_de_nivel_superior('$nor', criterios)
end

#no(*criterios) ⇒ Seleccionable

Niega los argumentos o la siguiente selección si no se dan argumentos.

Ejemplos:

Niega la siguiente selección.

selectable.not.in(field: [ 1, 2 ])

Añade el criterio $not.

selectable.not(name: /Bob/)

Ejecutar un $not en una consulta where.

selectable.where(:field.not => /Bob/)

Parámetros:

  • *criterios ([ Hash | Criterios ]...) —

    El par clave/valor coincide con los objetos Criterios que se van a negar.

Devuelve:

  • (Seleccionable) —

    El nuevo seleccionable.



554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 554

def no(*criterios)
  Si criterios.¿vacío?
    dup.grifo { |Consulta| Consulta.negando = !Consulta.negando }
  else
    criterios.compact.inyectar(yo.clon) hacer |C, noticias|
      Si noticias.is_a?(Seleccionable)
        noticias = noticias.selector
      end
      _teclas de expansión de mongoid(noticias).cada hacer |k, v|
        k = k.a_s
        Si C.selector[k] || k.empezar_con?('$')
          C = C.Enviar(:__multi__, [{'$nor' => [{k => v}]}], '$y ')
        else
          Si v.is_a?(Picadillo)
            C = C.Enviar(:__multi__, [{'$nor' => [{k => v}]}], '$y ')
          else
            Si v.is_a?(Regexp)
              operador negado = ' $no '
            else
              operador negado = '$ne'
            end
            C = C.Enviar(:__override__, {k => v}, operador negado)
          end
        end
      end
      C
    end
  end
end

#o(*criterio) ⇒ Seleccionable

Crea una disyunción utilizando $or a partir de los criterios existentes en el receptor y los argumentos proporcionados.

Este comportamiento (el receptor se convierte en uno de los operandos de disyunción) coincide con el comportamiento or de ActiveRecord.

Utilice any_of para agregar una disyunción de los argumentos como una restricción adicional a los criterios ya existentes en el receptor.

Cada argumento puede ser un hash, un objeto Criteria, un array de objetos hash o Criteria, o un array anidado. Los arrays anidados se aplanarán y podrán tener cualquier profundidad. Pasar arrays está obsoleto.

Ejemplos:

Agregue la selección $or donde ambos campos deben tener los valores especificados.

selectable.or(field: 1, field: 2)

Agregue la selección $or donde cualquiera de los valores coincida es suficiente.

selectable.or({field: 1}, {field: 2})

Igual que el ejemplo anterior pero utilizando el ajuste de matriz obsoleto.

selectable.or([{field: 1}, {field: 2}])

Igual que el ejemplo anterior, también obsoleto.

selectable.or([{field: 1}], [{field: 2}])

Parámetros:

  • *criterios ([ Hash | Criterios | Matriz<Hash | Criterios> ]...) —

    Coincidencias con múltiples pares clave-valor u objetos Criterios, o matrices de estos. El paso de matrices está obsoleto.

Devuelve:

  • (Seleccionable) —

    El nuevo seleccionable.



644
645
646
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 644

def or(*criterios)
  _mongoid_add_operación_de_nivel_superior('$o ', criterios)
end

#text_search(términos, opts = nulo) ⇒ Seleccionable

Nota:

Según www.mongodb.com/es/docs/manual/reference/operator/query/text,actualmente no es posible proporcionar múltiples condiciones de búsqueda de texto en una consulta. Mongoid generará dicha consulta, pero el servidor devolverá un error al intentar ejecutarla.

Construya un selector de búsqueda de texto.

Ejemplos:

Construya un selector de búsqueda de texto.

selectable.text_search("testing")

Construya un selector de búsqueda de texto con opciones.

selectable.text_search("testing", :$language => "fr")

Parámetros:

  • términos (Cadena | Símbolo) —

    Una cadena de términos que MongoDB analiza y utiliza para consultar el índice de texto.

  • opta (Hash) (predeterminado: nulo) —

    Opciones de búsqueda de texto. Consulte la documentación de MongoDB para ver las opciones.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 776

def búsqueda de texto(términos, opta = nulo)
  Si términos.nil?
    propagar Errors::CriteriosArgumentoRequerido, :términos
  end

  clon.grifo hacer |Consulta|
    criterion = {'$text' => { '$búsqueda ' => términos }}
    criterion['$text'].¡unir!(opta) Si opta
    Si Consulta.selector['$text']
      # Según https://www.mongodb.com/es/docs/manual/reference/operator/query/text/
      # Actualmente no se admiten múltiples expresiones de $texto.
      # Servidor MongoDB, pero crea la consulta correctamente en lugar de
      # sobrescribiendo la condición de búsqueda de texto anterior con la actual
      # dado uno.
      Mongoid.logger.advertir('El servidor no admite actualmente múltiples expresiones $text por consulta')
      Consulta.selector = {'$y ' => [Consulta.selector]}.unir(criterion)
    else
      Consulta.selector = Consulta.selector.unir(criterion)
    end
  end
end

#donde(*criterios) ⇒ Seleccionable

Este es el punto de entrada general para la mayoría de las consultas de MongoDB. Crea un campo estándar: selección de valor y selección expandida mediante métodos hash, o una selección $where si se proporciona una cadena.

Ejemplos:

Añadir una selección estándar.

selectable.where(name: "syd")

Agregar una selección de JavaScript.

selectable.where("this.name == 'syd'")

Parámetros:

  • *criterion ([ Hash | Cadena ]... ) —

    La selección estándar o cadena de javascript.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 812

def donde(*criterios)
  criterios.inyectar(clon) hacer |Consulta, criterion|
    Si criterion.nil?
      propagar Errors::CriteriosArgumentoRequerido, :dónde
    end

    # Necesitamos guardar el criterio en una variable de instancia para
    # Los métodos modificables saben cómo crear un objeto polimórfico.
    # Tenga en cuenta que este método en principio acepta múltiples criterios,
    # pero solo el primero se almacenará en @criterion. Este
    # funciona bien porque los métodos first_or_create etc.
    # solo especifique un criterio para #where.
    @criterion = criterion
    Si criterion.is_a?(String)
      consulta_js(criterion)
    else
      consulta_expr(criterion)
    end
  end.reset_strategies!
end

#with_size(criterio) ⇒ Seleccionable

Nota:

Este método se llama #with_size para no entrar en conflicto con ningún método #size existente en enumerables o símbolos.

Agregue una selección de $size para los campos de la matriz.

Ejemplos:

Agregue la selección $size.

selectable.with_size(field: 5)

Ejecutar un $size en una consulta where.

selectable.where(:field.with_size => 10)

Parámetros:

  • criterion (Hash) —

    El criterio de pares campo/tamaño.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



718
719
720
721
722
723
724
725
726
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 718

def con_tamaño(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :con_tamaño
  end

  anulación tipificada(criterion, "$size") hacer |valor|
    ::entero.evolucionar(valor)
  end
end

#with_type(criterio) ⇒ Seleccionable

Nota:

vurl.me/PGOU contiene una lista de todos los tipos.

Agrega una selección de tipo $ a lo seleccionable.

Ejemplos:

Agregue la selección $type.

selectable.with_type(field: 15)

Ejecutar un $type en una consulta where.

selectable.where(:field.with_type => 15)

Parámetros:

  • criterion (Hash) —

    Los pares campo/tipo.

Devuelve:

  • (Seleccionable) —

    El seleccionable clonado.



744
745
746
747
748
749
750
751
752
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 744

def con_tipo(criterion)
  Si criterion.nil?
    propagar Errors::CriteriosArgumentoRequerido, :con_tipo
  end

  anulación tipificada(criterion, "$tipo") hacer |valor|
    ::entero.evolucionar(valor)
  end
end