Classificação: Mongo::Banco de dados

Herda:
Objeto
  • Objeto
mostrar tudo
Estendido por:
Encaminhável
Inclui:
Repetitivo
Definido em:
lib/mongo/database.rb,
lib/mongo/database/view.rb,
lib/mongo/database/cursor_command_view.rb

Visão geral

Representa um banco de dados de dados no servidor db e as operações que podem ser executadas nele nesse nível.

Desde:

  • 2.0.0

Definido sob namespace

Classes: CursorCommandView, View

Colapsode resumo constante

ADMIN =

O nome do banco de dados admin .

Desde:

  • 2.0.0

'admin'
COMMAND =

A "coleção" contra a qual os comandos do banco de dados operam.

Desde:

  • 2.0.0

'$cmd'
DEFAULT_OPTIONS =

As opções de banco de dados de dados padrão.

Desde:

  • 2.0.0

Opções::Editado.Novo(database: ADMIN).congelar
NOME =
Obsoleto.

Constante do campo de nome do banco de dados.

Desde:

  • 2.1.0

'name'
BANCO DE DADOS =

Bancos de dados constantes.

Desde:

  • 2.1.0

'databases'
namespaces =

O nome da collection que contém todos os nomes de collections.

Desde:

  • 2.0.0

'system.namespaces'

Recolhimento do Resumo do atributo de instância

Recolhimento do Resumo do método de instância

Métodos incluídos no Retryable

#read_worker, #select_server, #with_overload_retry, #write_worker

Detalhes do construtor

#inicializar(cliente, nome, opções = {}) ➤ Banco de Dados

Instancie um novo objeto de banco de dados de dados .

Exemplos:

Instancie o banco de dados de dados .

Mongo::Database.new(client, :test)

Parâmetros:

  • Cliente (Mongo::Client) —

    O cliente do driver.

  • name (string, símbolo) —

    O nome do banco de dados.

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

    As opções.

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

  • :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 do cliente.

Aumenta:

  • (Mongo::Database::InvalidName) —

    Se o nome for nulo.

Desde:

  • 2.0.0



479
480
481
482
483
484
485
486
487
488
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 479

def inicializar(Cliente, name, opções = {})
  aumentar Erro::InvalidDatabaseName.Novo a menos que name
  se Lint.habilitado? && !(name.is_a?(String) || name.is_a?(Símbolo))
    aumentar "O nome do banco de dados deve ser uma string ou um símbolo: #{name}"
  end

  @cliente = Cliente
  @name = name.to_s.congelar
  @opções = opções.congelar
end

Detalhes do atributo da instância

#cliente ➤ Cliente (somente leitura)

Retorna cliente O cliente do banco de dados de dados.

Retorna:

  • (Cliente) —

    cliente O cliente do banco de dados.

Desde:

  • 2.0.0



61
62
63
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 61

def Cliente
  @cliente
end

#name ➤ string (somente leitura)

Retorna name O nome do banco de banco de dados.

Retorna:

  • (string) —

    name O nome do banco de banco de dados.

Desde:

  • 2.0.0



64
65
66
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 64

def name
  @name
end

#opções ➤ Hash (somente leitura)

Retorna as opções As opções.

Retorna:

  • (Hash) —

    opções As opções.

Desde:

  • 2.0.0



67
68
69
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 67

def opções
  @opções
end

Detalhes do método de instância

#==(outro) ➤ true, false

Verifique a igualdade do objeto de banco de dados de dados em relação a outro. Simplesmente verificará se os nomes são os mesmos.

Exemplos:

Verifique a igualdade do banco de dados de dados.

database == other

Parâmetros:

  • Outro (Objeto) —

    O objeto em relação ao qual verificar.

Retorna:

  • (verdadeiro, falso) —

    Se os objetos forem iguais.

Desde:

  • 2.0.0



94
95
96
97
98
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 94

def ==(Outro)
  Método false a menos que Outro.is_a?(Database)

  name == Outro.name
end

#[](collection_name, options = {}) ➤ Mongo::Collection Também conhecido como: collection

Obtenha uma coleção neste banco de dados de dados pelo nome fornecido.

Exemplos:

Obtenha uma coleção.

database[:users]

Parâmetros:

  • collection_name (string, símbolo) —

    O nome da collection.

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

    As opções da collection.

