Módulo: Mongo::Collection::View::Readable

Incluído em:
Mongo::collection::Visualizar
Definido em:
lib/mongo/collection/view/readable.rb

Visão geral

Define o comportamento relacionado à leitura para visualização de collection.

Desde:

  • 2.0.0

Recolhimento do Resumo do método de instância

Detalhes do método de instância

#aggregate(pipeline, options = {}) ➤ Aggregation

Execute uma aggregation na visualização da collection.

Exemplos:

Documentos agregados.

view.aggregate([
  { "$group" => { "_id" => "$city", "tpop" => { "$sum" => "$pop" }}}
])

Parâmetros:

  • gasoduto (Array<Hash>) —

    O pipeline de agregação .

  • opções (Hash) (padrão para: {}) —

    As opções de aggregation.

Hash de opções (opções):

  • :allow_disk_use (verdadeiro, falso) —

    Defina como verdadeiro se o uso do disco for permitido durante a agregação.

  • :batch_size (Inteiro) —

    O número de documentos a serem devolvidos por lote.

  • :bypass_document_validation (verdadeiro, falso) —

    Se deve ou não ignorar a validação em nível de documento .

  • :collation (Hash) —

    O agrupamento a ser usado.

  • :comentário (Objeto) —

    Um comentário fornecido pelo usuário para anexar a este comando.

  • :hint (string) —

    O índice a ser usado para a agregação.

  • :let (Hash) —

    Mapeamento de variáveis a serem usadas no pipeline. Consulte a documentação do servidor para obter detalhes.

  • :max_time_ms (Inteiro) —

    A quantidade máxima de tempo em milissegundos para permitir a execução da agregação . Esta opção está obsoleta, use :timeout_ms em vez disso.

  • :session (Sessão) —

    A sessão a ser usada.

  • :timeout_ms (Inteiro) —

    O tempo limite da operação em milissegundos. Deve ser um número inteiro não negativo. Um valor explícito de 0 significa infinito. O valor padrão não está definido, o que significa que o valor é herdado da coleção, do banco de dados ou do cliente.

Retorna:

Desde:

  • 2.0.0

[Ver fonte]

61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/mongo/collection/view/readable.rb', linha 61

def Agregação(gasoduto, opções = {})
  opções = @opções.mesclar(opções) a menos que mongo.quebrado_view_options
  Aggregation = Agregação.Novo(auto, gasoduto, opções)

  # Como os estágios de pipeline $merge e $out gravam documentos no
  # collection, é necessário limpar o cache quando elas forem executadas.
  #
  # Opte por limpar todo o cache em vez de um namespace, pois
  # os estágios $out e $merge não precisam escrever no mesmo namespace
  # no qual a agregação é realizada.
  Cache de consulta.Limpar se Aggregation.escrever?

  Aggregation
end

#allow_disk_use ➤ Visualizar

Permite que o servidor escreva dados temporários no disco enquanto executa uma operação de busca.

Retorna:

Desde:

  • 2.0.0

[Ver fonte]

80
81
82
 
# File 'lib/mongo/collection/view/readable.rb', linha 80

def allow_disk_use
  configure(:allow_disk_use, true)
end

#allow_partial_results ➤ Visualizar

Permite que a query obtenha resultados parciais se alguns shards estiverem inativos.

Exemplos:

Permitir resultados parciais.

view.allow_partial_results

Retorna:

Desde:

  • 2.0.0

[Ver fonte]

92
93
94
 
# File 'lib/mongo/collection/view/readable.rb', linha 92

def allow_partial_results
  configure(:allow_partial_results, true)
end

#await_data ➤ Visualizar

Diga ao cursor da query para ficar aberto e aguardar os dados.

Exemplos:

Aguarda dados no cursor.

view.await_data

Retorna:

Desde:

  • 2.0.0

[Ver fonte]

104
105
106
 
# File 'lib/mongo/collection/view/readable.rb', linha 104

def await_data
  configure(:await_data, true)
end

