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

Ampliado por:
Macrosable
Definido en:
lib/mongoid/criteria/queryable/selectable.rb

Overview

Un seleccionable consultable es seleccionable, en el sentido de que tiene la capacidad de seleccionar documentos de la base de datos. El módulo seleccionable lleva toda la funcionalidad al elemento seleccionable que tiene que ver con la creación de selectores MongoDB.

Colapso delresumen constante

CADENA DE LÍNEA =

Constante para una geometría LineString.

"LineString"
punto =

Constante para una geometría de Punto ($geometry).

"punto"
polígono =

Constante para una $geometry Polígono.

"polígono"

Resumen de atributos de la instancia colapsar

Resumen del método de clase colapsar

Resumen del método de instancia colapsar

Métodos incluidos en Macroable

llave

Detalles de los atributos de instancia

#negando ⇒ objeto

Devuelve el valor del atributo negando.



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

def negar
  @negando
end

#negación Si la siguiente expresión está negada.(Ifthe) ⇒ objeto 



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

attr_accessor :negando, :selector

#selector ⇒ Objeto

Devuelve el valor del selector del atributo.



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

def selector
  @selector
end

#selector El selector de query.(El selector de query.) ⇒ objeto 



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

attr_accessor :negando, :selector

Detalles del método de clase

.forwardables ⇒ arreglo<Symbol>

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

Ejemplos:

Consigue los métodos transferibles.

Selectable.forwardables

Devuelve:

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

    Los nombres de los métodos transferibles.



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

#all(*criteria) ⇒ Seleccionable También conocido como: all_in

Agrega 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 (encriptada...) —

    El par clave-valor para que $all coincida.

Devuelve:



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 Todo(*criterios)
  si criterios.¿vacío?
    return clon.tocar hacer |Consulta|
      Consulta.reset_strategies!
    end
  end

  criterios.inyectar(clon) hacer |Consulta, condición|
    si condición.nil?
      propagar Errors::CriteriaArgumentRequired, todo
    end

    condición = expandir_condición_a_valores_de_arreglo(condición)

    si estrategia
      enviar(estrategia, condición, "$all")
    else
      condición.inyectar(Consulta) hacer |query, (Campo, Valor)|
        v = {'$all' => Valor}
        si ¿negando?
          v = {' $no ' => v}
        end
        query.add_field_expression(Campo.to_s, v)
      end
    end
  end.reset_strategies!
end

#y(*criterios) ⇒ Selectable 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 | arreglo<Hash | Criterios> ]...) —

    Varias coincidencias de pares clave/valor u objetos Criterios que todos deben coincidir para devolver resultados.

Devuelve:



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)
  _mongoid_flatten_arrays(criterios).inyectar(sí mismo.clon) hacer |C, nueva|
    si nueva.is_a?(Seleccionable)
      nueva = nueva.selector
    end
    normalizado = _mongoid_expand_keys(nueva)
    normalizado.cada hacer |k, v|
      k = k.to_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 los operadores, y v no está presente en las condiciones existentes,
        # podemos añadir a las condiciones existentes.
        # De lo contrario, use $and.
        si v.is_a?(Picadillo) &&
          v.longitud == 1 &&
          (nuevo_k = v.claves.primero).start_with?('$') &&
          (existing_kv = C.selector[k]).is_a?(Picadillo) &&
          !existing_kv.key?(nuevo_k) &&
          existing_kv.claves.¿todos? { |sub_k| sub_k.start_with?('$') }
        entonces
          fusionado_v = C.selector[k].fusionar(v)
          C.selector.store(k, fusionado_v)
        else
          C = C.enviar(:__multi__, [k => v], '$and')
        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.

Utiliza or para hacer que el receptor sea uno de los operanlos de disyunción.

Cada argumento puede ser un Hash, un objeto Criteria, un arreglo de Hash o de objetos Criteria, o un arreglo anidado. Los arreglos anidados se aplanarán y pueden tener cualquier profundidad. El traspaso de arreglos está obsoleto.

Ejemplos:

Añada 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})

Lo mismo que en el ejemplo anterior, pero utilizando el wrap de arreglo obsoleto.

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

Igual que el ejemplo anterior, también quedó obsoleto.

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

Parámetros:

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

    Varios pares clave/valor coincidentes u Objetos de criterios, o arreglos de los mismos. El traspaso de arreglos está obsoleto.

