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.



25
26
27
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 25

def negando
  @ negando
end

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



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

attr_accessor : negating, :selector

#seletor ➤ Objeto

Retorna o valor do seletor de atributo.



25
26
27
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 25

def seletor
  @selector
end

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



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

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.



945
946
947
948
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 945

def encaminháveis
  public_instance_methods(false) -
    [ : negating, : negating=, : negando?, :selector, :selector= ]
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:



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

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|
    se Condição.nada?
      aumentar Errors::CriteriaArgumentRequired, :all
    end

    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}
        se negando?
          v = {'$not' => v}
        end
        _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:



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

def e a(*critério)
  _mongoid_flatten_arrays(critério).injetar(auto.clonar) fazer |C, new_s|
    se new_s.is_a?(Seleccionado)
      new_s = new_s.seletor
    end
    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?('$') }
        então
          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:



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

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:



124
125
126
127
128
129
130
131
132
133
134
135
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 124

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

  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:



154
155
156
157
158
159
160
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 154

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

  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:



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

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

  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:



177
178
179
180
181
182
183
184
185
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 177

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

  typed_override(criterion, "$existe") fazer |valor|
    Mongoid::Boolean.evolua(valor)
  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: 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:



224
225
226
227
228
229
230
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 224

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

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



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

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

  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:



297
298
299
300
301
302
303
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 297

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

  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:



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

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

  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}
      se negando?
        v = {'$not' => v}
      end
      Query.add_field_expression(Campo.to_s, v)
    end.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:



353
354
355
356
357
358
359
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 353

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

  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:



373
374
375
376
377
378
379
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 373

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

  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:



390
391
392
393
394
395
396
397
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 390

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

  # $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:



410
411
412
413
414
415
416
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 410

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

  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:



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

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

  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:



451
452
453
454
455
456
457
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 451

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

  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:



471
472
473
474
475
476
477
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 471

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

  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.



535
536
537
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 535

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:



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

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

  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}
      se negando?
        v = {'$not' => v}
      end
      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:



601
602
603
604
605
606
607
608
609
610
611
612
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 601

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:



525
526
527
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 525

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:



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

def não(*critério)
  se critério.vazio?
    dup.toque { |Query| Query.negando = true }
  mais
    critério.compactar.injetar(auto.clonar) fazer |C, new_s|
      se new_s.is_a?(Seleccionado)
        new_s = new_s.seletor
      end
      _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')
        mais
          se v.is_a?(Hash)
            C = C.enviar(:__multi__, [{'$nor' => [{k => v}]}], '$e')
          mais
            se v.is_a?(regexp)
              negated_operator = '$not'
            mais
              negated_operator = '$ne'
            end
            C = C.enviar(:__override__, {k => v}, negated_operator)
          end
        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:



644
645
646
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 644

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

#text_search(termos, opts = nil) ➤ Seleccionado

Observação:

Por http://mongodb.com/pt-br/docs/manual/reference/operator/query/text/ atualmente não é possível fornecer múltiplas condições de texto do Atlas Search 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:



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

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

  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:



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

def ONDE(*critério)
  critério.injetar(clonar) fazer |Query, criterion|
    se criterion.nada?
      aumentar Errors::CriteriaArgumentRequired, :where
    end

    # 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)
      js_query(criterion)
    mais
      expr_query(criterion)
    end
  end.reset_strategies!
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:



718
719
720
721
722
723
724
725
726
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 718

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

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

#with_type(critério) ➤ Seleccionado

Observação:

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:



744
745
746
747
748
749
750
751
752
 
# Arquivo 'lib/mongoid/criteria/queryable/selectable.rb', linha 744

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

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