#batch_size(batch_size = nil) ⇒ Integer, View

Observação:

Especificar 1 ou um número negativo é análogo à definição de um limite.

O número de documentos retornados em cada lote de resultados do MongoDB.

Exemplos:

Defina o tamanho do lote .

view.batch_size(5)

Parâmetros:

  • batch_size (Inteiro) (padrão para: nil) —

    O tamanho de cada lote de resultados.

Retorna:

  • (Inteiro, Visualizar) —

    O valor batch_size ou um novo View.

Desde:

  • 2.0.0

[Ver fonte]

121
122
123
 
# File 'lib/mongo/collection/view/readable.rb', linha 121

def batch_size(batch_size = nada)
  configure(:batch_size, batch_size)
end

#comentário(comentário = nil) ➤ string, Visualizar

Observação:

Defina profilingLevel como 2 e o comentário será registrado na coleção de perfil junto com a query.

Associe um comentário à query.

Exemplos:

Adicione um comentário.

view.comment('slow query')

Parâmetros:

  • comment (Objeto) (padrão para: nil) —

    O comentário a ser associado à query.

Retorna:

  • (string, Visualizar) —

    O comentário ou um novo View.

Desde:

  • 2.0.0

[Ver fonte]

139
140
141
 
# File 'lib/mongo/collection/view/readable.rb', linha 139

def comment(comment = nada)
  configure(:comentário, comment)
end

#count(opts = {}) ⇒ Inteiro

Obsoleto.

Use #count_documents ou #estimated_document_count em vez disso. No entanto, observe que os seguintes operadores precisarão ser substituídos ao mudar para #count_documents:

* $where should be replaced with $expr (only works on 3.6+)
* $near should be replaced with $geoWithin with $center
* $nearSphere should be replaced with $geoWithin with $centerSphere

Obtenha uma contagem de documentos correspondentes na coleção.

Exemplos:

Obtenha o número de documentos na coleção.

collection_view.count

Parâmetros:

  • opciona (Hash) (padrão para: {}) —

    Opções para a operação.

  • opções (Hash) —

    um conjunto personalizável de opções

Hash de opções (opts):

  • :skip (Inteiro) —

    O número de documentos a ignorar.

  • :hint (Hash) —

    Substituir seleção de índice padrão e forçar o MongoDB a usar um índice específico para a query.

  • :limit (Inteiro) —

    Número máximo de Docs para contar.

  • :max_time_ms (Inteiro) —

    A quantidade máxima de tempo para permitir a execução do comando.

  • :read (Hash) —

    As opções de preferência de leitura .

  • :collation (Hash) —

    O agrupamento a ser usado.

  • :session (Mongo::Session) —

    A sessão a ser usada para a operação.

  • :comentário (Objeto) —

    Um comentário fornecido pelo usuário para anexar a este comando.

Retorna:

  • (Inteiro) —

    A contagem de documento .

Desde:

  • 2.0.0

[Ver fonte]

175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
 
# File 'lib/mongo/collection/view/readable.rb', linha 175

def contar(opciona = {})
  opciona = @opções.mesclar(opciona) a menos que mongo.quebrado_view_options
  cmd = { :count => collection.name, :query => filtro, filtro }
  cmd[:skip] = opciona[:skip] se opciona[:skip]
  cmd[:hint] = opciona[:hint] se opciona[:hint]
  cmd[:limit] = opciona[:limit] se opciona[:limit]
  se read_concern
    cmd[:readConcern] = Opções::Mapeador.transform_values_to_strings(
      read_concern)
  end
  cmd[:maxTimeMS] = opciona[:max_time_ms] se opciona[:max_time_ms]
  mongo::Lint.validate_subscore_read_preference(opciona[:read])
  read_pref = opciona[:read] || read_preference
  seletor = ServerSelector.obter(read_pref || server_selector)
  with_session(opciona) fazer |session|
    Contexto = (operação)::Contexto.Novo(
      cliente: Cliente,
      sessão: session,
      operation_timeouts: operation_timeouts(opciona)
    )
    read_with_retry(session, seletor, Contexto) fazer |Servidor|
      (operação)::Contar.Novo(
        seletor: cmd,
        db_name: database.name,
        opções: {:limit => -1},
        ler: read_pref,
        sessão: session,
        # Por alguma razão, o agrupamento foi historicamente aceito como
        # chave de string. Observe que isso não está documentado como uso válido.
        agrupamento: opciona[:collation] || opciona['agrupamento'] || agrupamento,
        comment: opciona[:comentário],
      ).executar, executar(
        Servidor,
        contexto: Contexto
      )
    end.n.to_i
  end