Retorna:

Desde:

  • 2.0.0



111
112
113
114
115
116
117
118
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 111

def [](collection_name, opções = {})
  se opções[:server_api]
    aumentar ArgumentError,
          'A opção :server_api não pode ser especificada para objetos de coleção. Só pode ser especificado no nível do cliente'
  end

  collection.Novo(auto, collection_name, opções)
end

#aggregation(pipeline, options = {}) ➤ Collection::View::aggregation

Execute uma agregação no banco de banco de dados.

Exemplos:

Execute uma agregação.

collection.aggregate([ { "$listLocalSessions" => {} } ])

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.

  • :max_time_ms (Inteiro) —

    O tempo máximo para permitir a execução da consulta, em milissegundos. Esta opção está obsoleta, use :timeout_ms em vez disso.

  • :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 do banco de dados ou do cliente.

  • :hint (string) —

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

  • :session (Sessão) —

    A sessão a ser usada.

Retorna:

Desde:

  • 2.10.0



568
569
570
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 568

def Agregação(gasoduto, opções = {})
  Vista.Novo(auto, opções).Agregação(gasoduto, opções)
end

#cluster ⇒ Mongo::Server

Retorna Obter o servidor primário do cluster.

Retorna:

Desde:

  • 2.0.0



80
81
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 80

def_delegators :cluster,
:next_primary

#collection_names(opções = {}) ➤ Array<String>

Observação:

O conjunto de nomes de collection retornados depende da versão do servidor MongoDB que atende à solicitação.

Obtenha todos os nomes das coleções que não são do sistema no banco de banco de dados.

See https://mongodb.com/pt-br/docs/manual/reference/command/listCollections/
for more information and usage.

Parâmetros:

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

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

  • :filter (Hash) —

    Um filtro para as collections retornadas.

  • : authorized_collections (verdadeiro, falso) —

    Um sinalizador, quando definido como true e usado com nameOnly: true, que permite a um usuário sem o privilégio necessário executar o comando quando o controle de acesso é imposto

  • :comentário (Objeto) —

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

  • :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 do banco de dados ou do cliente.

Retorna:

  • (Array<String>) —

    Nomes das collections.

Desde:

  • 2.0.0



145
146
147
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 145

def collection_names(opções = {})
  Vista.Novo(auto, opções).collection_names(opções)
end

#collections(options = {}) ➤ Array

Observação:

O conjunto de collections retornadas depende da versão do servidor MongoDB que atende à solicitação.

Obtenha todas as collections que não são do sistema que pertencem a este banco de dados de dados.

See https://mongodb.com/pt-br/docs/manual/reference/command/listCollections/
for more information and usage.

Parâmetros:

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

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

  • :filter (Hash) —

    Um filtro para as collections retornadas.

  • : authorized_collections (verdadeiro, falso) —

    Um sinalizador, quando definido como true e usado com name_only: true, que permite a um usuário sem o privilégio necessário executar o comando quando o controle de acesso é imposto.

  • :comentário (Objeto) —

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

  • :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 do banco de dados ou do cliente.

Retorna:

Desde:

  • 2.0.0



206
207
208
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 206

def collections(opções = {})
  collection_names(opções).map { |name| collection(name) }
end

#command(operation, opts = {}) ➤ Mongo::Operation::Result

Executar um comando no banco de dados.

Exemplos:

Execute um comando.

database.command(:hello => 1)

Parâmetros:

  • operação (Hash) —

    O comando a ser executado.

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

    As opções de comando.

  • opções (Hash) —

    um conjunto personalizável de opções

Hash de opções (opts):

  • :read (Hash) —

    A preferência de leitura para este comando.

  • :session (Sessão) —

    A sessão a ser usada para esse comando.

  • :execution_options (Hash) —

    Opções a serem passadas para o código que executa esse comando. Esta é uma opção interna e está sujeita a alterações.

    • :deserialize_as_bson [ Boolean ] Se deve desserializar a resposta a este comando usando BSON types em vez de tipos Ruby nativos sempre que possível.

Retorna:

Desde:

  • 2.0.0



232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 232

