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

Estendido por:
macroable
Definido em:
build/mongoid-8.1/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.



24
25
26
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 24

def negando
  @ negando
end

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



24
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 24

attr_accessor : negating, :selector

#seletorObjeto

Retorna o valor do seletor de atributo.



24
25
26
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 24

def seletor
  @selector
end

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



24
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 24

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.



960
961
962
963
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 960

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:



37
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
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 37

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:



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
102
103
104
105
106
107
108
109
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 77

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:



673
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
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 673

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:



123
124
125
126
127
128
129
130
131
132
133
134
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 123

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:



153
154
155
156
157
158
159
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 153

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

  and_or_override(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:



256
257
258
259
260
261
262
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 256

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

  and_or_override(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:



176
177
178
179
180
181
182
183
184
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 176

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:



223
224
225
226
227
228
229
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 223

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:



276
277
278
279
280
281
282
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 276

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

  and_or_override(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:



296
297
298
299
300
301
302
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 296

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

  and_or_override(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:



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

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:



352
353
354
355
356
357
358
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 352

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

  and_or_override(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:



372
373
374
375
376
377
378
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 372

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

  and_or_override(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:



389
390
391
392
393
394
395
396
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 389

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:



409
410
411
412
413
414
415
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 409

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

  and_or_override(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:



429
430
431
432
433
434
435
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 429

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

  and_or_override(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:



450
451
452
453
454
455
456
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 450

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

  and_or_override(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:



470
471
472
473
474
475
476
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 470

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

  and_or_override(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.



534
535
536
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 534

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:



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

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:



600
601
602
603
604
605
606
607
608
609
610
611
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 600

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:



524
525
526
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 524

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:



553
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
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 553

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:



643
644
645
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 643

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:



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

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:



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

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:



717
718
719
720
721
722
723
724
725
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 717

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:



743
744
745
746
747
748
749
750
751
# File 'build/mongoid-8.1/lib/mongoid/criteria/queryable/selectable.rb', linha 743

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

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