end

#count_documents(opts = {}) ➤ inteiro

Obtenha uma contagem de documentos correspondentes na coleção.

Exemplos:

Obtenha o número de documentos na coleção.

collection_view.count

Parâmetros:

  • opciona (Hash) (padrão para: {}) —

    Opções para a operação.

  • ops (Hash) —

    um conjunto personalizável de opções

  • opções (Hash) —

    um conjunto personalizável de opções

Hash de opções (opts):

  • :skip (Inteiro) —

    O número de documentos a ignorar.

  • :hint (Hash) —

    Substituir seleção de índice padrão e forçar o MongoDB a usar um índice específico para a query. Requer versão do servidor 3.6+.

  • :limit (Inteiro) —

    Número máximo de Docs para contar.

  • :max_time_ms (Inteiro) —

    A quantidade máxima de tempo para permitir a execução do comando. Esta opção está obsoleta, use :timeout_ms em vez disso.

  • :read (Hash) —

    As opções de preferência de leitura .

  • :collation (Hash) —

    O agrupamento a ser usado.

  • :session (Mongo::Session) —

    A sessão a ser usada para a operação.

Retorna:

  • (Inteiro) —

    A contagem de documento .

Desde:

  • 2.6.0

[Ver fonte]

241
242
243
244
245
246
247
248
249
250
251
252
253
254
 
# File 'lib/mongo/collection/view/readable.rb', linha 241

def count_documents(opciona = {})
  opciona = @opções.mesclar(opciona) a menos que mongo.quebrado_view_options
  gasoduto = [:'$match' => filtro, filtro]
  gasoduto << { :'$skip' => opciona[:skip] } se opciona[:skip]
  gasoduto << { :'$limit' => opciona[:limit] } se opciona[:limit]
  gasoduto << { :'$group' => { _id: 1, n: { :'$sum' => 1 } } }

  opciona = opciona.fatia(:hint, :max_time_ms, :read, :collation, :session, :comentário, :timeout_ms)
  opciona[:collation] ||= agrupamento

  primeiro = Agregação(gasoduto, opciona).primeiro
  Método 0 a menos que primeiro
  primeiro['n'].to_i
end

#cursor_type(type = nil) ➤ :tailable, ...

O tipo de cursor a ser usado. Pode ser :tailable ou :tailable_await.

Exemplos:

Defina o tipo de cursor.

view.cursor_type(:tailable)

Parâmetros:

  • type (:tailable, :tailable_await) (padrão para: nil) —

    O tipo de cursor.

Retorna:

  • (:tailable, :tailable_await, Visualizar) —

    A configuração do tipo de cursor ou um novo View.

Desde:

  • 2.3.0

[Ver fonte]

660
661
662
 
# File 'lib/mongo/collection/view/readable.rb', linha 660

def cursor_type(type = nada)
  configure(:cursor_type, type)
end

#distinct(field_name, opts = {}) ➤ Array<Object>

Obtenha uma lista de valores distintos para um campo específico .

Exemplos:

Obtenha os valores distintos.

collection_view.distinct('name')

Parâmetros:

  • field_name (string, símbolo) —

    O nome do campo.

  • opciona (Hash) (padrão para: {}) —

    Opções para o comando distinto.

  • opções (Hash) —

    um conjunto personalizável de opções

