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



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

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



77
78
79
 
# File 'lib/mongo/collection/view/readable.rb', linha 77

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



89
90
91
 
# File 'lib/mongo/collection/view/readable.rb', linha 89

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



101
102
103
 
# File 'lib/mongo/collection/view/readable.rb', linha 101

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



118
119
120
 
# File 'lib/mongo/collection/view/readable.rb', linha 118

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



136
137
138
 
# File 'lib/mongo/collection/view/readable.rb', linha 136

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
* $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



172
173
174
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
213
 
# File 'lib/mongo/collection/view/readable.rb', linha 172

def contar(opciona = {})
  opciona = @opções.mesclar(opciona) a menos que mongo.quebrado_view_options
  cmd = { contar: 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)
    )
    operação = (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]
    )
    tracer.rastreamento_operação(operação, Contexto) fazer
      read_with_retry(session, seletor, Contexto) fazer |Servidor|
        operação.executar, executar(
          Servidor,
          contexto: Contexto
        )
      end.n.to_i
    end
  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.

  • 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. 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.

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



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

def count_documents(opciona = {})
  opciona = @opções.mesclar(opciona) a menos que mongo.quebrado_view_options
  gasoduto = [ {    
         
         
               

          
    

     
     

  
' $match ': filtro } ] pipeline < < { ' $skip ': opts [:skip ] } se optar [:skip ] pipeline < < { ' $limit ': optou por [:limit ] } se opções [:limit ] pipeline << { ' $group ': { _id: 1, n: { ' $sum ': 1opts = opts. slice (:hint,:max_time_ms,:read,:collation,:session,:comment,:timeout_ms ) opts [:collation ] ||= agrupamento first = aggregate ( pipeline, opts ). first return0a menos que first first [ ' 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



665
666
667
 
# File 'lib/mongo/collection/view/readable.rb', linha 665

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.

Aumenta:

  • (ArgumentError)

Desde:

  • 2.0.0



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
383
384
385
386
 
# File 'lib/mongo/collection/view/readable.rb', linha 344

def distinto(field_name, opciona = {})
  aumentar ArgumentError, 'O nome do campo para operação distinta não deve ser nulo' se field_name.nada?

  opciona = @opções.mesclar(opciona) a menos que mongo.quebrado_view_options
  cmd = { distinto: collection.name,
          chave: 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)
    )
    operação = (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
    )
    tracer.rastreamento_operação(operação, Contexto) fazer
      read_with_retry(session, seletor, Contexto) fazer |Servidor|
        operação.executar, executar(
          Servidor,
          contexto: Contexto
        )
      end.primeiro['valores']
    end
  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



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
324
 
# File 'lib/mongo/collection/view/readable.rb', linha 278

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)
    )
    cmd = { contar: collection.name }
    cmd[:maxTimeMS] = opciona[:max_time_ms] se opciona[:max_time_ms]
    cmd[:readConcern] = Opções::Mapeador.transform_values_to_strings(read_concern) se read_concern
    operação = (operação)::Contar.Novo(
      seletor: cmd,
      db_name: database.name,
      ler: read_pref,
      sessão: session,
      comment: opciona[:comentário]
    )
    tracer.rastreamento_operação(operação, Contexto, op_name: 'estimatedDocumentCount') fazer
      read_with_retry(session, seletor, Contexto) fazer |Servidor|
        Resultado = operação.executar, executar(Servidor, contexto: Contexto)
        Resultado.n.to_i
      end
    salvar Erro::Falha de operação::família => e
      aumentar a menos que e.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
    end
  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



398
399
400
 
# File 'lib/mongo/collection/view/readable.rb', linha 398

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



412
413
414
 
# File 'lib/mongo/collection/view/readable.rb', linha 412

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



428
429
430
 
# File 'lib/mongo/collection/view/readable.rb', linha 428

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



637
638
639
 
# File 'lib/mongo/collection/view/readable.rb', linha 637

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



445
446
447
 
# File 'lib/mongo/collection/view/readable.rb', linha 445

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



651
652
653
 
# File 'lib/mongo/collection/view/readable.rb', linha 651

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



459
460
461
 
# File 'lib/mongo/collection/view/readable.rb', linha 459

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



473
474
475
 
# File 'lib/mongo/collection/view/readable.rb', linha 473

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



618
619
620
621
622
623
624
 
# File 'lib/mongo/collection/view/readable.rb', linha 618

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



486
487
488
 
# File 'lib/mongo/collection/view/readable.rb', linha 486

def no_cursor_timeout
  configure(:no_cursor_timeout, true)
end

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

Desde:

  • 2.0.0



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
749
750
 
# File 'lib/mongo/collection/view/readable.rb', linha 707

def parallel_scan(cursor_count, opções = {})
  session = se opções[:session]
              # A sessão seria substituída pela de +options+ mais tarde.
              Cliente.get_session(@opções)
            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,
      # 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



504
505
506
507
 
# File 'lib/mongo/collection/view/readable.rb', linha 504

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



520
521
522
523
524
 
# File 'lib/mongo/collection/view/readable.rb', linha 520

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



679
680
681
682
683
684
685
 
# File 'lib/mongo/collection/view/readable.rb', linha 679

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



688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
 
# File 'lib/mongo/collection/view/readable.rb', linha 688

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



536
537
538
 
# File 'lib/mongo/collection/view/readable.rb', linha 536

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



551
552
553
 
# File 'lib/mongo/collection/view/readable.rb', linha 551

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



567
568
569
 
# File 'lib/mongo/collection/view/readable.rb', linha 567

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



585
586
587
 
# File 'lib/mongo/collection/view/readable.rb', linha 585

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



600
601
602
 
# File 'lib/mongo/collection/view/readable.rb', linha 600

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



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

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