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

Estendido por:
macroable
Definido em:
lib/mongoid/criteria/queryable/selectable.rb

Visão geral

Um selecionável por query é selecionável, pois tem a capacidade de selecionar documento do banco de banco de dados. O módulo selecionável traz toda a funcionalidade para o selecionável que tem a ver com a criação de seletores do MongoDB .

Colapsode resumo constante

LINE_STRING =

Constante para uma LineString $geometry.

'LineString'
PONTO =

Constante para um ponto $geometry.

'Ponto'
POLÍgono =

Constante para um polígono $geometry.

'Polígono'

Recolhimento do Resumo do atributo de instância

Recolhimento do Resumo do método de classe

Recolhimento do Resumo do método de instância

Métodos incluídos do macroable

chave

Detalhes do atributo da instância

# objetode negação

Retorna o valor do atributo negando.



23
24
25
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 23

def negando
  @ negando
end

#negating Se a próxima expressão for negada.(Se o) ➤ Objeto 



23
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 23

attr_accessor : negating, :selector

#seletor ➤ Objeto

Retorna o valor do seletor de atributo.



23
24
25
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 23

def seletor
  @selector
end

#selector O seletor de consulta.(O seletor de query.) ➤ Objeto 



23
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 23

attr_accessor : negating, :selector

Detalhes do método de classe

.forwardables ➤ Array<Symbol>

Obtenha os métodos no selecionável que pode ser encaminhado a partir de um modelo.

Exemplos:

Obtenha os métodos encaminháveis.

Selectable.forwardables

Retorna:

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

    Os nomes dos métodos encaminháveis.



883
884
885
886
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 883

def encaminháveis
  public_instance_methods(false) -
    %i[negando negando= negando? seletor SELETOR =]
end

Detalhes do método de instância

#all(*criteria) ➤ Seleccionado Também conhecido como: all_in

Adicione o critério $all.

Exemplos:

Adicione o critério.

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

Execute um $all em uma query onde.

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

Parâmetros:

  • *critérios (Hash...) —

    O(s) par(es) de valores-chave para $all correspondente.

Retorna:



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

def todos(*critério)
  se critério.vazio?
    Método clonar.toque fazer |Query|
      Query.reset_strategies!
    end
  end

  critério.injetar(clonar) fazer |Query, Condição|
    aumentar Errors::CriteriaArgumentRequired, :all se Condição.nada?

    Condição = expand_ conditions_to_array_values(Condição)

    se estratégia
      enviar(estratégia, Condição, '$all')
    mais
      Condição.injetar(Query) fazer |_query, (Campo, valor)|
        v = { '$all' => valor }
        v = { '$not' => v } se negando?
        _query.add_field_expression(Campo.to_s, v)
      end
    end
  end.reset_strategies!
end

#e(*critérios) ➤ Seleccionado Também conhecido como: all_of

Adicione o critério $and.

Exemplos:

Adicione o critério.

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

Parâmetros:

  • *critérios ([ Hash | Critérios | Matriz<Hash | Critérios> ]...) —

    Várias correspondências de pares de chave/valor ou objetos Criteria que devem corresponder para retornar resultados.

Retorna:



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
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 72

def e a(*critério)
  _mongoid_flatten_arrays(critério).injetar(clonar) fazer |C, new_s|
    new_s = new_s.seletor se new_s.is_a?(Seleccionado)
    Normalizado = _mongoid_expand_keys(new_s)
    Normalizado.cada fazer |k, v|
      k = k.to_s
      se C.seletor[k]
        # Já existe uma condição em k.
        # Se v for um operador e todas as condições existentes forem
        # também operadores, e v não está presente nas condições existentes,
        # podemos adicionar às condições existentes.
        # Caso contrário, use $and.
        se v.is_a?(Hash) &&
           v.Tamanho == 1 &&
           (new_k = v.keys.primeiro).start_with?('$') &&
           (exists_kv = C.seletor[k]).is_a?(Hash) &&
           !exists_kv.chave?(new_k) &&
           exists_kv.keys.todos? { |sub_k| sub_k.start_with?('$') }
          merged_v = C.seletor[k].mesclar(v)
          C.seletor.Armazenar(k, merged_v)
        mais
          C = C.enviar(:__multi__, [ { k => v } ], '$e')
        end
      mais
        C.seletor.Armazenar(k, v)
      end
    end
    C
  end