Hash de opções (opts):

  • :max_time_ms (Inteiro) —

    A quantidade máxima de tempo para permitir a execução do comando.

  • :read (Hash) —

    As opções de preferência de leitura .

  • :collation (Hash) —

    O agrupamento a ser usado.

Retorna:

  • (Array<Object>) —

    A lista de valores distintos.

Desde:

  • 2.0.0

[Ver fonte]

343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
 
# File 'lib/mongo/collection/view/readable.rb', linha 343

def distinto(field_name, opciona = {})
  se field_name.nada?
    aumentar ArgumentError, 'O nome do campo para operação distinta não deve ser nulo'
  end
  opciona = @opções.mesclar(opciona) a menos que mongo.quebrado_view_options
  cmd = { :distinct => collection.name,
          :key => field_name.to_s,
          :query => filtro, filtro, }
  cmd[:maxTimeMS] = opciona[:max_time_ms] se opciona[:max_time_ms]
  se read_concern
    cmd[:readConcern] = Opções::Mapeador.transform_values_to_strings(
      read_concern)
  end
  mongo::Lint.validate_subscore_read_preference(opciona[:read])
  read_pref = opciona[:read] || read_preference
  seletor = ServerSelector.obter(read_pref || server_selector)
  with_session(opciona) fazer |session|
    Contexto = (operação)::Contexto.Novo(
      cliente: Cliente,
      sessão: session,
      operation_timeouts: operation_timeouts(opciona)
    )
    read_with_retry(session, seletor, Contexto) fazer |Servidor|
      (operação)::distinto.Novo(
        seletor: cmd,
        db_name: database.name,
        opções: {:limit => -1},
        ler: read_pref,
        sessão: session,
        comment: opciona[:comentário],
        # Por alguma razão, o agrupamento foi historicamente aceito como
        # chave de string. Observe que isso não está documentado como uso válido.
        agrupamento: opciona[:collation] || opciona['agrupamento'] || agrupamento,
      ).executar, executar(
        Servidor,
        contexto: Contexto
      )
    end.primeiro['valores']
  end
end

#estimated_document_count(opts = {}) ➤ Inteiro

Obtém uma estimativa da contagem de documentos em uma collection usando metadados de collection.

Exemplos:

Obtenha o número de documentos na coleção.

collection_view.estimated_document_count

Parâmetros:

  • opciona (Hash) (padrão para: {}) —

    Opções para a operação.

  • opções (Hash) —

    um conjunto personalizável de opções

Hash de opções (opts):

  • :max_time_ms (Inteiro) —

    A quantidade máxima de tempo para permitir a execução do comando.

  • :read (Hash) —

    As opções de preferência de leitura .

  • :comentário (Objeto) —

    Um comentário fornecido pelo usuário para anexar a este comando.

Retorna:

  • (Inteiro) —

    A contagem de documento .

Desde:

  • 2.6.0

[Ver fonte]

276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
 
# File 'lib/mongo/collection/view/readable.rb', linha 276

def estimated_document_count(opciona = {})
  a menos que vista.filtro, filtro.vazio?
    aumentar ArgumentError, "Não é possível chamar estimated_document_count ao consultar com um filtro"
  end

  %i[limit ignorar].cada fazer |opt|
    se opções.chave?(opt) || opciona.chave?(opt)
      aumentar ArgumentError, "Não é possível chamar estimated_document_count ao fazer query com #{opt}"
    end
  end

  opciona = @opções.mesclar(opciona) a menos que mongo.quebrado_view_options
  mongo::Lint.validate_subscore_read_preference(opciona[:read])
  read_pref = opciona[:read] || read_preference
  seletor = ServerSelector.obter(read_pref || server_selector)
  with_session(opciona) fazer |session|
    Contexto = (operação)::Contexto.Novo(
      cliente: Cliente,
      sessão: session,
      operation_timeouts: operation_timeouts(opciona)
    )
    read_with_retry(session, seletor, Contexto) fazer |Servidor|
      cmd = { contar: collection.name }
      cmd[:maxTimeMS] = opciona[:max_time_ms] se opciona[:max_time_ms]
      se read_concern
        cmd[:readConcern] = Opções::Mapeador.transform_values_to_strings(read_concern)
      end
      Resultado = (operação)::Contar.Novo(
        seletor: cmd,
        db_name: database.name,
        ler: read_pref,
        sessão: session,
        comment: opciona[:comentário],
      ).executar, executar(Servidor, contexto: Contexto)
      Resultado.n.to_i
    end
  end