def comando(operação, opciona = {})
  opciona = opciona.dup
  execution_opts = opciona.excluir(:execution_options) || {}

  txn_read_pref = (opciona[:session].txn_read_preference se opciona[:session] && opciona[:session].in_transaction?)
  txn_read_pref ||= opciona[:read] || ServerSelector::Primário
  Lint.validate_subscore_read_preference(txn_read_pref)
  seletor = ServerSelector.obter(txn_read_pref)

  Cliente.with_session(opciona) fazer |session|
    Contexto = (operação)::Contexto.Novo(
      cliente: Cliente,
      sessão: session,
      operation_timeouts: operation_timeouts(opciona)
    )
    op = (operação)::Comando.Novo(
      seletor: operação,
      db_name: name,
      ler: seletor,
      sessão: session
    )

    retry_enabled = Cliente.opções[:retry_reads] != false &&
                    Cliente.opções[:retry_writes] != false
    with_overload_retry(contexto: Contexto, retry_enabled: retry_enabled) fazer
      Servidor = seletor.select_server(cluster, nada, session)
      op.executar, executar(Servidor, contexto: Contexto, opções: execution_opts)
    end
  end
end

#cursor_command(comando, opções = {}) ⇒ Mongo::cursor

Execute um comando que retorna um cursor e analise a resposta como um cursor.

O comando é enviado ao servidor sem modificações; o driver NÃO DEVE inspecioná-lo ou alterá-lo. Se a resposta não contiver um campo de cursor, um erro será gerado. O comando nunca é repetido.

Observação: se um campo maxTimeMS já estiver definido no documento de comando, ele será mantido como está. A opção max_time_ms abaixo aplica-se apenas aos comandos getMore. Definir timeout_ms e max_time_ms não é compatível e tem comportamento indefinido.

Exemplos:

Execute um comando de retorno do cursor.

database.cursor_command(checkMetadataConsistency: 1)

Parâmetros:

  • comando (Hash) —

    O comando a ser executado.

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

    As opções de comando.

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

  • :read (Hash) —

    A preferência de leitura para este comando, usada para seleção de servidor e reutilizada para getMores subsequentes.

  • :session (Sessão) —

    A sessão a ser usada. Se nenhum for fornecido, uma sessão implícita será criada e reutilizada durante a vida útil do cursor.

  • :timeout_ms (Inteiro) —

    O tempo limite da operação em milissegundos.

  • :batch_size (Inteiro) —

    O batchSize a ser enviado em comandos getMore.

  • :max_time_ms (Inteiro) —

    O maxTimeMS para enviar em mais comandos.

  • :comentário (Objeto) —

    Um comentário para anexar aos comandos getMore.

  • :cursor_type (Símbolo) —

    O tipo de cursor, :tailable ou :tailable_await. Deve corresponder aos sinalizadores definidos no documento de comando.

  • :timeout_mode (Símbolo) —

    :cursor_lifetime ou :iteration.

Retorna:

Aumenta:

Desde:

  • 2.0.0



301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
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
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 301