end

#any_of(*criteria) ⇒ Seleccionado

Adiciona uma disjunção dos argumentos como uma restrição adicional aos critérios já existentes no receptor.

Use or para tornar o receptor um dos operandos de disjunção.

Cada argumento pode ser um Hash, um objeto Critérios , uma array de objetos Hash ou Critérios ou uma array aninhada. As arrays agrupadas serão achatadas e podem ter qualquer profundidade. Passar arrays está obsoleto.

Exemplos:

Adicione a seleção $or onde ambos os campos devem ter os valores especificados.

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

Adicione a seleção $or onde qualquer correspondência de valor for suficiente.

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

Igual ao exemplo anterior, mas usando o wrap de array obsoleto.

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

Igual ao exemplo anterior, também obsoleto.

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

Parâmetros:

  • *critérios ([ Hash | Critérios | Matriz<Hash | Critérios> ]...) —

    Várias correspondências de pares de chave/valor ou objetos Criteria, ou arrays dos mesmos. Passar arrays está obsoleto.

Retorna:



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
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 625

def any_of(*critério)
  critério = _mongoid_flatten_arrays(critério)
  caso critério.Tamanho
  quando 0
    clonar
  quando 1
    # Quando temos um único critério, any_of se comporta como e.
    # Observação: os critérios podem ser um objeto Query , cujo método #where faz
    # não suporta.
    auto.e a(*critério)
  mais
    # Quando tivermos vários critérios, combine todos eles com $ou
    # e adicione o resultado a si mesmo.
    exprs = critério.map fazer |criterion|
      se criterion.is_a?(Seleccionado)
        _mongoid_expand_keys(criterion.seletor)
      mais
        Hash[criterion.map fazer |k, v|
          se k.is_a?(Símbolo)
            [ k.to_s, v ]
          mais
            [ k, v ]
          end
        end]
      end
    end
    auto.e a('$or' => exprs)
  end
end

#entre(critério) ➤ Seleccionado

Adicione a seleção de intervalo.

Exemplos:

Combine os resultados em um único intervalo.

selectable.between(field: 1..2)

Correspondência de resultados entre vários intervalos.

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

Parâmetros:

  • criterion (Hash) —

    Vários pares chave/faixa.

Retorna:

Aumenta:



115
116
117
118
119
120
121
122
123
124
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 115

def entre(criterion)
  aumentar Errors::CriteriaArgumentRequired, :entre se criterion.nada?

  seleção(criterion) fazer |seletor, Campo, valor|
    seletor.Armazenar(
      Campo,
      { '$gte' => valor.min, '$lte' => valor.max }
    )
  end
end

#elem_match(critério) ⇒ Seleccionado

Selecione com um $elemMatch.

Exemplos:

Adiciona critério para uma única correspondência.

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

Adicionar critério para múltiplas correspondências.

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

Execute um $elemMatch em uma query onde.

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

Parâmetros:

  • criterion (Hash) —

    Os pares campo/partida.

Retorna:

Aumenta:



143
144
145
146
147
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 143

def elem_match(criterion)
  aumentar Errors::CriteriaArgumentRequired, :elem_match se criterion.nada?

  and_with_operator(criterion, '$elemMatch')
end

#eq(critério) ➤ Seleccionado

Adicione o critério $eq ao seletor.

Exemplos:

Adicione o critério $eq.

selectable.eq(age: 60)

Execute um $eq em uma query onde.

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

Parâmetros:

  • criterion (Hash) —

    Os pares de campo/valor a serem verificados.