salvar Erro::Falha de operação::família => exc
  se exc.código == 26
    # NamespaceNotFound
    # Isso só deve acontecer com o caminho do pipeline de agregação
    # (servidor 4.9+). Os servidores anteriores devem retornar 0 para inexistente
    # collections.
    0
  mais
    aumentar
  end
end

#dica(dica = nil) ➤ Hash, Visualização

O índice que o MongoDB será forçado a usar para a query.

Exemplos:

Defina a dica de índice.

view.hint(name: 1)

Parâmetros:

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

    O índice a ser usado para a query.

Retorna:

Desde:

  • 2.0.0

[Ver fonte]

394
395
396
 
# File 'lib/mongo/collection/view/readable.rb', linha 394

def dica(dica = nada)
  configure(:hint, dica)
end

#limit(limit = nil) ⇒ Integer, View

O número máximo de Docs a retornar da consulta.

Exemplos:

Defina o limite.

view.limit(5)

Parâmetros:

  • limit (Inteiro) (padrão para: nil) —

    O número de Docs a serem devolvidos.

Retorna:

  • (Inteiro, Visualizar) —

    O limite ou um novo View.

Desde:

  • 2.0.0

[Ver fonte]

408
409
410
 
# File 'lib/mongo/collection/view/readable.rb', linha 408

def limit(limit = nada)
  configure(:limit, limit)
end

#map_reduce(map, reduzir, opções = {}) ➤ MapReduce

Execute uma operação de mapeamento/redução na visualização da coleção.

Exemplos:

Execute um mapeamento/redução.

view.map_reduce(map, reduce)

Parâmetros:

  • map (string) —

    A função JavaScript do mapa.

  • reduzir (string) —

    A função reduzir JavaScript .

  • opções (Hash) (padrão para: {}) —

    As opções de mapear/reduzir.

Retorna:

  • (MapReduce) —

    O wrapper de redução de mapa.

Desde:

  • 2.0.0

[Ver fonte]

424
425
426
 
# File 'lib/mongo/collection/view/readable.rb', linha 424

def map_reduce(map, reduzir, opções = {})
  Redução de mapa.Novo(auto, map, reduzir, @opções.mesclar(opções))
end

#max_await_time_ms(max = nil) ➤ Integer, View

Um limite de tempo cumulativo em milissegundos para processamento de obter mais operações em um cursor.

Exemplos:

Defina o valor máximo de tempo de espera ms.

view.max_await_time_ms(500)

Parâmetros:

  • max (Inteiro) (padrão para: nil) —

    O tempo máximo em milissegundos.

Retorna:

  • (Inteiro, Visualizar) —

    O valor máximo de tempo de espera ms ou um novo View.

Desde:

  • 2.1.0

[Ver fonte]

632
633
634
 
# File 'lib/mongo/collection/view/readable.rb', linha 632

def max_await_time_ms(max = nada)
  configure(:max_await_time_ms, max)
end

#max_scan(value = nil) ⇒ Integer, View

Obsoleto.

Esta opção está obsoleta a partir da versão 4.0 do servidor MongoDB.

Defina o número máximo de documentos a serem digitalizados.

Exemplos:

Defina o valor máximo de varredura.

view.max_scan(1000)

Parâmetros:

  • valor (Inteiro) (padrão para: nil) —

    O número máximo a ser analisado.

Retorna:

  • (Inteiro, Visualizar) —

    O valor ou um novo View.

Desde:

  • 2.0.0

[Ver fonte]

441
442
443
 
# File 'lib/mongo/collection/view/readable.rb', linha 441