def cursor_command(comando, opções = {})
  opções = opções.dup
  execution_opts = opções.excluir(:execution_options) || {}
  view_options = extract_cursor_command_view_options(opções)

  txn_read_pref = (opções[:session].txn_read_preference se opções[:session] && opções[:session].in_transaction?)
  txn_read_pref ||= opções[:read] || ServerSelector::Primário
  Lint.validate_subscore_read_preference(txn_read_pref)
  seletor = ServerSelector.obter(txn_read_pref)

  # A sessão não é intencionalmente encapsulada em #with_session: um implícito
  # a sessão deve sobreviver a este método e é encerrada pelo cursor quando é
  # esgotado ou fechado. Até que o cursor assuma a propriedade, a sessão e
  # qualquer conexão com balanceamento de carga é limpa aqui em cada caminho de saída.
  session = Cliente.get_session(opções)
  Contexto = (operação)::Contexto.Novo(
    cliente: Cliente,
    sessão: session,
    operation_timeouts: operation_timeouts(opções)
  )
  op = (operação)::CursorCommand.Novo(
    seletor: comando,
    db_name: name,
    ler: seletor,
    sessão: session
  )

  # De acordo com a especificação de contrapressão do cliente, repetir um comando genérico em
  # sobrecarregar erros requer leituras e gravações repetíveis para ser
  # ativado, o mesmo que Database#command.
  retry_enabled = Cliente.opções[:retry_reads] != false &&
                  Cliente.opções[:retry_writes] != false

  Servidor = nada
  Conexão = nada
  cursor = nada
  começar
    Resultado = with_overload_retry(contexto: Contexto, retry_enabled: retry_enabled) fazer
      Servidor = seletor.select_server(cluster, nada, session)
      se Servidor.load_balancer?
        # A conexão é verificada pelo cursor quando ele é drenado.
        Conexão = check_out_cursor_command_connection(Servidor, Contexto)
        começar
          op.execute_with_connection(Conexão, contexto: Contexto, opções: execution_opts)
        salvar StandardError
          # Libere a conexão antes que o erro se propague para que
          # uma tentativa repetida verifica um novo.
          Conexão.connection_pool.check_in(Conexão) a menos que Conexão.fixado?
          Conexão = nada
          aumentar
        end
      mais
        op.executar, executar(Servidor, contexto: Contexto, opções: execution_opts)
      end
    end

    a menos que Resultado.cursor?
      aumentar Erro::InvalidCursorOperation,
            'A resposta do comando não incluiu um cursor. ' \
            'Use o comando de banco de dados para comandos que não retornam um cursor.'
    end

    view = CursorCommandView.new(self, view_options)
    cursor = Cursor.new(view, result, servidor, session: session, context: context)
  ensure
    # Se o cursor foi criado, ele é o proprietário da sessão e da conexão;
    # caso contrário (erro ou nenhum cursor na resposta), libere-os aqui.
    unless cursor
      connection.connection_pool.check_in(connection) if connection && !connection.pinned?
      session.end_session if session && session.implicit?
    end
  end
  cursor
end

#descartar(opções = {}) ➤ Resultado

Solte o banco de dados de dados e todas as suas informações associadas.

Exemplos:

Solte o banco de dados.

database.drop

Parâmetros:

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

    As opções para a operação.

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

  • :session (Sessão) —

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

  • :write_concern (Hash) —

    As opções de preocupação de gravação .

  • :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 do banco de dados ou do cliente.

Retorna:

  • (Resultado) —

    O resultado do comando.

Desde:

  • 2.0.0



439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 439

def derrubar(opções = {})
  operação = { dropDatabase: 1 }
  Cliente.with_session(opções) fazer |session|
    write_concern = se opções[:write_concern]
                      Escreva preocupação.obter(opções[:write_concern])
                    mais
                      auto.write_concern
                    end
    (operação)::Descartar banco de dados.Novo({
                                  seletor: operação,
                                  db_name: name,
                                  write_concern: write_concern,
                                  sessão: session
                                }).executar, executar(
                                  próximo_primary(nada, session),
                                  contexto: (operação)::Contexto.Novo(
                                    cliente: Cliente,
                                    sessão: session,
                                    operation_timeouts: operation_timeouts(opções)
                                  )
                                )
  end
end

#fs(options = {}) ⇒ Grid::FSBucket

Obtenha o "sistema de arquivos" do Grid para este banco de dados.

Parâmetros:

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

    As opções do GridFS .

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

  • :bucket_name (string) —

    O prefixo para os arquivos e coleções de blocos.

  • :chunk_size (Inteiro) —

    Substitua o tamanho padrão do chunk.

  • :fs_name (string) —

    O prefixo para os arquivos e coleções de blocos.

  • :read (string) —

    A preferência de leitura.

  • :session (Sessão) —

    A sessão a ser usada.

  • :write (Hash) —

    Obsoleto. Equivalente à opção :write_concern.

  • :write_concern (Hash) —

    As opções de preocupação de gravação . Pode ser :w => Inteiro|String, : fsync => Booleano, :j => Booleano.

Retorna:

Desde:

  • 2.0.0



522
523
524
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 522

def fs(opções = {})
  Grade::FSBucket.Novo(auto, opções)
end

#inspecionar ➤ string

Obtenha uma inspeção de string bem impressa para o banco de dados.

Exemplos:

Inspecione o banco de dados de dados .

database.inspect

Retorna:

  • (string) —

    A inspeção do banco de dados de dados.

Desde:

  • 2.0.0



498
499
500
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 498

def inspecionar
  "#<Mongo::Database:0x#{object_id} name=#{name}>"
end

#list_collections(options = {}) ➤ Array<Hash>

Observação:

O conjunto de coleções retornadas e o esquema do hash de informações por coleção depende da versão do servidor MongoDB que atende à solicitação.

Obtenha informações sobre todas as collections que não são do sistema no banco de dados.

See https://mongodb.com/pt-br/docs/manual/reference/command/listCollections/
for more information and usage.

Parâmetros:

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

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

  • :filter (Hash) —

    Um filtro para as collections retornadas.

  • :name_only (verdadeiro, falso) —

    Indica se o comando deve retornar apenas os nomes e o tipo da collection/visualização ou se deve retornar o nome e outras informações

  • : authorized_collections (verdadeiro, falso) —

    Um sinalizador, quando definido como true e usado com nameOnly: true, que permite a um usuário sem o privilégio necessário executar o comando quando o controle de acesso é imposto.

  • :comentário (Objeto) —

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

  • :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 do banco de dados ou do cliente.

Retorna:

  • (Array<Hash>) —

    Array de hashes de informações, um para cada collection no banco de banco de dados.

Desde:

  • 2.0.5



178
179
180
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 178

def list_collections(opções = {})
  Vista.Novo(auto, opções).list_collections(opções)
end

#operation_timeouts(opts) ➤ Hash

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.

Retorna o valor de timeout_ms definido no nível de operação (se houver) e/ou timeout_ms definido no nível de coleção/ banco de dados/ cliente (se houver).

Retorna:

  • (Hash) —

    valor de timeout_ms definido no nível de operação (se houver) e/ou timeout_ms definido no nível de coleção/ banco de dados/ cliente (se houver).

Desde:

  • 2.0.0



659
660
661
662
663
664
665
666
667
668
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 659

def operation_timeouts(opciona)
  # TODO: Devemos reavaliar se precisamos de dois tempos limite separadamente.
  {}.toque fazer |Resultado|
    se opciona[:timeout_ms].nada?
      Resultado[:inherited_timeout_ms] = timeout_ms
    mais
      Resultado[:operation_timeout_ms] = opciona.excluir(:timeout_ms)
    end
  end
end

#read_command(operation, opts = {}) ➤ Hash

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.

Execute um comando de leitura no banco de banco de dados, tentando novamente a leitura, se necessário.

Parâmetros:

  • operação (Hash) —

    O comando a ser executado.

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

    As opções de comando.

Hash de opções (opts):

  • :read (Hash) —

    A preferência de leitura para este comando.

  • :session (Sessão) —

    A sessão a ser usada para esse comando.

  • :comentário (Objeto) —

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

  • :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 do banco de dados ou do cliente.

  • :op_name (string | nil) —

    O nome da operação para fins de rastreamento.

Retorna:

  • (Hash) —

    O resultado da execução do comando.

Desde:

  • 2.0.0



394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 394

def read_command(operação, opciona = {})
  txn_read_pref = (opciona[:session].txn_read_preference se opciona[:session] && opciona[:session].in_transaction?)
  txn_read_pref ||= opciona[:read] || ServerSelector::Primário
  Lint.validate_subscore_read_preference(txn_read_pref)
  preferência = ServerSelector.obter(txn_read_pref)

  Cliente.with_session(opciona) fazer |session|
    Contexto = (operação)::Contexto.Novo(
      cliente: Cliente,
      sessão: session,
      operation_timeouts: operation_timeouts(opciona)
    )
    operação = (operação)::Comando.Novo(
      seletor: operação.dup,
      db_name: name,
      ler: preferência,
      sessão: session,
      comment: opciona[:comentário]
    )
    op_name = opciona[:op_name] || 'Comando'
    rastreador.rastreamento_operação(operação, Contexto, op_name: op_name) fazer
      read_with_retry(session, preferência, Contexto) fazer |Servidor|
        operação.executar, executar(Servidor, contexto: Contexto)
      end
    end
  end
end

#timeout_ms ⇒ Integer | nil

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.

Retorna o tempo limite da operação que é para esse banco de dados ou para o cliente correspondente.

Retorna:

  • (Inteiro | nil) —

    Tempo limite de operação para esse banco de dados ou para o cliente correspondente .

Desde:

  • 2.0.0



651
652
653
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 651

def timeout_ms
  opções[:timeout_ms] || Cliente.timeout_ms
end

#usuários ➤ Visualizar::Usuário