Retorna:

Aumenta:



240
241
242
243
244
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 240

def eq(criterion)
  aumentar Errors::CriteriaArgumentRequired, :eq se criterion.nada?

  and_with_operator(criterion, '$eq')
end

#exists(critério) ➤ Seleccionado

Adicione a seleção $exists.

Exemplos:

Adicione uma única seleção.

selectable.exists(field: true)

Adicione várias seleções.

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

Execute um $exists em uma query onde.

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

Parâmetros:

  • criterion (Hash) —

    O campo/boolean verifica a existência.

Retorna:

Aumenta:



164
165
166
167
168
169
170
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 164

def existe(criterion)
  aumentar Errors::CriteriaArgumentRequired, :exists se criterion.nada?

  typed_override(criterion, '$existe') fazer |valor|
    Mongoid::Boolean.evolua(valor)
  end
end

#expr_query(critério) ⇒ selecionável

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Adiciona a expressão especificada à query.

O critério deve ser um hash em uma das seguintes formas:

  • valor
  • => valor
  • valor
  • => operator_value_expression

O nome do campo e o operador podem ser fornecidos como strings ou símbolos.

Exemplos:

Crie a seleção.

selectable.expr_query(age: 50)

Parâmetros:

  • criterion (Hash) —

    Os pares de campo/value.

Retorna:

Aumenta:

  • (ArgumentError) 


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

def expr_query(criterion)
  aumentar ArgumentError, 'O critério não pode ser nulo aqui' se criterion.nada?
  a menos que criterion.is_a?(Hash)
    aumentar Errors::Query inválida, "A expressão deve ser um Hash: #{Errors::InvalidQuery.truncate_expr(criteria)}"
  end

  Normalizado = _mongoid_expand_keys(criterion)
  clonar.toque fazer |Query|
    Normalizado.cada fazer |Campo, valor|
      field_s = Campo.to_s
      se field_s.start_with?('$')
        # Operador de nível de expressão de query, como $and ou $where
        Query.add_operator_expression(field_s, valor)
      mais
        Query.add_field_expression(Campo, valor)
      end
    end
    Query.reset_strategies!
  end
end

#geo_spatial(criterion) ⇒ selecionável

Observação:

As únicas formas de geometria válidas para um $geoIntersects são: :intersects_line, :intersects_point e :intersects_polygon.

Observação:

As únicas opções válidas para uma query $geoWithin são a forma de geometria :within_polygon e o operador :within_box.

Observação:

O operador :within_box para a query $geoWithin espera o par de coordenadas inferior esquerdo (sudoeste) como o primeiro argumento e o canto superior direito (nordeste) como o segundo argumento. Importante: quando a latitude e a longitude são passadas, a longitude é esperada como o primeiro elemento do par de coordenadas. Fonte: https://www.mongodb.com/pt-br/docs/manual/reference/operator/query/box/

Adicione uma seleção $geoIntersects ou $geoWithin. Os operadores de símbolos devem ser usados conforme mostrado nos exemplos para expandir os critérios.

Exemplos:

Adicione um critério de interseção geográfica para uma linha.

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

Adicione um critério de interseção geográfica para um ponto.

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

Adicione um critério de interseção geográfica para um polígono.

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

Adicione uma geo dentro do critério para um polígono.

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

Adicione um geo dentro do critério para uma caixa.

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

Parâmetros:

  • criterion (Hash) —

    O critério.

Retorna:

Aumenta:



209
210
211
212
213
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 209

def geo_spatial(criterion)
  aumentar Errors::CriteriaArgumentRequired, :geo_spatial se criterion.nada?

  __merge__(criterion)
end

#gt(critério) ⇒ Seleccionado

Adicione o critério $gt ao seletor.

Exemplos:

Adicione o critério $gt.

selectable.gt(age: 60)

Execute um $gt em uma query onde.

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

Parâmetros:

  • criterion (Hash) —

    Os pares de campo/valor a serem verificados.

