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

Ampliado por:
Macroable
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.

Resumen de constantes colapsar

LINE_STRING =

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 de Macroable

llave

Detalles de atributo de instancias

#negando ⇒ objeto

Devuelve el valor del atributo negando.



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

def negar
  @negando
end

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



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

attr_accessor :negando, Selector:

#selector ⇒ Objeto

Devuelve el valor del selector del atributo.



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

def selector
  @selector
end

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



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

attr_accessor :negando, Selector:

Detalles del método de clase

.forwardables ⇒ arreglo<Symbol>

Obtén los métodos en el elemento seleccionable a los que se puede remitir desde un modelo.

Ejemplos:

Consigue los métodos transferibles.

Selectable.forwardables

Devuelve:

  • (arreglo<Symbol>) —

    Los nombres de los métodos transferibles.



883
884
885
886
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 883

def reenviables
  public_instance_methods(false) -
    %i[negar negando= ¿Negar? selector SELECTOR =]
end

Detalles del método de instancia

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

Agrega el criterio $all.

Ejemplos:

Agregar 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:



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 36

def Todo(*criterios)
  si criterios.¿vacío?
    return clonar.tocar hacer |Consulta|
      Consulta.reset_strategies!
    end
  end

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

    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 }
        v = { '$not' => v } si ¿Negar?
        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:

Agregar 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:



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 72

def y (*criterios)
  _mongoid_flatten_arrays(criterios).inyectar(clonar) hacer |C, nueva|
    nueva = nueva.selector si nueva.is_a?(Seleccionable)
    normalizado = _mongoid_expand_keys(nueva)
    normalizado.cada hacer |k, v|
      k = k.to_s
      si C.selector[k]
        # Ya existe una condición sobre 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?(encriptada) &&
           v.longitud == 1 &&
           (nuevo_k = v.claves.primero).start_with?('$') &&
           (existing_kv = C.selector[k]).is_a?(encriptada) &&
           !existing_kv.key?(nuevo_k) &&
           existing_kv.claves.¿todos? { |sub_k| sub_k.start_with?('$') }
          merged_v = C.selector[k].fusionar(v)
          C.selector.store(k, merged_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

Agrega 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)

Agrega la selección $or donde cualquiera de los valores sea suficiente para coincidir.

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:



625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 625

def any_of(*criterios)
  criterios = _mongoid_flatten_arrays(criterios)
  caso criterios.longitud
  cuando 0
    clonar
  cuando 1
    # Cuando tenemos un solo criterio, any_of se comporta como and.
    # Nota: los criterios pueden ser un objeto query, que #where hace
    # 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
        encriptada[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 ('$or' => 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) —

    Varios pares clave/rango.

Devuelve:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


115
116
117
118
119
120
121
122
123
124
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 115

def entre(criterion)
  propagar Errors::CriteriaArgumentRequired, Entre si criterion.nil?

  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" })

Agregar criterio para múltiples coincidencias.

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

Ejecutar un $elemMatch en una query where.

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

Parámetros:

  • criterion (encriptada) —

    Los pares campo/match.

Devuelve:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


143
144
145
146
147
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 143

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

  y_with_operator(criterion, '$elemMatch')
end

#eq(criterio) ⇒ Selectable

Agregue 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:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


240
241
242
243
244
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 240

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

  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)

Ejecute un $exists en una query where.

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

Parámetros:

  • criterion (encriptada) —

    Las comprobaciones de existencia de campo/booleano.

Devuelve:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


164
165
166
167
168
169
170
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 164

def exists(criterion)
  propagar Errors::CriteriaArgumentRequired, existe si criterion.nil?

  typed_override(criterion, '$exists') hacer |Valor|
    Mongoid::Booleano.evolucionar(Valor)
  end
end

#expr_query(criterio) ⇒ Seleccionable

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 la expresión especificada a la query.

El criterio debe ser un hash en una de las siguientes formas:

  • Valor
  • => valor
  • Valor
  • => expresión_de_valor_operador

El nombre del campo y el operador pueden proporcionarse como cadenas o símbolos.

Ejemplos:

Crea la selección.

selectable.expr_query(age: 50)

Parámetros:

  • criterion (encriptada) —

    Los pares campo/valor.

Devuelve:

Aumenta:

  • (ArgumentError) 


795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 795