Obtenha a visualização do usuário para este banco de dados de dados .

Exemplos:

Obtenha a visualização do usuário.

database.users

Retorna:

  • (Visualizar::Usuário) —

    A visão do usuário.

Desde:

  • 2.0.0



534
535
536
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 534

def Usuários
  auth::Usuário::Vista.Novo(auto)
end

#watch(pipeline = [], options = {}) ➤ ChangeStream

Observação:

Um fluxo de alterações permite apenas a read concern de "maioria".

Observação:

Este método auxiliar é preferível a executar uma agregação bruta com um estágio $changeStream, com a finalidade de apoiar a capacidade de retomada.

Permite que os usuários solicitem o envio de notificações para todas as alterações que ocorram no banco de dados do cliente.

Exemplos:

Obtenha notificações de alteração para um determinado banco de dados de dados.

database.watch([{ '$match' => { operationType: { '$in' => ['insert', 'replace'] } } }])

Parâmetros:

  • gasoduto (Array<Hash>) (padrão para: []) —

    Operadores de filtro adicionais opcionais.

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

    As opções de change stream.

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

  • :full_document (string) —

    Valores permitidos: nil, 'padrão', 'updateLookup', 'whenAvailable', 'required'.

    O padrão é não enviar um valor (ou seja, nil), que é equivalente a "padrão". Por padrão, a notificação de alteração para atualizações parciais incluirá um delta descrevendo as alterações no documento.

    Quando definido como 'updateLookup', a notificação de alteração para atualizações parciais incluirá um delta descrevendo as alterações no documento , bem como uma cópia de todo o documento que foi alterado algum tempo após a ocorrência da alteração.

    Quando definido como 'whenAvailable', configura o fluxo de alterações para retornar a pós-imagem do documento modificado para eventos de alteração de substituição e atualização se a pós-imagem desse evento estiver disponível.

    Quando definido como "obrigatório", tem o mesmo comportamento de "whenAvailable", exceto pelo fato de que um erro é gerado se a imagem de publicação não estiver disponível.

  • :full_document_before_change (string) —

    Valores permitidos: nil, 'whenAvailable', 'required', 'off'.

    O padrão é não enviar um valor (ou seja, nil), que é equivalente a "off".

    Quando definido como "whenAvailable", configura o fluxo de alterações para retornar a pré-imagem do documento modificado para substituir, atualizar e excluir eventos de alteração, se estiver disponível.

    Quando definido como "obrigatório", tem o mesmo comportamento de "whenAvailable", exceto pelo fato de que um erro é gerado se a pré-imagem não estiver disponível.

  • :resume_after (BSON::Document, Hash) —

    Especifica o ponto de partida lógico para o novo fluxo de alteração.

  • :max_await_time_ms (Inteiro) —

    O tempo máximo para o servidor aguardar novos documentos para atender a uma query de fluxo de alterações.

  • :batch_size (Inteiro) —

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

  • :collation (BSON::Document, Hash) —

    O agrupamento a ser usado.

  • :session (Sessão) —

    A sessão a ser usada.

  • :start_at_operation_time (BSON::Timestamp) —

    Retornar apenas as alterações que ocorreram após o registro de data/hora especificado. Qualquer comando executado no servidor retornará um tempo de cluster que pode ser usado aqui.

  • :comentário (Objeto) —

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

  • :show_expanded_events (Booleano) —

    Permite que o servidor envie a lista "expandida" de eventos de fluxo de alterações. A lista de eventos adicionais incluídos com este conjunto de sinalizadores é: createIndexes, dropIndexes, modify, create, shardCollection, reshardCollection, refineCollectionShardKey.

Retorna:

  • (ChangeStream) —

    O objeto de fluxo de alterações.

Desde:

  • 2.6.0



635
636
637
638
639
640
641
642
643
644
645
 
# Arquivo 'lib/mongo/ banco de dados.rb', linha 635

def assistir(gasoduto = [], opções = {})
  view_options = opções.dup
  view_options[:cursor_type] = :tailable_await se opções[:max_await_time_ms]

  mongo::collection::Vista::Change stream.Novo(
    mongo::collection::Vista.Novo(collection("#{COMMAND}.aggregate"), {}, view_options),
    gasoduto,
    mongo::collection::Vista::Change stream::Banco de dados,
    opções
  )
end