Retorna:

Aumenta:



258
259
260
261
262
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 258

def gt(criterion)
  aumentar Errors::CriteriaArgumentRequired, :gt se criterion.nada?

  and_with_operator(criterion, '$gt')
end

#gte(critério) ➤ Seleccionado

Adicione o critério $gte ao seletor.

Exemplos:

Adicione o critério $gte.

selectable.gte(age: 60)

Execute um $gte em uma query onde.

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

Parâmetros:

  • criterion (Hash) —

    Os pares de campo/valor a serem verificados.

Retorna:

Aumenta:



276
277
278
279
280
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 276

def gte(criterion)
  aumentar Errors::CriteriaArgumentRequired, :gte se criterion.nada?

  and_with_operator(criterion, '$gte')
end

#em(condição) ➤ selecionável Também conhecido como: any_in

Adiciona a seleção $in ao selecionável.

Exemplos:

Adicione a seleção $in em uma array.

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

Adiciona $in seleção em um intervalo.

selectable.in(age: 18..24)

Execute um $in em uma query onde.

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

Parâmetros:

  • Condição (Hash) —

    Os pares de critérios de campo/valor.

Retorna:

Aumenta:



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

def Em(Condição)
  aumentar Errors::CriteriaArgumentRequired, :in se Condição.nada?

  Condição = expand_ conditions_to_array_values(Condição)

  se estratégia
    enviar(estratégia, Condição, '$in')
  mais
    Condição.injetar(clonar) fazer |Query, (Campo, valor)|
      v = { '$in' => valor }
      v = { '$not' => v } se negando?
      Query.add_field_expression(Campo.to_s, v)
    end.reset_strategies!
  end
end

#js_query(criterion) ⇒ selecionável

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Crie uma seleção de javascript.

Exemplos:

Crie a seleção de javascript.

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

Parâmetros:

  • criterion (string) —

    O javascript como uma string.

Retorna:



826
827
828
829
830
831
832
833
834
835
836
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 826

def js_query(criterion)
  clonar.toque fazer |Query|
    se negando?
      Query.add_operator_expression('$e',
                                    [ { '$nor' => [ { '$where' => criterion } ] } ])
    mais
      Query.add_operator_expression('$where', criterion)
    end
    Query.reset_strategies!
  end
end

#lt(critério) ⇒ Seleccionado

Adicione o critério $lt ao seletor.

Exemplos:

Adicione o critério $lt.

selectable.lt(age: 60)

Execute um $lt em uma query onde.

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

Parâmetros:

  • criterion (Hash) —

    Os pares de campo/valor a serem verificados.

Retorna:

Aumenta:



326
327
328
329
330
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 326

def lt(criterion)
  aumentar Errors::CriteriaArgumentRequired, :lt se criterion.nada?

  and_with_operator(criterion, '$lt')
end

#lte(critério) ⇒ Seleccionado

Adicione o critério $lte ao seletor.

Exemplos:

Adicione o critério $lte.

selectable.lte(age: 60)

Execute um $lte em uma query onde.

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

Parâmetros:

  • criterion (Hash) —

    Os pares de campo/valor a serem verificados.

Retorna:

Aumenta:



344
345
346
347
348
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 344

def lte(criterion)
  aumentar Errors::CriteriaArgumentRequired, :lte se criterion.nada?

  and_with_operator(criterion, '$lte')
end

#max_istance(criterion) ⇒ selecionável

Adicione uma seleção $maxDistance ao selecionável.

Exemplos:

Adicione a seleção $maxDistance.

selectable.max_distance(location: 10)

Parâmetros:

  • criterion (Hash) —

    Os pares de campo/distância.

Retorna:

Aumenta:



359
360
361
362
363
364
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 359

def max_istance(criterion)
  aumentar Errors::CriteriaArgumentRequired, :max_istance se criterion.nada?

  # $maxDistance deve ser fornecido junto com $near
  __add__(criterion, '$maxDistance')