def expr_query(criterion)
  propagar ArgumentError, 'El criterio no puede estar vacío aquí' si criterion.nil?
  a menos que criterion.is_a?(encriptada)
    propagar Errors::Consulta no válida, "La expresión debe ser un Hash: #{Errores::InvalidQuery.truncate_expr(criterion)}"
  end

  normalizado = _mongoid_expand_keys(criterion)
  clonar.tocar hacer |Consulta|
    normalizado.cada hacer |Campo, Valor|
      field_s = Campo.to_s
      si field_s.start_with?('$')
        # Operador a nivel de expresión de query, como $and o $where
        Consulta.add_operator_expression(field_s, Valor)
      else
        Consulta.add_field_expression(Campo, Valor)
      end
    end
    Consulta.reset_strategies!
  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 query son la forma geométrica :within_polygon y el operador :within_box.

Nota:

El operador :within_box para la query $geoWithin espera el par de coordenadas inferiores izquierdas (suroeste) como el primer argumento y las superiores derechas (noreste) como el segundo argumento. Importante: cuando se pasan la latitud y la longitud, se espera que la longitud sea el primer elemento del par de coordenadas. Fuente: https://www.mongodb.com/es/docs/manual/reference/operator/query/box/

Agrega una selección $geoIntersects o $geoWithin. Los operadores de símbolos deben utilizarse como se muestra en los ejemplos para ampliar los criterios.

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:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


209
210
211
212
213
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 209

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

  __merge__(criterion)
end

#gt(criterio) ⇒ Seleccionable

Agregar el criterio $gt al selector.

Ejemplos:

Agrega el criterio $gt.

selectable.gt(age: 60)

Ejecutar un $gt en una query where.

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

Parámetros:

  • criterion (encriptada) —

    Los pares campo/valor a comprobar.

Devuelve:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


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

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

  y_with_operator(criterion, '$gt')
end

#gte(criterio) ⇒ Selectable

Agrega el criterio $gte al selector.

Ejemplos:

Agregue el criterio $gte.

selectable.gte(age: 60)

Ejecutar un $gte en una query where.

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

Parámetros:

  • criterion (encriptada) —

    Los pares campo/valor a comprobar.

Devuelve:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


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

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

  y_with_operator(criterion, '$gte')
end

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

Agrega la selección $in a la 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:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 297

def in(condición)
  propagar Errors::CriteriaArgumentRequired, :en si condición.nil?

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

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

#js_query(criterio) ⇒ Seleccionable

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.

Crear una selección de JavaScript.

Ejemplos:

Crear la selección de JavaScript.

selectable.js_query("this.age == 50")

Parámetros:

  • criterion (string) —

    El JavaScript como una string.

Devuelve:



826
827
828
829
830
831
832
833
834
835
836
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 826

def js_query(criterion)
  clonar.tocar hacer |Consulta|
    si ¿Negar?
      Consulta.add_operator_expression('$and',
                                    [ { '$nor' => [ { '$where' => criterion } ] } ])
    else
      Consulta.add_operator_expression('$where', criterion)
    end
    Consulta.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:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


326
327
328
329
330
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 326

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

  y_with_operator(criterion, '$lt')
end

#lte(criterio) ⇒ Seleccionable

Agregue el criterio $lte al selector.

Ejemplos:

Agregue el criterio $lte.

selectable.lte(age: 60)

Ejecuta un $lte en una query where.

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

Parámetros:

  • criterion (encriptada) —

    Los pares campo/valor a comprobar.

Devuelve:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


344
345
346
347
348
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 344

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

  y_with_operator(criterion, '$lte')
end

#max_distance(criterio) ⇒ Seleccionable

Agrega una selección $maxDistance al seleccionable.

Ejemplos:

Agregar la selección de $maxDistance.

selectable.max_distance(location: 10)

Parámetros:

  • criterion (encriptada) —

    Los pares campo/distancia.

Devuelve:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


359
360
361
362
363
364
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 359

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

  # $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 query where.

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

Parámetros:

  • criterion (encriptada) —

    Las selecciones de campo/mod.

Devuelve:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


377
378
379
380
381
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 377

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

  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:

query para un valor $ne a algo.

selectable.ne(field: 10)

Ejecuta un $ne en una query where.

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

Parámetros:

  • criterion (encriptada) —

    Las selecciones de campo.

Devuelve:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


395
396
397
398
399
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 395

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

  y_with_operator(criterion, '$ne')
end

#near(criterion) ⇒ Los elementos seleccionables

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

Ejemplos:

Agrega 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:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


414
415
416
417
418
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 414

def near(criterion)
  propagar Errors::CriteriaArgumentRequired, cerca de si criterion.nil?

  y_with_operator(criterion, '$near')
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:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


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

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

  y_with_operator(criterion, '$nearSphere')
end

#¿negando? ⇒ true | false

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

Ejemplos:

¿Está el elemento seleccionable negando?

selectable.negating?

Devuelve:

  • (true | false) —

    Si el campo seleccionable está negando.