def max_scan(valor = nada)
  configure(:max_scan, valor)
end

#max_time_ms(max = nil) ➤ Integer, View

Um limite de tempo cumulativo em milissegundos para operações de processamento em um cursor.

Exemplos:

Defina o valor ms de tempo máximo.

view.max_time_ms(500)

Parâmetros:

  • max (Inteiro) (padrão para: nil) —

    O tempo máximo em milissegundos.

Retorna:

  • (Inteiro, Visualizar) —

    O valor ms de tempo máximo ou um novo View.

Desde:

  • 2.1.0

[Ver fonte]

646
647
648
 
# File 'lib/mongo/collection/view/readable.rb', linha 646

def max_time_ms(max = nada)
  configure(:max_time_ms, max)
end

#max_value(value = nil) ➤ Hash, Visualizar

Defina o valor máximo para Atlas Search.

Exemplos:

Defina o valor máximo.

view.max_value(_id: 1)

Parâmetros:

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

    O campo e o valor máximo.

Retorna:

Desde:

  • 2.1.0

[Ver fonte]

455
456
457
 
# File 'lib/mongo/collection/view/readable.rb', linha 455

def max_value(valor = nada)
  configure(:max_value, valor)
end

#min_value(value = nil) ➤ Hash, Visualizar

Defina o valor mínimo para pesquisar.

Exemplos:

Defina o valor mínimo.

view.min_value(_id: 1)

Parâmetros:

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

    O campo e o valor mínimos.

Retorna:

Desde:

  • 2.1.0

[Ver fonte]

469
470
471
 
# File 'lib/mongo/collection/view/readable.rb', linha 469

def min_value(valor = nada)
  configure(:min_value, valor)
end

#modifiers(doc = nil) ⇒ Hash, View

Se chamado sem argumentos ou com um argumento nulo, retorna os modificadores do servidor legado (OP_QUERY) para a visualização atual. Se for chamado com um argumento não nulo, que deve ser um hash ou uma subclasse, mescla os modificadores fornecidos na exibição atual. As chaves de string e símbolo são permitidas no hash de entrada.

Exemplos:

Defina o documento de modificadores.

view.modifiers(:$orderby => Mongo::Index::ASCENDING)

Parâmetros:

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

    O documento de modificadores.

Retorna:

  • (Hash, Visualizar) —

    O documento de modificadores ou um novo View.

Desde:

  • 2.1.0

[Ver fonte]

613
614
615
616
617
618
619
 
# File 'lib/mongo/collection/view/readable.rb', linha 613

def modifiers(doc = nada)
  se doc.nada?
    (operação)::encontrar::Construtor::Modifiers.map_server_modifiers(opções)
  mais
    Novo(opções.mesclar((operação)::encontrar::Construtor::Modifiers.map_driver_options(BSON::Documento.Novo(doc))))
  end
end

#no_cursor_timeout ➤ Visualizar

O servidor normalmente atinge o tempo limite dos cursores ociosos após um período de inatividade (10 minutos) para evitar o uso excessivo de memória. Defina esta opção para evitar isso.

Exemplos:

Defina o cursor para não atingir o tempo limite.

view.no_cursor_timeout

Retorna:

Desde:

  • 2.0.0

[Ver fonte]

482
483
484
 
# File 'lib/mongo/collection/view/readable.rb', linha 482

def no_cursor_timeout
  configure(:no_cursor_timeout, true)
end

#parallel_scan(cursor_count, opções = {}) ➤ Objeto

Desde:

  • 2.0.0

[Ver fonte]

702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
 
# File 'lib/mongo/collection/view/readable.rb', linha 702