end

#mod(critério) ⇒ selecionável

Adiciona seleção $mod ao selecionável.

Exemplos:

Adicione a seleção $mod.

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

Execute um $mod em uma query onde.

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

Parâmetros:

  • criterion (Hash) —

    As seleções do campo/mod.

Retorna:

Aumenta:



377
378
379
380
381
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 377

def mod(criterion)
  aumentar Errors::CriteriaArgumentRequired, :mod se criterion.nada?

  and_with_operator(criterion, '$mod')
end

#ne(critério) ➤ Seleccionado Também conhecido como: exclui

Adiciona $ne seleção ao selecionável.

Exemplos:

Query de um valor $ne para algo.

selectable.ne(field: 10)

Execute um $ne em uma query onde.

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

Parâmetros:

  • criterion (Hash) —

    As seleções do campo/ne.

Retorna:

Aumenta:



395
396
397
398
399
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 395

def ne(criterion)
  aumentar Errors::CriteriaArgumentRequired, :ne se criterion.nada?

  and_with_operator(criterion, '$ne')
end

#próximo(critério) ➤ Seleccionado

Adiciona um critério $near a uma seleção geográfica.

Exemplos:

Adicione a seleção $near.

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

Execute um $near em uma query onde.

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

Parâmetros:

  • criterion (Hash) —

    O par de campo/localização.

Retorna:

Aumenta:



414
415
416
417
418
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 414

def perto(criterion)
  aumentar Errors::CriteriaArgumentRequired, :perto se criterion.nada?

  and_with_operator(criterion, '$near')
end

#near_sphere(criterion) ⇒ selecionável

Adiciona um critério $nearSphere a uma seleção geográfica.

Exemplos:

Adicione a seleção $nearSphere.

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

Execute um $nearSphere em uma query onde.

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

Parâmetros:

  • criterion (Hash) —

    O par de campo/localização.

Retorna:

Aumenta:



432
433
434
435
436
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 432

def near_sphere(criterion)
  aumentar Errors::CriteriaArgumentRequired, :near_sphere se criterion.nada?

  and_with_operator(criterion, '$nearSphere')
end

#negando? ➤ verdadeiro | false

O selecionável atual está negando a próxima seleção?

Exemplos:

O selecionável está negando?

selectable.negating?

Retorna:

  • (verdadeiro | falso) —

    Se o selecionável estiver negando.



490
491
492
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 490

def negando?
  !!negando
end

#nin(condição) undício selecionável Também conhecido como: not_in

Adiciona a seleção $nin ao selecionável.

Exemplos:

Adicione a seleção $nin em uma array.

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

Adiciona a seleção $nin em uma faixa.

selectable.nin(age: 18..24)

Execute um $nin em uma query onde.

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

Parâmetros:

  • Condição (Hash) —

    Os pares de critérios de campo/valor.

Retorna:

Aumenta:



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

def nin(Condição)
  aumentar Errors::CriteriaArgumentRequired, :nin se Condição.nada?

  Condição = expand_ conditions_to_array_values(Condição)

  se estratégia
    enviar(estratégia, Condição, '$nin')
  mais
    Condição.injetar(clonar) fazer |Query, (Campo, valor)|
      v = { '$nin' => valor }
      v = { '$not' => v } se negando?
      Query.add_field_expression(Campo.to_s, v)
    end.reset_strategies!
  end
end

#none_of(*critérios) ➤ Selecionado

Negue os argumentos, restringindo a query apenas aos documentos que NÃO correspondem aos argumentos.

Exemplos:

Exclua um único critério.

selectable.none_of(name: /Bob/)

Excluir vários critérios.

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

Exclua vários critérios como um array.

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

Parâmetros:

  • *critérios ([ Hash | Critérios ]...) —

    O par chave/valor corresponde a ou Criteria objetos para negar.

Retorna:



552
553
554
555
556
557
558
559
560
561
562
563
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 552