Devuelve:



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 = _mongoid_flatten_arrays(criterios)
  caso criterios.longitud
  Cuando 0
    clon
  Cuando 1
    # Cuando tenemos un solo criterio, any_of se comporta como and.
    # Nota: los criterios pueden ser un objeto de consulta, lo cual no hace el método where.
    # no soporte.
    sí mismo.y (*criterios)
  else
    # Cuando tenemos varios criterios, los combinamos todos con $or
    # y añade el resultado a sí mismo.
    expresiones = criterios.map hacer |criterion|
      si criterion.is_a?(Seleccionable)
        _mongoid_expand_keys(criterion.selector)
      else
        Picadillo[criterion.map hacer |k, v|
          si k.is_a?(Símbolo)
            [k.to_s, v]
          else
            [k, v]
          end
        end]
      end
    end
    sí mismo.y ('$o ' => expresiones)
  end
end

#between(criterio) ⇒ Seleccionable

Agrega la selección de rango.

Ejemplos:

Concatenar resultados dentro de un solo rango.

selectable.between(field: 1..2)

Coincidencia en los resultados entre varios rangos.

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

Parámetros:

  • criterion (encriptada) —

    Múltiples pares de clave/rango.

Devuelve:



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::CriteriaArgumentRequired, 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

Selecciona 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 (encriptada) —

    Los pares campo/partido.

Devuelve:



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

def elem_match(criterion)
  si criterion.nil?
    propagar Errors::CriteriaArgumentRequired, elem_match
  end

  y_with_operator(criterion, "$elemMatch")
end

#eq(criterio) ⇒ Selectable

Añade el criterio $eq al selector.

Ejemplos:

Agrega el criterio $eq.

selectable.eq(age: 60)

Ejecuta un $eq en una query where.

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

Parámetros:

  • criterion (encriptada) —

    Los pares campo/valor a comprobar.

Devuelve:



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::CriteriaArgumentRequired, :eq
  end

  y_with_operator(criterion, "$eq")
end

#exists(criterion) ⇒ Seleccionable

Agregue la selección $exists.

Ejemplos:

Añadir una selección individual.

selectable.exists(field: true)

Agrega varias selecciones.

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

Ejecutar un $exists en una consulta where.

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

Parámetros:

  • criterion (encriptada) —

    Las comprobaciones de existencia de campo/booleano.

Devuelve:



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::CriteriaArgumentRequired, existe
  end

  typed_override(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 ]])

Añade un criterio de intersección geográfica para un punto.

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

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

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

Agrega un criterio geo dentro para un polígono.

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

Añade un criterio geográfico dentro de la casilla.

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

Parámetros:

  • criterion (encriptada) —

    El criterio.

Devuelve:



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

def geo_spatial(criterion)
  si criterion.nil?
    propagar Errors::CriteriaArgumentRequired, geo_spatial
  end

  __merge__(criterion)
end

#gt(criterio) ⇒ Seleccionable

Agregar el criterio $gt al selector.

Ejemplos:

Agrega el criterio $gt.

selectable.gt(age: 60)

Ejecute un $gt en una consulta where.

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

Parámetros:

  • criterion (encriptada) —

    Los pares campo/valor a comprobar.

Devuelve:



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::CriteriaArgumentRequired, :gt
  end

  y_with_operator(criterion, "$gt")
end

#gte(criterio) ⇒ Seleccionable

Agrega el criterio $gte al selector.

Ejemplos:

Agregue el criterio $gte.

selectable.gte(age: 60)

Ejecutar un $gte en una consulta where.

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

Parámetros:

  • criterion (encriptada) —

    Los pares campo/valor a comprobar.

Devuelve:



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::CriteriaArgumentRequired, :gte
  end

  y_with_operator(criterion, "$gte")
end

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

Agrega la selección $in a lo seleccionable.

Ejemplos:

Añadir la selección $in en un arreglo.

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

Añada una selección $in sobre 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 (encriptada) —

    Los pares de criterios campo/valor.

Devuelve:



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::CriteriaArgumentRequired, :en
  end

  condición = expandir_condición_a_valores_de_arreglo(condición)

  si estrategia
    enviar(estrategia, condición, "$in")
  else
    condición.inyectar(clon) hacer |Consulta, (Campo, Valor)|
      v = {'$in' => Valor}
      si ¿negando?
        v = {' $no ' => v}
      end
      Consulta.add_field_expression(Campo.to_s, v)
    end.reset_strategies!
  end