def parallel_scan(cursor_count, opções = {})
  se opções[:session]
    # A sessão seria substituída pela de +options+ mais tarde.
    session = Cliente.get_session(@opções)
  mais
    session = nada
  end
  Servidor = server_selector.select_server(cluster, nada, session)
  especificações = {
    coll_name: collection.name,
    db_name: database.name,
    cursor_count: cursor_count,
    read_concern: read_concern,
    sessão: session,
  }.update(opções)
  session = especificações[:session]
  op = (operação)::ParallelScan.Novo(especificações)
  # Observe que o objeto de contexto não deve ser reutilizado para subsequentes
  # Operações GetMore.
  Contexto = (operação)::Contexto.Novo(cliente: Cliente, sessão: session)
  Resultado = op.executar, executar(Servidor, contexto: Contexto)
  Resultado.cursor_ids.map fazer |cursor_id|
    especificações = {
      cursor_id: cursor_id,
      coll_name: collection.name,
      db_name: database.name,
      sessão: session,
      batch_size: batch_size,
      to_return: 0,
      # max_time_ms não está sendo passado aqui, presumi intencionalmente?
    }
    op = (operação)::pegue mais.Novo(especificações)
    Contexto = (operação)::Contexto.Novo(
      cliente: Cliente,
      sessão: session,
      connection_global_id: Resultado.connection_global_id,
    )
    Resultado = se Servidor.load_balancer?
               # A conexão será verificada quando o cursor for drenado.
               Conexão = Servidor.pool.check_out(contexto: Contexto)
               op.execute_with_connection(Conexão, contexto: Contexto)
             mais
               op.executar, executar(Servidor, contexto: Contexto)
             end
    Cursor.Novo(auto, Resultado, Servidor, sessão: session)
  end
end

#projeção(documento = nil) ➤ Hash, Visualizar

Observação:

Um valor de 0 exclui um campo do documento. Um valor de 1 a inclui. Os valores devem ser todos 0 ou todos ser 1, com exceção do valor _id. O campo _id é incluído por padrão. Deve ser excluído explicitamente.

Os campos a incluir ou excluir de cada documento no conjunto de resultados.

Exemplos:

Defina os campos como para incluir ou excluir.

view.projection(name: 1)

Parâmetros:

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

    O campo e 1 ou 0 para incluí-lo ou excluí-lo.

Retorna:

  • (Hash, Visualizar) —

    Os campos ou um novo View.

Desde:

  • 2.0.0

[Ver fonte]

500
501
502
503
 
# File 'lib/mongo/collection/view/readable.rb', linha 500

def projeção(documento = nada)
  validate_doc!(documento) se documento
  configure(:projection, documento)
end

#read(value = nil) ➤ Símbolo, visualização

Observação:

Se nenhum for especificado para a query, a preferência de leitura da coleção será usada.

A preferência de leitura a ser usada para a query.

Parâmetros:

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

    O modo de read preference a ser usado para a query.

Retorna:

Desde:

  • 2.0.0

[Ver fonte]

516
517
518
519
 
# File 'lib/mongo/collection/view/readable.rb', linha 516

def ler(valor = nada)
  Método read_preference se valor.nada?
  configure(:read, valor)
end

#read_concern ➤ Objeto

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.

Desde:

  • 2.0.0

[Ver fonte]

674
675
676
677
678
679
680
 
# File 'lib/mongo/collection/view/readable.rb', linha 674

def read_concern
  se opções[:session] && opções[:session].in_transaction?
    opções[:session].enviar(:txn_read_concern) || collection.Cliente.read_concern
  mais
    collection.read_concern
  end
end

#read_preference ➤ Objeto

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.

Desde:

  • 2.0.0

[Ver fonte]

683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
 
# File 'lib/mongo/collection/view/readable.rb', linha 683

def read_preference
  @read_preference ||= começar
    # A preferência de leitura da operação é sempre respeitada e tem o
    # maior prioridade. Se estamos em uma transação, analisamos
    # preferência de leitura de transação e padrão para o cliente, ignorando
    # preferência de leitura da coleção . Se não estivermos em uma transação, nós
    # veja a preferência de leitura da coleção que tem como padrão o cliente.
    rp = se opções[:read]
      opções[:read]
    elsif opções[:session] && opções[:session].in_transaction?
      opções[:session].txn_read_preference || collection.Cliente.read_preference
    mais
      collection.read_preference
    end
    Lint.validate_subscore_read_preference(rp)
    rp
  end