def none_of(*critério)
  critério = _mongoid_flatten_arrays(critério)
  Método dup se critério.vazio?

  exprs = critério.map fazer |criterion|
    _mongoid_expand_keys(
      criterion.is_a?(Seleccionado) ? criterion.seletor : criterion
    )
  end

  auto.e a('$nor' => exprs)
end

#nor(*critérios) ➤ Seleccionado

Adiciona seleção $nor ao selecionável.

Exemplos:

Adicione a seleção $nor.

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

Parâmetros:

  • *critérios ([ Hash | Critérios | Matriz<Hash | Critérios> ]...) —

    Várias correspondências de pares de chave/valor ou objetos Criteria.

Retorna:



480
481
482
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 480

def nem(*critério)
  _mongoid_add_top_level_operation('$nor', critério)
end

#não(*critérios) ⇒ Seleccionado

Negue os argumentos ou a próxima seleção se nenhum argumento for fornecido.

Exemplos:

Negue a próxima seleção.

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

Adicione o critério $not.

selectable.not(name: /Bob/)

Execute um $not em uma query onde.

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

Parâmetros:

  • *critérios ([ Hash | Critérios ]...) —

    O par chave/valor corresponde a ou Criteria objetos para negar.

Retorna:



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
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 509

def não(*critério)
  se critério.vazio?
    dup.toque { |Query| Query.negando = !Query.negando }
  mais
    critério.compactar.injetar(clonar) fazer |C, new_s|
      new_s = new_s.seletor se new_s.is_a?(Seleccionado)
      _mongoid_expand_keys(new_s).cada fazer |k, v|
        k = k.to_s
        se C.seletor[k] || k.start_with?('$')
          C = C.enviar(:__multi__, [ { '$nor' => [ { k => v } ] } ], '$e')
        elsif v.is_a?(Hash)
          C = C.enviar(:__multi__, [ { '$nor' => [ { k => v } ] } ], '$e')
        mais
          negated_operator = se v.is_a?(regexp)
                               '$not'
                             mais
                               '$ne'
                             end
          C = C.enviar(:__override__, { k => v }, negated_operator)
        end
      end
      C
    end
  end
end

#ou(*critérios) ⇒ Seleccionado

Cria uma disjunção usando $or a partir dos critérios existentes no receptor e dos argumentos fornecidos.

Esse comportamento (o receptor se tornando um dos operandos de disjunção) corresponde ao comportamento or do ActiveRecord.

Use any_of para adicionar uma disjunção dos argumentos como uma restrição adicional aos critérios já existentes no receptor.

Cada argumento pode ser um Hash, um objeto Critérios , uma array de objetos Hash ou Critérios ou uma array aninhada. As arrays agrupadas serão achatadas e podem ter qualquer profundidade. Passar arrays está obsoleto.

Exemplos:

Adicione a seleção $or onde ambos os campos devem ter os valores especificados.

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

Adicione a seleção $or onde qualquer correspondência de valor for suficiente.

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

Igual ao exemplo anterior, mas usando o wrap de array obsoleto.

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

Igual ao exemplo anterior, também obsoleto.

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

Parâmetros:

  • *critérios ([ Hash | Critérios | Matriz<Hash | Critérios> ]...) —

    Várias correspondências de pares de chave/valor ou objetos Criteria, ou arrays dos mesmos. Passar arrays está obsoleto.

Retorna:



595
596
597
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 595

def ou(*critério)
  _mongoid_add_top_level_operation('$or', critério)
end

#text_search(termos, opts = nil) ➤ Seleccionado

Observação:

Por https://www.mongodb.com/pt-br/docs/manual/reference/operator/query/text/ atualmente não é possível fornecer múltiplas condições de pesquisa de texto em uma query. O Mongoid construirá tal query, mas o servidor retornará um erro ao tentar executá-la.

Construa um seletor de texto do Atlas Search .

Exemplos:

Construa um seletor de texto do Atlas Search .

selectable.text_search("testing")