490
491
492
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 490

def ¿Negar?
  !!negar
end

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

Agrega la selección $nin al elemento seleccionable.

Ejemplos:

Agrega la selección $nin a un arreglo.

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:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 453

def nin(condición)
  propagar Errors::CriteriaArgumentRequired, :nin si condición.nil?

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

  si estrategia
    enviar(estrategia, condición, '$nin')
  else
    condición.inyectar(clonar) hacer |Consulta, (Campo, Valor)|
      v = { '$nin' => Valor }
      v = { '$not' => v } si ¿Negar?
      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:



552
553
554
555
556
557
558
559
560
561
562
563
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 552

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

#nor(*criterios) ⇒ Seleccionable

Agrega la selección $nor a los seleccionables.

Ejemplos:

Añadir la selección $nor.

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

Parámetros:

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

    Varios pares clave/valor coincidentes u objetos Criteria.

Devuelve:



480
481
482
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 480

def ni(*criterios)
  _mongoid_add_top_level_operation('$nor', criterios)
end

#not(*criteria) ⇒ Seleccionable

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

Ejemplos:

Negar 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:



509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 509

def no(*criterios)
  si criterios.¿vacío?
    dup.tocar { |Consulta| Consulta.negar = !Consulta.negar }
  else
    criterios.compact.inyectar(clonar) hacer |C, nueva|
      nueva = nueva.selector si nueva.is_a?(Seleccionable)
      _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')
        elsif v.is_a?(encriptada)
          C = C.enviar(:__multi__, [ { '$nor' => [ { k => v } ] } ], '$and')
        else
          operador_negado = si v.is_a?(Regexp)
                               '$not'
                             else
                               '$ne'
                             end
          C = C.enviar(:__override__, { k => v }, operador_negado)
        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 la 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)

Agrega la selección $or donde cualquiera de los valores sea suficiente para coincidir.

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:



595
596
597
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 595

def or(*criterios)
  _mongoid_add_top_level_operation('$or', criterios)
end

#text_search(términos, opts = nil) ⇒ Selectable

Nota:

Por https://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 query. Mongoid construirá dicha query, 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.

  • opciones (encriptada) (valor por defecto: nil) —

    Opciones de búsqueda de texto. Consulta la documentación de MongoDB para conocer las opciones.

Devuelve:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 723

def text_search(término, opciones = nulo)
  propagar Errors::CriteriaArgumentRequired, término si término.nil?

  clonar.tocar hacer |Consulta|
    criterion = { '$text' => { '$search' => término } }
    criterion['$text'].¡Actualizar!(opciones) si opciones
    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. Esto crea un campo estándar: selección de valor y selección ampliada con el uso de métodos hash, o una selección $where si se proporciona una string.

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 string de JavaScript.

Devuelve:



757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 757

def dónde(*criterios)
  return clonar.reset_strategies! si criterios.¿vacío?

  criterios.inyectar(sí mismo) hacer |Consulta, criterion|
    propagar Errors::CriteriaArgumentRequired, dónde si criterion.nil?

    # Necesitamos guardar el criterio en una variable de instancia, así que
    # Los métodos modificables saben cómo crear un objeto polimorfo.
    # Tenga en cuenta que este método, en principio, acepta múltiples criterios,
    # pero solo el primero se almacenará en @criterion. Esto
    # resulta ser adecuado porque los métodos 555first_or_create555, etc.
    # especifica sólo un criterio para #where.
    @criterion = criterion
    si criterion.is_a?(String)
      Consulta.js_query(criterion)
    else
      Consulta.expr_query(criterion)
    end
  end
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)

Ejecuta un $size en una query where.

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

Parámetros:

  • criterion (encriptada) —

    El criterio pares campo/tamaño.

Devuelve:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


669
670
671
672
673
674
675
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 669

def con el tamaño(criterion)
  propagar Errors::CriteriaArgumentRequired, con tamaño si criterion.nil?

  typed_override(criterion, '$tamaño') hacer |Valor|
    ::entero.evolucionar(Valor)
  end
end

#with_type(criterio) ⇒ Seleccionable

Nota:

http://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) —

    Las parejas campo/tipo.

Devuelve:

Aumenta:

  • (<span class=\" \"><a href=\" \" title=\" \">Errores::Se requiere criterioArgument) 


693
694
695
696
697
698
699
 
# Archivo 'lib/mongoid/criteria/queryable/selectable.rb', línea 693

def con tipo(criterion)
  propagar Errors::CriteriaArgumentRequired, con_tipo si criterion.nil?

  typed_override(criterion, '$type') hacer |Valor|
    ::entero.evolucionar(Valor)
  end
end