end

#return_key(value = nil) ➤ true, ...

Defina se deseja retornar apenas o campo ou campos indexados.

Exemplos:

Defina o valor da chave de retorno.

view.return_key(true)

Parâmetros:

  • valor (verdadeiro, falso) (padrão para: nil) —

    O valor da chave de retorno.

Retorna:

  • (true, false, Visualizar) —

    O valor ou um novo View.

Desde:

  • 2.1.0

[Ver fonte]

531
532
533
 
# File 'lib/mongo/collection/view/readable.rb', linha 531

def return_key(valor = nada)
  configure(:return_key, valor)
end

#show_disk_loc(value = nil) ➤ true, ... Também conhecido como: show_record_id

Defina se a localização do disco deve ser mostrada para cada documento.

Exemplos:

Defina a opção mostrar localização do disco.

view.show_disk_loc(true)

Parâmetros:

  • valor (verdadeiro, falso) (padrão para: nil) —

    O valor do campo.

Retorna:

  • (true, false, Visualizar) —

    O valor ou um novo View.

Desde:

  • 2.0.0

[Ver fonte]

546
547
548
 
# File 'lib/mongo/collection/view/readable.rb', linha 546

def show_disk_loc(valor = nada)
  configure(:show_disk_loc, valor)
end

#skip(number = nil) ⇒ Integer, Visualizar

O número de Docs a ignorar antes de retornar os resultados.

Exemplos:

Defina o número a ser ignorado.

view.skip(10)

Parâmetros:

  • número (Inteiro) (padrão para: nil) —

    Número de Docs a ignorar.

Retorna:

  • (Inteiro, Visualizar) —

    O valor de pular ou um novo View.

Desde:

  • 2.0.0

[Ver fonte]

562
563
564
 
# File 'lib/mongo/collection/view/readable.rb', linha 562

def ignorar(número = nada)
  configure(:skip, número)
end

#snapshot(valor = nil) ➤ Objeto

Obsoleto.

Esta opção está obsoleta a partir da versão 4.0 do servidor MongoDB.

Observação:

Quando definido como verdadeiro, impede que os documentos retornem mais de uma vez.

Defina o valor do snapshot para a visualização.

Exemplos:

Defina o valor do snapshot.

view.snapshot(true)

Parâmetros:

  • valor (verdadeiro, falso) (padrão para: nil) —

    O valor do snapshot.

Desde:

  • 2.0.0

[Ver fonte]

580
581
582
 
# File 'lib/mongo/collection/view/readable.rb', linha 580

def snapshot(valor = nada)
  configure(:snapshot, valor)
end

#sort(spec = nil) ➤ Hash, Visualizar

Os pares de chave e direção pelos quais o conjunto de resultados será classificado.

Exemplos:

Definir os critérios de classificação

view.sort(name: -1)

Parâmetros:

  • especificações (Hash) (padrão para: nil) —

    Os atributos e direções para classificar por.

Retorna:

  • (Hash, Visualizar) —

    A configuração de classificação ou um novo View.

Desde:

  • 2.0.0

[Ver fonte]

595
596
597
 
# File 'lib/mongo/collection/view/readable.rb', linha 595

def sort(especificações = nada)
  configure(:sort, especificações)
end

#timeout_ms(timeout_ms = nil) ⇒ Integer, View

O tempo limite por operação em milissegundos. Deve ser um número inteiro positivo.

Parâmetros:

  • timeout_ms (Inteiro) (padrão para: nil) —

    Valor de tempo limite.

Retorna:

  • (Inteiro, Visualizar) —

    O valor de timeout_ms ou um novo View.

Desde:

  • 2.0.0

[Ver fonte]

669
670
671
 
# File 'lib/mongo/collection/view/readable.rb', linha 669

def timeout_ms(timeout_ms = nada)
  configure(:timeout_ms, timeout_ms)
end