end

#lt(criterio) ⇒ Seleccionable

Agrega el criterio $lt al selector.

Ejemplos:

Agregar el criterio $lt.

selectable.lt(age: 60)

Ejecutar un $lt en una query where.

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

Parámetros:

  • criterion (encriptada) —

    Los pares campo/valor a comprobar.

Devuelve:



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::CriteriaArgumentRequired, :lt
  end

  y_with_operator(criterion, "$lt")
end

#lte(criterio) ⇒ Seleccionable

Agregue el criterio $lte al selector.

Ejemplos:

Agregue el criterio $lte.

selectable.lte(age: 60)

Ejecutar un $lte en una consulta where.

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

Parámetros:

  • criterion (encriptada) —

    Los pares campo/valor a comprobar.

Devuelve:



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::CriteriaArgumentRequired, :lte
  end

  y_with_operator(criterion, "$lte")
end

#max_distance(criterio) ⇒ Seleccionable

Agrega una selección $maxDistance al seleccionable.

Ejemplos:

Agregue la selección $maxDistance.

selectable.max_distance(location: 10)

Parámetros:

  • criterion (encriptada) —

    Los pares campo/distancia.

Devuelve:



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

def max_distance(criterion)
  si criterion.nil?
    propagar Errors::CriteriaArgumentRequired, distancia máxima
  end

  # $maxDistance debe darse junto con $near
  __add__(criterion, "$maxDistance")
end

#mod(criterio) ⇒ Seleccionable

Agrega la selección $mod al elemento 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 (encriptada) —

    Las selecciones de campo/mod.

Devuelve:



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::CriteriaArgumentRequired, :mod
  end

  y_with_operator(criterion, "$mod")
end

#no es igual(criterio) ⇒ Seleccionable También conocido como: excluye

Agrega la selección $ne a las opciones seleccionables.

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 (encriptada) —

    Las selecciones de campo/ne.

Devuelve:



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::CriteriaArgumentRequired, :ne
  end

  y_with_operator(criterion, "$ne")
end

#cerca(criterio) ⇒ Seleccionable

Añade un criterio $near a una selección geográfica.

Ejemplos:

Añade la selección $near.

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

Ejecución de un $near en una query where.

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

Parámetros:

  • criterion (encriptada) —

    El par campo/ubicación.

Devuelve:



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::CriteriaArgumentRequired, cerca de
  end

  y_with_operator(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 ])

Ejecuta un $nearSphere en una consulta where.

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

Parámetros:

  • criterion (encriptada) —

    El par campo/ubicación.

Devuelve:



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::CriteriaArgumentRequired, :near_sphere
  end

  y_with_operator(criterion, "$nearSphere")
end

#¿negando? ⇒ true | false

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

Ejemplos:

¿La selección es negadora?

selectable.negating?

Devuelve:

  • (true | false) —

    Si el campo seleccionable está negando.



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

def ¿negando?
  !!negar
end

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

Agrega la selección $nin al elemento seleccionable.

Ejemplos:

Agregue la selección $nin en una matriz.

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

Agrega la selección $nin en un rango.

selectable.nin(age: 18..24)

Ejecuta un $nin en una query where.

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

Parámetros:

  • condición (encriptada) —

    Los pares de criterios campo/valor.