Construa um seletor de pesquisa de texto com opções.

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

Parâmetros:

  • termos (string | Símbolo) —

    Uma string de termos que o MongoDB analisa e usa para consultar o índice de texto.

  • opciona (Hash) (padrão para: nil) —

    Opções de Atlas Search de texto. Consulte a documentação do MongoDB para opções.

Retorna:

Aumenta:



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

def text_search(termos, opciona = nada)
  aumentar Errors::CriteriaArgumentRequired, :termos se termos.nada?

  clonar.toque fazer |Query|
    criterion = { '$text' => { '$search' => termos } }
    criterion['$text'].mesclar!(opciona) se opciona
    se Query.seletor['$text']
      # Per https://www.mongodb.com/pt-br/docs/manual/reference/operator/query/text/
      # múltiplas expressões $text não são atualmente suportadas por
      # Servidor MongoDB, mas construa a query corretamente em vez de
      # substituindo a condição de pesquisa de texto anterior pela atual
      # dado um.
      Mongoid.logger.AVISAR('Várias expressões de $text por query não são atualmente suportadas pelo servidor')
      Query.seletor = { '$e' => [ Query.seletor ] }.mesclar(criterion)
    mais
      Query.seletor = Query.seletor.mesclar(criterion)
    end
  end
end

#onde(*critérios) ➤ Seleccionado

Este é o ponto de entrada geral para a maioria das consultas MongoDB. Isso cria um campo padrão: seleção de valor e seleção expandida com o uso de métodos de hash ou uma seleção $where se uma string for fornecida.

Exemplos:

Adicione uma seleção padrão.

selectable.where(name: "syd")

Adicione uma seleção JavaScript .

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

Parâmetros:

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

    A seleção padrão ou JavaScript string.

Retorna:



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

def ONDE(*critério)
  Método clonar.reset_strategies! se critério.vazio?

  critério.injetar(auto) fazer |Query, criterion|
    aumentar Errors::CriteriaArgumentRequired, :where se criterion.nada?

    # Precisamos salvar o critério em uma variável de instância para que
    # Métodos modificáveis sabe como criar um objeto polimórfico .
    # Observe que este método, em princípio, aceita vários critérios,
    # mas apenas o primeiro será armazenado em @criterion. Isto
    # funciona bem porque first_or_create etc.
    # especifique sempre um critério para #onde.
    @criterion = criterion
    se criterion.is_a?(String)
      Query.js_query(criterion)
    mais
      Query.expr_query(criterion)
    end
  end
end

#with_size(critério) ⇒ Seleccionado

Observação:

Este método é denominado #with_size para não entrar em conflito com nenhum método #size existente em enumeráveis ou símbolos.

Adicione uma seleção $size para campos de array.

Exemplos:

Adicione a seleção $size.

selectable.with_size(field: 5)

Execute um $size em uma query onde.

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

Parâmetros:

  • criterion (Hash) —

    O critério de pares de campo/tamanho.

Retorna:

Aumenta:



669
670
671
672
673
674
675
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 669

def with_size(criterion)
  aumentar Errors::CriteriaArgumentRequired, :with_size se criterion.nada?

  typed_override(criterion, '$size') fazer |valor|
    ::Inteiro.evolua(valor)
  end
end

#with_type(critério) ➤ Seleccionado

Observação:

http://vurl.me/PGOU contém uma lista de todos os tipos.

Adiciona uma seleção $type ao selecionável.

Exemplos:

Adicione a seleção $type.

selectable.with_type(field: 15)

Execute um $type em uma query onde.

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

Parâmetros:

  • criterion (Hash) —

    Os pares de campo/tipo.

Retorna:

Aumenta:



693
694
695
696
697
698
699
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 693

def with_type(criterion)
  aumentar Errors::CriteriaArgumentRequired, :with_type se criterion.nada?

  typed_override(criterion, '$type') fazer |valor|
    ::Inteiro.evolua(valor)
  end
end