Devuelve:



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::CriteriaArgumentRequired, :nin
  end

  condición = expandir_condición_a_valores_de_arreglo(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.add_field_expression(Campo.to_s, v)
    end.reset_strategies!
  end
end

#none_of(*criteria) ⇒ Selectable

Negar los argumentos, limitando la query solo a aquellos documentos que NO coincidan con los argumentos.

Ejemplos:

Excluir un solo criterio.

selectable.none_of(name: /Bob/)

Excluir varios criterios.

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

Excluir múltiples criterios como un arreglo.

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

Parámetros:

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

    El par clave/valor coincide o los objetos de criterios para negar.

Devuelve:



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

def none_of(*criterios)
  criterios = _mongoid_flatten_arrays(criterios)
  return dup si criterios.¿vacío?

  expresiones = criterios.map hacer |criterion|
    _mongoid_expand_keys(
        criterion.is_a?(Seleccionable) ?
          criterion.selector : criterion)
  end

  sí mismo.y ('$nor' => expresiones)
end

#ni(*criterios) ⇒ Seleccionable

Agrega la selección $nor a lo seleccionable.

Ejemplos:

Añadir la selección $nor.

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

Parámetros:

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

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

Devuelve:



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

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

Ejemplos:

Niega la siguiente selección.

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

Agrega el criterio $not.

selectable.not(name: /Bob/)

Ejecuta un $not en una query where.

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

Parámetros:

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

    El par clave/valor coincide o los objetos de criterios para negar.

Devuelve:



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.tocar { |Consulta| Consulta.negar = !Consulta.negar }
  else
    criterios.compact.inyectar(sí mismo.clon) hacer |C, nueva|
      si nueva.is_a?(Seleccionable)
        nueva = nueva.selector
      end
      _mongoid_expand_keys(nueva).cada hacer |k, v|
        k = k.to_s
        si C.selector[k] || k.start_with?('$')
          C = C.enviar(:__multi__, [{'$nor' => [{k => v}]}], '$and')
        else
          si v.is_a?(Picadillo)
            C = C.enviar(:__multi__, [{'$nor' => [{k => v}]}], '$and')
          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.

Use 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 arreglo de Hash o de objetos Criteria, o un arreglo anidado. Los arreglos anidados se aplanarán y pueden tener cualquier profundidad. El traspaso de arreglos está obsoleto.

Ejemplos:

Añada 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})

Lo mismo que en el ejemplo anterior, pero utilizando el wrap de arreglo obsoleto.

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

Igual que el ejemplo anterior, también quedó obsoleto.

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

Parámetros:

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

    Varios pares clave/valor coincidentes u Objetos de criterios, o arreglos de los mismos. El traspaso de arreglos está obsoleto.

Devuelve:



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 = nil) ⇒ Selectable

Nota:

Por www.mongodb.com/es/docs/manual/reference/operator/query/text/ actualmente no es posible suministrar múltiples condiciones de búsqueda de texto en una query. Mongoid construirá una query de este tipo, 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érmino (String | Símbolo) —

    Una string de términos que MongoDB analiza y utiliza para hacer una query al índice de texto.

  • opta (Hash) (predeterminado: nulo) —

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

Devuelve:



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 text_search(término, opta = nulo)
  si término.nil?
    propagar Errors::CriteriaArgumentRequired, término
  end

  clon.tocar hacer |Consulta|
    criterion = {'$text' => { '$search' => término }}
    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 $text
      # Servidor MongoDB, pero construye la query correctamente en lugar de
      # sobrescribiendo la condición de búsqueda de texto anterior con la actual
      # dado uno.
      Mongoid.logger.advertencia('El servidor actualmente no admite múltiples expresiones $text por query')
      Consulta.selector = {'$and' => [Consulta.selector]}.fusionar(criterion)
    else
      Consulta.selector = Consulta.selector.fusionar(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ñade una selección estándar.

selectable.where(name: "syd")

Agregar una selección de JavaScript.

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

Parámetros:

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

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

Devuelve:



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 dónde(*criterios)
  criterios.inyectar(clon) hacer |Consulta, criterion|
    si criterion.nil?
      propagar Errors::CriteriaArgumentRequired, dónde
    end

    # Necesitamos guardar el criterio en una variable de instancia, así que
    # 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. Esto
    # funciona bien porque los métodos first_or_create etc.
    # especifica sólo un criterio para #where.
    @criterion = criterion
    si criterion.is_a?(String)
      js_query(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 contenedores o símbolos.

Agregar una selección de $size para los campos de arreglo.

Ejemplos:

Agregue la selección de $size.

selectable.with_size(field: 5)

Ejecutar un $size en una consulta where.

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

Parámetros:

  • criterion (encriptada) —

    El criterio pares campo/tamaño.

Devuelve:



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::CriteriaArgumentRequired, con tamaño
  end

  typed_override(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 $type a lo seleccionable.

Ejemplos:

Agregue la selección $type.

selectable.with_type(field: 15)

Ejecutar un $type en una query where.

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

Parámetros:

  • criterion (encriptada) —

    Los pares campo/tipo.

Devuelve:



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::CriteriaArgumentRequired, con_tipo
  end

  typed_override(criterion, "$tipo") hacer |Valor|
    ::entero.evolucionar(Valor)
  end
end