Classificação: Mongo::Client

Herda:
Objeto
  • Objeto
mostrar tudo
Estendido por:
Encaminhável
Inclui:
Logável
Definido em:
lib/mongo/ cliente.rb

Visão geral

O cliente é o ponto de entrada do driver e é o principal objeto com o qual haverá interação.

Desde:

  • 2.0.0

Colapsode resumo constante

CRUD_OPTIONS =

As opções que não afetam o comportamento de um cluster e seus subcomponentes.

Desde:

  • 2.1.0

[
  :auto_encryption_options,
  :database,
  :read, :read_concern,
  :write, :write_concern,
  :retry_reads, :max_read_retry, :read_retry_interval,
  :retry_writes, :max_write_retry,

  # Opções que não podem estar aqui atualmente:
  #
  # :server_selection_timeout
  # O tempo limite de seleção do servidor MongoDB é usado pelo construtor do cluster para descobrir
  # quanto tempo esperar pela verificação inicial no modo de compatibilidade, mas uma vez
  # o cluster é inicializado e não usa mais esse tempo limite.
  # Infelizmente, o seletor de servidor lê o tempo limite de seleção do servidor de
  # o cluster, e esse comportamento é exigido pelo Cluster#next_primary
  # que não aceita argumentos. Quando próximo_primary for removido, podemos rever
  # usando o mesmo objeto de cluster com diferentes tempos limite de seleção de servidor.
].congelar
VALID_OPTIONS =

Opções válidas do cliente.

Desde:

  • 2.1.2

[
  :app_name,
  :auth_mech,
  :auth_mech_properties,
  :auth_source,
  :auto_encryption_options,
  :bg_error_backtrace,
  :cleanup,
  :compressors,
  :direct_connection,
  :connect,
  :connect_timeout,
  :database,
  : heartbeat_frequency,
  :id_generator,
  :load_balanced,
  :local_threshold,
  :logger,
  :log_prefix,
  :max_connecting,
  :max_idle_time,
  :max_pool_size,
  :max_read_retry,
  :max_write_retry,
  :min_pool_size,
  :monitoring,
  :monitoring_io,
  :password,
  :platform,
  :populator_io,
  :read,
  :read_concern,
  :read_retry_interval,
  :replica_set,
  :resolv_options,
  :retry_reads,
  :retry_writes,
  :scan,
  :sdam_proc,
  :server_api,
  :server_selection_timeout,
  :socket_timeout,
  :srv_max_hosts,
  :srv_service_name,
  :ssl,
  :ssl_ca_cert,
  :ssl_ca_cert_object,
  :ssl_ca_cert_string,
  :ssl_cert,
  :ssl_cert_object,
  :ssl_cert_string,
  :ssl_key,
  :ssl_key_object,
  :ssl_key_pass_ phrase,
  :ssl_key_string,
  :ssl_verify,
  :ssl_verify_certificate,
  :ssl_verify_hostname,
  :ssl_verify_ocsp_endpoint,
  :timeout_ms,
  :truncate_logs,
  : user,
  :wait_queue_timeout,
  :wrapping_libraries,
  :write,
  :write_concern,
  :zlib_compression_level,
].congelar
VALID_COMPRESSORS =

Os algoritmos de compressão suportados pelo driver.

Desde:

  • 2.5.0

[
  mongo::protocolo::Compactado::zstd,
  mongo::protocolo::Compactado::Snappy,
  mongo::protocolo::Compactado::zlib
].congelar
VALID_SERVER_API_VERSIONS =

As versões conhecidas da API do servidor.

Desde:

  • 2.0.0

%w(
  1
).congelar

Constantes incluídas do Loggable

Loggable::Prefix

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 no Loggable

#log_debug, #log_error, #log_fatal, #log_info, #log_WARN, #logger

Detalhes do construtor

#initialize(addresses_or_uri, options = nil) ⇒ Cliente

Instancie um novo cliente de driver.

Exemplos:

Instancie um único servidor ou cliente mongos.

Mongo::Client.new(['127.0.0.1:27017'])

Instancie um cliente para um conjunto de réplicas.

Mongo::Client.new(['127.0.0.1:27017', '127.0.0.1:27021'])

Conecte-se diretamente a um mongod em um conjunto de réplicas

Mongo::Client.new(['127.0.0.1:27017'], :connect => :direct)
# without `:connect => :direct`, Mongo::Client will discover and
# connect to the replica set if given the address of a server in
# a replica set

Parâmetros:

  • endereços_or_uri (Array <string> | string) —

    A array de endereços de servidor na forma de host:port ou uma connection string de URI MongoDB.

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

    As opções a serem usadas pelo cliente. Se uma string de conexão de URI MongoDB também for fornecida, essas opções terão precedência sobre quaisquer opções análogas presentes na string de URI.

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

  • :app_name (string, símbolo) —

    Nome do aplicativo que é impresso nos registros do mongod ao estabelecer uma conexão nas versões do servidor >= 3.4.

  • :auth_mech (Símbolo) —

    O mecanismo de autenticação a ser usado. Um de :mongodb_cr, :mongodb_x509, :plain, :scram, :scram256

  • :auth_mech_properties (Hash)
  • :auth_source (string) —

    A fonte da qual autenticar.

  • :bg_error_backtrace (verdadeiro | falso | nulo | inteiro) —

    Experimental. Defina como true para registrar backtrace completos para erros em threads em background. Defina como falso ou nulo para não registrar backtrace. Forneça um número inteiro positivo para registrar até esse número de linhas de backtrace.

  • :compressors (Array<String>) —

    Uma lista de possíveis compressores a serem usados, em ordem de preferência. O driver escolhe o primeiro compressor que também é suportado pelo servidor. Atualmente, o driver suporta apenas 'zstd, 'snappy' e 'zlib'.

  • :direct_connection (verdadeiro | falso) —

    Se deve se conectar diretamente à semente especificada, ignorando a descoberta da topologia. Exatamente uma semente deve ser fornecida.

  • :connect (Símbolo) —

    Obsoleto - use a opção :direct_connection em vez desta opção. O método de conexão a ser usado. Isso força o cluster a se comportar da maneira especificada em vez de fazer a descoberta automaticamente. Um dos :direct, :replica_set, :sharded, :load_balanced. Se :connect estiver definido como :load_balanced, o driver se comportará como se o servidor fosse um balancer de carga, mesmo que não esteja conectado a um balancer de carga.

  • :connect_timeout (Flutuante) —

    O tempo limite, em segundos, para tentar uma conexão.

  • :database (string) —

    O banco de dados ao qual se conectar.

  • : heartbeat_frequency (Flutuante) —

    O intervalo, em segundos, para o monitor do servidor atualizar sua descrição por meio de hello.

  • :id_generator (Objeto) —

    Um objeto personalizado para gerar ID para documento. Deve responder a #generate.

  • :load_balanced (verdadeiro | falso) —

    Se deve esperar para se conectar a um balancer de carga.

  • :local_threshold (Inteiro) —

    O limite local em segundos para selecionar um servidor próximo para uma operação.

  • :logger (Registrador) —

    Um registrador personalizado para usar.

  • :log_prefix (string) —

    Um prefixo de registro personalizado para usar ao fazer registro. Esta opção é experimental e sujeita a alterações em uma versão futura do driver.

  • :max_connecting (Inteiro) —

    O número máximo de conexões que podem se conectar simultaneamente. O padrão é 2. Essa opção deve ser aumentada se houver muitos threads que compartilham o mesmo cliente e o aplicação estiver enfrentando tempos limite enquanto aguarda o estabelecimento das conexões. selecionar um servidor para uma operação. O padrão é 2.

  • :max_idle_time (Inteiro) —

    O máximo de segundos que um soquete pode permanecer inativo desde que fez check-in no pool.

  • :max_pool_size (Inteiro) —

    O tamanho máximo do pool de conexões. Definir esta opção para zero cria um pool de conexões ilimitado.

  • :max_read_retry (Inteiro) —

    O número máximo de tentativas de leitura quando as tentativas de leitura legado estão em uso.

  • :max_write_retry (Inteiro) —

    O número máximo de tentativas de gravação quando as tentativas de gravação legado estão em uso.

  • :min_pool_size (Inteiro) —

    O tamanho mínimo do pool de conexões.

  • :monitoring (verdadeiro, falso) —

    Se falso for fornecido, o cliente será inicializado sem assinantes globais de eventos SDAM e não publicará eventos SDAM. O monitoramento de comandos e os eventos legados ainda serão publicados, e o driver ainda executará o SDAM e monitorará seu cluster para realizar a seleção do servidor. O registro de driver integrado de eventos SDAM será desabilitado porque é implementado por meio da assinatura de eventos SDAM. Client#subscribe terá sucesso para todos os tipos de eventos, mas assinantes para eventos SDAM não serão invocados. Valores diferentes de falso resultam no comportamento padrão que é executar a publicação normal de eventos SDAM.

  • :monitoring_io (verdadeiro, falso) —

    Somente para uso interno do driver. Defina como falso para evitar que a E/S relacionada ao SDAM seja feita por esse cliente ou servidores abaixo dele. Observação: definir essa opção como falso tornará o cliente não funcional. Destina-se ao uso em testes que invocam manualmente transições de estado SDAM.

  • :cleanup (verdadeiro | falso) —

    Somente para uso interno do driver. Defina como false para evitar que o comando endSessions seja enviado ao servidor para limpar as sessões do servidor quando o cluster for desconectado e para não iniciar o executor periódico. Se :monitoring_io for falso, :cleanup automaticamente padronizará para falso também.

  • :password (string) —

    A senha do usuário.

  • :platform (string) —

    Informações da plataforma que devem ser incluídas nos metadados impressos nos registros do mongod ao estabelecer uma conexão nas versões do servidor >= 3.4.

  • :read (Hash) —

    As opções de read preference. O hash pode ter os seguintes itens:

    • : modo – preferência de leitura especificada como um símbolo; Os valores válidos são :primary, :primary_preferred, :secondary, :secondary_preferred e :nearest.

    • :tag_sets – uma array de hashes.

    • :local_threshold.

  • :read_concern (Hash) —

    A opção read concern.

  • :read_retry_interval (Flutuante) —

    O intervalo, em segundos, no qual as leituras em um mongos são repetidas.

  • :replica_set (Símbolo) —

    O nome do conjunto de réplicas ao qual se conectar. Os servidores que não estejam neste conjunto de réplicas serão ignorados.

  • :retry_reads (verdadeiro | falso) —

    Se verdadeiro, as leituras repetíveis modernas estarão habilitadas (que é o padrão). Se falso, as leituras repetíveis modernos serão desativadas e as leituras repetíveis herdadas serão habilitadas.

  • :retry_writes (verdadeiro | falso) —

    Tente gravar novamente uma vez quando estiver conectado a um conjunto de réplicas ou a versões de cluster fragmentado 3.6 e superiores. (O padrão é verdadeiro.)

  • :scan (verdadeiro | falso) —

    Se todas as sementes devem ser verificadas no construtor. O padrão na versão do driver 2.x é fazer isso; versão do driver 3.x não verificará sementes no construtor. Opte pelo novo comportamento definindo esta opção como false. Observação: definir essa opção como nulo habilita a digitalização de sementes no construtor na versão do driver 2.x. Versão do driver 3.x reconhecerá esta opção, mas a ignorará e nunca verificará sementes no construtor.

  • :sdam_proc (Proc) —

    Um Proc para invocar com o cliente como argumento antes de executar a descoberta e o monitoramento do servidor. Use isto para configurar os ouvintes de eventos SDAM para receber eventos publicados durante a construção do cliente.

    Observação: o cliente não está totalmente construído quando sdam_proc é invocado, em particular o cluster é nulo neste momento. sdam_proc deve limitar-se a chamar os métodos #subscribe e #unsubscribe apenas no cliente.

  • :server_api (Hash) —

    A versão da API do servidor solicitado. Esse hash pode ter os seguintes itens:

    • :version – string

    • :strict – boolean

    • :deprecation_errors – boolean

  • :server_selection_timeout (Inteiro) —

    O tempo limite em segundos para selecionar um servidor para uma operação.

  • :socket_timeout (Flutuante) —

    O timeout, em segundos, para executar operações em um soquete. Esta opção está obsoleta, use :timeout_ms em vez disso.

  • :srv_max_hosts (Inteiro) —

    O número máximo de mongos com os quais o driver se comunicará para topologias fragmentadas. Se esta opção for 0, não haverá número máximo de mongos. Se o URI fornecido for resolvido para mais hosts do que “:srv_max_hosts”, o cliente escolherá aleatoriamente um subconjunto de hosts do tamanho de “:srv_max_hosts”.

  • :srv_service_name (string) —

    O nome do serviço a ser usado na query DNS do SRV.

  • :ssl (verdadeiro, falso) —

    Se deve usar o TLS.

  • :ssl_ca_cert (string) —

    O arquivo contendo certificados de autoridade de certificação concatenados usados para validar certificados passados da outra extremidade da conexão. Certificados intermediários NÃO devem ser especificados em arquivos referenciados por esta opção. Um dos seguintes :ssl_ca_cert, :ssl_ca_cert_string ou :ssl_ca_cert_object (em ordem de prioridade) é necessário ao utilizar :ssl_verify.

  • :ssl_ca_cert_object (Array <OpenSSL::X509::Certificate>) —

    Uma array de objetos OpenSSL::X509::Certificate que representam os certificados de autoridade de certificação usados para validar os certificados passados da outra extremidade da conexão. Certificados intermediários NÃO devem ser especificados em arquivos referenciados por esta opção. Um dos seguintes :ssl_ca_cert, :ssl_ca_cert_string ou :ssl_ca_cert_object (em ordem de prioridade) é necessário ao utilizar :ssl_verify.

  • :ssl_ca_cert_string (string) —

    Uma string contendo certificado de autoridade de certificação usada para validar certificados passados da outra extremidade da conexão. Esta opção permite passar apenas um certificado CA para o driver. Certificados intermediários NÃO devem ser especificados em arquivos referenciados por esta opção. Um dos seguintes :ssl_ca_cert, :ssl_ca_cert_string ou :ssl_ca_cert_object (em ordem de prioridade) é necessário ao utilizar :ssl_verify.

  • :ssl_cert (string) —

    O arquivo de certificado usado para identificar a conexão com o MongoDB. Uma cadeia de certificados pode ser passada especificando o certificado do cliente primeiro, seguido por quaisquer certificados intermediários até o certificado da CA. O arquivo também pode conter a chave privada do certificado, que será ignorada. Esta opção, se presente, tem precedência sobre os valores de :ssl_cert_string e :ssl_cert_object

  • :ssl_cert_object (OpenSSL::X509::Certificate) —

    O OpenSSL::X509::Certificate usado para identificar a conexão com o MongoDB. Somente um certificado pode ser passado por esta opção.

  • :ssl_cert_string (string) —

    Uma string contendo o certificado codificado por PEM usado para identificar a conexão com o MongoDB. Uma cadeia de certificados pode ser passada especificando o certificado do cliente primeiro, seguido por quaisquer certificados intermediários até o certificado da CA. A string também pode conter a chave privada do certificado, que será ignorada. Esta opção, se presente, tem precedência sobre o valor de :ssl_cert_object

  • :ssl_key (string) —

    O arquivo de chave privada usado para identificar a conexão com o MongoDB. Observe que, mesmo que a chave esteja armazenada no mesmo arquivo que o certificado, ambos precisam ser especificados explicitamente. Esta opção, se presente, tem precedência sobre os valores de :ssl_key_string e :ssl_key_object

  • :ssl_key_object (OpenSSL::PKey) —

    A chave privada usada para identificar a conexão com o MongoDB

  • :ssl_key_pass_ phrase (string) —

    Uma senha para a chave privada.

  • :ssl_key_string (string) —

    Uma string contendo a chave privada codificada PEM usada para identificar a conexão com o MongoDB. Este parâmetro, se presente, tem precedência sobre o valor da opção:ssl_key_object

  • :ssl_verify (verdadeiro, falso) —

    Se deve ser executada a validação do certificado de par e a verificação do nome do host. Observe que a decisão de validar certificados será substituída se :ssl_verify_certificate estiver definido, e a decisão de validar nomes de host será substituída se :ssl_verify_hostname estiver definido.

  • :ssl_verify_certificate (verdadeiro, falso) —

    Se a validação do certificado de par deve ser executada. Esta configuração substitui :ssl_verify no que diz respeito à execução ou não da validação do certificado.

  • :ssl_verify_hostname (verdadeiro, falso) —

    Se deve ser executada a validação do nome do host do par. Esta configuração substitui :ssl_verify com relação à execução ou não da validação do nome do host.

  • :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 recurso não está ativado.

  • :truncate_logs (verdadeiro, falso) —

    Se os registros devem ser truncados nos 250 caracteres padrão.

  • : user (string) —

    O nome de usuário.

  • :wait_queue_timeout (Flutuante) —

    O tempo de espera, em segundos, no pool de conexões para que uma conexão seja verificada. Esta opção está obsoleta, use :timeout_ms em vez disso.

  • :wrapping_libraries (Array<Hash>) —

    Informações sobre bibliotecas, como ODMs, que estão empacotando o driver a serem adicionados a

    metadata sent to the server. Specify the lower level libraries first.
Allowed hash keys: :name, :version, :platform.
  • :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, :wtimeout => inteiro (em milissegundos, obsoleto), :j => booleano, : fsync => booleano.

  • :zlib_compression_level (Inteiro) —

    O nível de compressão zlib a ser usado, se estiver usando compressão. Ruby zlib Consulte o módulo do para obter níveis válidos.

  • :resolv_options (Hash) —

    Somente para uso interno do driver. Opções a serem passadas para o construtor Resolv::DNS para pesquisas SRV.

  • :auto_encryption_options (Hash) —

    Opções relacionadas à criptografia automática.

    • :key_vault_client => Cliente | nil, um cliente conectado à instância do MongoDB que contém o cofre da chave de criptografia

    • :key_vault_namespace => string, o namespace do cofre de chaves no formato database.collection

    • :kms_providers => Hash, Um hash de informações de configuração KMS (KMS). As chaves de hash válidas são :aws, :azure, :gcp, :kmip, :local. Pode haver mais de um fornecedor de KMS especificado.

    • :kms_tls_options => Hash, um hash de opções de TLS para autenticar em provedores KMS, geralmente usado para servidores KMIP. As chaves de hash válidas são :aws, :azure, :gcp, :kmip, :local. Pode haver mais de um fornecedor de KMS especificado.

    • :schema_map => Hash | nil, JSONSchema para uma ou mais collections especificando quais campos devem ser criptografados. Esta opção é mutuamente exclusiva com :schema_map_path.

      • Observação: os esquemas fornecidos no schema_map se aplicam somente à configuração da criptografia automática para criptografia do lado do cliente. Outras regras de validação no JSON schema não serão aplicadas pelo driver e resultarão em um erro.

      • Observação: fornecer um schema_map oferece mais segurança do que depender de JSON schemas obtidos do servidor. Ele protege contra um servidor malicioso que anuncia um falso JSON schema, que pode induzir o cliente a enviar dados não criptografados que devem ser criptografados.

      • Observação: se uma coleção estiver presente em :encrypted_fields_map e :schema_map, um erro será gerado.

    • :schema_map_path => string | nil Um caminho para um arquivo contém o JSON schema

    da coleção que armazena documentos criptografados automaticamente. Esta opção é mutuamente exclusiva com o :schema_map.

    • :bypass_auto_encryption => Boolean, quando verdadeiro, desabilita a criptografia automática; o padrão é falso.

    • :extra_options => Hash | nil, opções relacionadas à geração de mongocryptd (esta parte da API está sujeita a alterações).

    • :encrypted_fields_map => Hash | nil, mapeia um namespace de collection para um hash que descreve campos criptografados para Queryable Encryption.

      • Observação: se uma coleção estiver presente no encryptionFieldsMap e no schemaMap, um erro será gerado.

    • :bypass_query_analysis => Booleano | nil, quando verdadeiro desabilita a análise automática de comandos de saída.

    • :crypt_shared_lib_path => [ string | nil ] Caminho que deve ser usado para carregar a biblioteca compartilhada de criptografia. Desde que esta opção substitua os caminhos de carregamento da biblioteca compartilhada de criptografia padrão para libmongocrypt.

    • :crypt_shared_lib_required => [ Booleano | nil ] Se a biblioteca compartilhada de criptografia é necessária. Se 'true', um erro será gerado se uma biblioteca crypt_shared não puder ser carregada por libmongocrypt.

    Notas sobre criptografia automática:

    • A criptografia automática é um recurso somente empresarial que se aplica somente a operações em uma collection.

    • A criptografia automática não é suportada para operações em um banco de dados de dados ou visualização.

    • A criptografia automática exige que o usuário autenticado tenha o privilégio listCollections.

    • Na pior das casos, a criptografia automática pode triplicar o número de conexões usadas pelo cliente a qualquer momento.

    • Se a criptografia automática falhar em uma operação, use um MongoClient configurado com bypass_auto_encryption: true e use ClientEncryption.encrypt para criptografar valores manualmente.

    • Habilitar a criptografia do lado do cliente reduz o tamanho máximo do lote de gravação e pode ter um impacto negativo no desempenho.

Desde:

  • 2.0.0

[Ver fonte]

502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
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
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
 
# File 'lib/mongo/ cliente.rb', linha 502

def inicializar(endereços_or_uri, opções = nada)
  opções = opções ? opções.dup : {}

  processado = process_addresses(endereços_or_uri, opções)

  uri = processado[:uri]
  Endereços = processado[:addresses]
  opções = processado[:opções]

  # Se o URI for um URI SRV, observe isto para que possamos começar
  # Pesquisa SRV se a topologia for um cluster fragmentado.
  srv_uri = uri se uri.is_a?(URI::Protocolo SRV)

  opções = auto.classe.canonicalize_ruby_options(opções)

  # A versão da API do servidor é especificada para ser uma string.
  # No entanto, é muito trabalhoso sempre fornecer o número 1 como uma string,
  #, portanto, convertido para o tipo de string aqui.
  se server_api = opções[:server_api]
    se server_api.is_a?(Hash)
      server_api = Opções::Editado.Novo(server_api)
      se (Versão = server_api[:version]).is_a?(Inteiro)
        opções[:server_api] = server_api.mesclar(versão: Versão.to_s)
      end
    end
  end

  # Tratamento especial para sdam_proc, pois ele é usado apenas durante o cliente
  # construção
  sdam_proc = opções.excluir(:sdam_proc)

  # Para gssapi service_name, a opção padrão é fornecida em um hash
  # (um nível abaixo do nível superior).
  mescle_options = default_options(opções)
  opções.cada fazer |k, v|
    default_v = mescle_options[k]
    se Hash === default_v
      v = default_v.mesclar(v)
    end
    mescle_options[k] = v
  end
  opções = mescle_options

  opções.keys.cada fazer |k|
    se opções[k].nada?
      opções.excluir(k)
    end
  end

  @opções = validate_new_options!(opções)
=begin Suporte ao objeto WriteConcern
  se @options[:write_concern].is_a?(WriteConcern::Base)
    # Armazene a instância em cache para que não a reconstruamos desnecessariamente.
    @write_concern = @options[:write_concern]
    @options[:write_concern] = @write_concern.options
  end
=end
  @opções.congelar
  validate_options!(Endereços, is_srv: uri.is_a?(URI::Protocolo SRV))
  validate_authentication_options!

  database_options = @opções.dup
  database_options.excluir(:server_api)
  @database = Database.Novo(auto, @opções[:database], database_options)

  # Defina temporariamente o monitoramento para que as assinaturas de evento possam ser
  # configurado sem que haja um cluster
  @monitoring = Monitoramento.Novo(@opções)

  se sdam_proc
    sdam_proc.Chame(auto)
  end

  @connect_lock = Mutex.Novo
  @connect_lock.sincronizar fazer
    @cluster = cluster.Novo(Endereços, @monitoring,
      cluster_options.mesclar(srv_uri: srv_uri))
  end

  começar
    # Desconfigure o monitoramento, ele será retirado do cluster a partir de agora
    remove_instance_variable('@monitoring')

    se @opções[:auto_encryption_options]
      @connect_lock.sincronizar fazer
        build_encrypter
      end
    end

  salvar
    começar
      @cluster.Fechar
    salvar => e
      log_service("Erro ao fechar o cluster no manipulador de exceções do construtor do cliente: #{e.class}: #{e}")
      # Solte esta exceção para que a exceção original seja gerada
    end
    aumentar
  end

  se block_given?
    começar
      rendimento(auto)
    garantir
      Fechar
    end
  end
end

Detalhes do atributo da instância

#cluster ➤ Mongo::Cluster (readonly)

Retorna cluster O cluster de servidores para o cliente.

Retorna:

  • (Mongo::Cluster) —

    cluster O cluster de servidores para o cliente.

Desde:

  • 2.0.0


139
140
141
 
# File 'lib/mongo/ cliente.rb', linha 139

def cluster
  @cluster
end

#database ➤ Mongo::Database (readonly)

Retorna banco de dados O banco de dados no qual o cliente está operando.

Retorna:

  • (Mongo::Database) —

    database O banco de dados no qual o cliente está operando.

Desde:

  • 2.0.0


142
143
144
 
# File 'lib/mongo/ cliente.rb', linha 142

def database
  @database
end

#encrypter ➤ Mongo::Crypt::AutoEncrypter (somente leitura)

Retorna o objeto que encapsula o comportamento de criptografia automática.

Retorna:

Desde:

  • 2.0.0


149
150
151
 
# File 'lib/mongo/ cliente.rb', linha 149

def criptografador
  @encrypter
end

#opções ➤ Hash (somente leitura)

Retorna opções As opções de configuração.

Retorna:

  • (Hash) —

    options As opções de configuração.

Desde:

  • 2.0.0


145
146
147
 
# File 'lib/mongo/ cliente.rb', linha 145

def opções
  @opções
end

Detalhes do método de classe

.canonicalize_ruby_options(opções) ➤ 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.

As propriedades do mecanismo de autenticação em minúsculas, se fornecidas, nas opções especificadas, convertem as opções em uma instância de Options::Redacted.

Desde:

  • 2.0.0

[Ver fonte]

1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
 
# File 'lib/mongo/ cliente.rb', linha 1162

def canonicalize_ruby_options(opções)
  Opções::Editado.Novo(Hash[opções.map fazer |k, v|
    se k == :auth_mech_properties || k == 'auth_mech_properties'
      se v
        v = Hash[v.map { |pk, pv| [pk.downcase, pv] }]
      end
    end
    [k, v]
  end])
end

Detalhes do método de instância

#==(outro) ➤ true, false Também conhecido como: eql?

Determine se este cliente é equivalente a outro objeto.

Exemplos:

Verifique a igualdade do cliente.

client == other

Parâmetros:

  • Outro (Objeto) —

    O objeto com o qual comparar.

Retorna:

  • (verdadeiro, falso) —

    Se os objetos forem iguais.

Desde:

  • 2.0.0

[Ver fonte]

178
179
180
181
 
# File 'lib/mongo/ cliente.rb', linha 178

def ==(Outro)
  Método false a menos que Outro.is_a?(Cliente)
  cluster == Outro.cluster && opções == Outro.opções
end

#[](collection_name, options = {}) ➤ Mongo::Collection

Obtenha um objeto de coleção para o nome da coleção fornecido.

Exemplos:

Obtenha a coleção.

client[: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

[Ver fonte]

195
196
197
 
# File 'lib/mongo/ cliente.rb', linha 195

def [](collection_name, opções = {})
  database[collection_name, opções]
end

#close ➤ true

Feche todas as conexões.

Retorna:

  • (verdadeiro) —

    Sempre verdadeiro.

Desde:

  • 2.1.0

[Ver fonte]

865
866
867
868
869
870
871
 
# File 'lib/mongo/ cliente.rb', linha 865

def Fechar
  @connect_lock.sincronizar fazer
    @closed = true
    do_close
  end
  true
end

#close_encrypter ➤ true

Feche o criptografador e limpe os recursos de criptografia automática.

Retorna:

  • (verdadeiro) —

    Sempre verdadeiro.

Desde:

  • 2.0.0

[Ver fonte]

876
877
878
879
880
 
# File 'lib/mongo/ cliente.rb', linha 876

def close_encrypter
  @encrypter.Fechar se @encrypter

  true
end

#fechado? ➤ Booleano

Retorna:

  • (Booleano)

Desde:

  • 2.0.0

[Ver fonte]

856
857
858
 
# File 'lib/mongo/ cliente.rb', linha 856

def fechado?
  !!@closed
end

#cluster_options ➤ 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]

611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
 
# File 'lib/mongo/ cliente.rb', linha 611

def cluster_options
  # Compartilhamos clusters quando um novo cliente com CRUD_OPTIONS diferente
  # é solicitado; portanto, o cluster não deve receber nenhum desses
  # opções na instanciação
  opções.rejeitar fazer |chave, valor|
    CRUD_OPTIONS.incluir?(chave.to_sym)
  end.mesclar(
    # mas precisa colocar o banco de dados de volta para autenticação...
    database: opções[:database],

    # Coloque essas opções para compatibilidade com legados, mas observe que
    # seus valores no cliente e no cluster não precisam corresponder -
    # os aplicativos devem ler esses valores do cliente, não do cluster
    max_read_retrys: opções[:max_read_retry],
    read_retry_interval: opções[:read_retry_interval],
  ).toque fazer |opções|
    # Se o cliente já tiver um cluster, encaminhe srv_uri para o novo
    # cluster para manter o monitoramento SRV. Se o cliente for novo,
    # seu construtor define srv_uri manualmente.
    se cluster
      opções.update(srv_uri: cluster.opções[:srv_uri])
    end
  end
end

#database_names(filter = {}, opts = {}) ➤ Array<String>

Obtenha os nomes de todos os bancos de dados.

Exemplos:

Obtenha os nomes do banco de dados.

client.database_names

Parâmetros:

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

    Os critérios de filtro para obter uma lista de bancos de dados.

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

  • : authorized_databases (verdadeiro, falso) —

    Um sinalizador que determina quais bancos de dados serão retornados com base nos privilégios do usuário quando o controle de acesso estiver ativado

    Consulte mongodb.com/pt-br/docs/manual/reference/command/listDatabases/ para obter mais informações e uso.

  • :session (Sessão) —

    A sessão a ser usada.

  • :comentário (Objeto) —

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

Retorna:

  • (Array<String>) —

    Os nomes dos bancos de dados.

Desde:

  • 2.0.5

[Ver fonte]

932
933
934
 
# File 'lib/mongo/ cliente.rb', linha 932

def database_names(filtro, filtro = {}, opciona = {})
  list_databases(filtro, filtro, true, opciona).coletar{ |informações| informações['nome'] }
end

#encryption_fields_map ➤ Hash | nada

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 hash do mapa de campo criptografado se fornecido ao criar o cliente.

Retorna:

  • (Hash | nulo) —

    Hash de mapa de campo criptografado ou nulo se não estiver definido.

Desde:

  • 2.0.0

[Ver fonte]

1178
1179
1180
 
# File 'lib/mongo/ cliente.rb', linha 1178

def encryption_fields_map
  @encrypted_fields_map ||= @opções.buscar(:auto_encryption_options, {})[:encrypted_fields_map]
end

#get_session(options = {}) ➤ Sessão | nada

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 uma sessão para usar para operações, se possível.

Se a opção :session estiver definida, valida essa sessão e a retorna. Caso contrário, se o sistema suportar sessões, crie uma nova sessão e a retorne. Quando uma nova sessão é criada, a sessão será implícita (o ciclo de vida é gerenciado pelo driver) se a opção :implicit for fornecida, caso contrário, a sessão será explícita (o ciclo de vida gerenciado pelo aplicativo). Se o sistema não suportar sessão, retornará zero.

Parâmetros:

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

    um conjunto personalizável de opções

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

  • :implicit (verdadeiro | falso) —

    Quando nenhuma sessão é passada, se deseja criar uma sessão implícita.

  • :session (Sessão) —

    A sessão para validar e retornar.

Retorna:

  • (Sessão | nil) —

    Objeto de sessão ou nulo se as sessões não forem suportadas pelo sistema.

Desde:

  • 2.0.0

[Ver fonte]

1118
1119
1120
1121
1122
 
# File 'lib/mongo/ cliente.rb', linha 1118

def get_session(opções = {})
  get_session!(opções)
salvar Erro::SessionsNotSupported
  nada
end

#hash ➤ inteiro

Obtenha o valor de hash do cliente.

Exemplos:

Obtenha o valor de hash do cliente.

client.hash

Retorna:

  • (Inteiro) —

    O valor de hash do cliente.

Desde:

  • 2.0.0

[Ver fonte]

207
208
209
 
# File 'lib/mongo/ cliente.rb', linha 207

def hash
  [cluster, opções].hash
end

#inspecionar ➤ string

Obtenha uma inspeção do cliente como uma string.

Exemplos:

Inspecione o cliente.

client.inspect

Retorna:

  • (string) —

    A string de inspeção.

Desde:

  • 2.0.0

[Ver fonte]

674
675
676
 
# File 'lib/mongo/ cliente.rb', linha 674

def inspecionar
  "#<Mongo::Client:0x#{object_id} cluster=#{cluster.resume}>"
end

#list_databases(filter = {}, name_only = false, opts = {}) ➤ Array<Hash>

Obtenha informações para cada banco de dados.

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

Exemplos:

Obtenha as informações de cada banco de dados de dados .

client.list_databases

Parâmetros:

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

    Os critérios de filtro para obter uma lista de bancos de dados.

  • name_only (verdadeiro, falso) (padrão para: false) —

    Se deve retornar apenas cada nome de banco de dados sem metadados completos.

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

  • : authorized_databases (verdadeiro, falso) —

    Um sinalizador que determina quais bancos de dados serão retornados com base nos privilégios do usuário quando o controle de acesso estiver habilitado.

  • :comentário (Objeto) —

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

  • :session (Sessão) —

    A sessão a ser usada.

Retorna:

  • (Array<Hash>) —

    As informações de cada banco de dados de dados.

Desde:

  • 2.0.5

[Ver fonte]

963
964
965
966
967
968
969
 
# File 'lib/mongo/ cliente.rb', linha 963

def list_databases(filtro, filtro = {}, name_only = false, opciona = {})
  cmd = { bancos de dados de lista: 1 }
  cmd[:nameOnly] = !!name_only
  cmd[:filter] = filtro, filtro a menos que filtro, filtro.vazio?
  cmd[: authorizedDatabases] = true se opciona[: authorized_databases]
  Usar(Database::ADMIN).database.read_command(cmd, opciona).primeiro[Database::Bancos de dados]
end

#list_mongo_databases(filter = {}, opts = {}) ➤ Array <Mongo::Database>

Retorna uma lista de objetos Mongo::Database.

Exemplos:

Obtenha uma lista de objetos Mongo::Database.

client.list_mongo_databases

Parâmetros:

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

    Os critérios de filtro para obter uma lista de bancos de dados.

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

  • :session (Sessão) —

    A sessão a ser usada.

Retorna:

Desde:

  • 2.5.0

[Ver fonte]

986
987
988
989
990
 
# File 'lib/mongo/ cliente.rb', linha 986

def list_mongo_databases(filtro, filtro = {}, opciona = {})
  database_names(filtro, filtro, opciona).coletar fazer |name|
    Database.Novo(auto, name, opções)
  end
end

#max_read_retry ➤ Inteiro

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.

Obtenha o número máximo de vezes que o cliente pode tentar novamente uma operação de leitura ao usar novas tentativas de leitura legado .

Retorna:

  • (Inteiro) —

    O número máximo de tentativas.

Desde:

  • 2.0.0

[Ver fonte]

642
643
644
 
# File 'lib/mongo/ cliente.rb', linha 642

def max_read_retry
  opções[:max_read_retry] || cluster::MAX_READ_RETRIES
end

#max_write_retry ➤ Inteiro

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.

Obtenha o número máximo de vezes que o cliente pode tentar novamente uma operação de gravação ao usar novas tentativas de gravação herdadas.

Retorna:

  • (Inteiro) —

    O número máximo de tentativas.

Desde:

  • 2.0.0

[Ver fonte]

662
663
664
 
# File 'lib/mongo/ cliente.rb', linha 662

def max_write_retry
  opções[:max_write_retry] || cluster::MAX_WRITE_RETRIES
end

#read_concern ➤ Hash

Obtenha a preocupação de leitura para este cliente.

Exemplos:

Obtenha a preocupação de leitura do cliente.

client.read_concern

Retorna:

  • (Hash) —

    A read concern.

Desde:

  • 2.6.0

[Ver fonte]

839
840
841
 
# File 'lib/mongo/ cliente.rb', linha 839

def read_concern
  opções[:read_concern]
end

#read_preference ➤ BSON::Document

Obtenha a preferência de leitura a partir das opções passadas para o cliente.

Exemplos:

Obtenha a read preference.

client.read_preference

Retorna:

  • (BSON::Document) —

    A preferência de leitura definida pelo usuário. O documento pode ter os seguintes campos:

    • : modo – preferência de leitura especificada como um símbolo; Os valores válidos são :primary, :primary_preferred, :secondary, :secondary_preferred e :nearest.

    • :tag_sets – uma array de hashes.

    • :local_threshold.

Desde:

  • 2.0.0

[Ver fonte]

722
723
724
 
# File 'lib/mongo/ cliente.rb', linha 722

def read_preference
  @read_preference ||= opções[:read]
end

#read_retry_interval ➤ Flutuante

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.

Obtenha o intervalo, em segundos, em que as tentativas de leitura ao usar tentativas de leitura herdadas.

Retorna:

  • (Flutuante) —

    O intervalo.

Desde:

  • 2.0.0

[Ver fonte]

652
653
654
 
# File 'lib/mongo/ cliente.rb', linha 652

def read_retry_interval
  opções[:read_retry_interval] || cluster::READ_RETRY_INTERVAL
end

#reconectar ➤ verdadeiro

Reconectar o cliente.

Exemplos:

Reconectar o cliente.

client.reconnect

Retorna:

  • (verdadeiro) —

    Sempre verdadeiro.

Desde:

  • 2.1.0

[Ver fonte]

890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
 
# File 'lib/mongo/ cliente.rb', linha 890

def reconectar
  Endereços = cluster.Endereços.map(&:to_s)

  @connect_lock.sincronizar fazer
    do_close salvar nada

    @cluster = cluster.Novo(Endereços, Monitoramento, cluster_options)

    se @opções[:auto_encryption_options]
      build_encrypter
    end

    @closed = false
  end

  true
end

#server_selector ➤ Mongo::ServerSelector

Obtenha o seletor de servidor. Ele usa a read preference definida nas opções do cliente ou padroniza para um seletor de servidor Primary.

Exemplos:

Obtenha o seletor de servidor.

client.server_selector

Retorna:

  • (Mongo::ServerSelector) —

    O seletor de servidor usando a preferência de leitura definida pelo usuário ou um padrão de seletor de servidor Primário.

Desde:

  • 2.5.0

[Ver fonte]

700
701
702
703
704
705
706
 
# File 'lib/mongo/ cliente.rb', linha 700

def server_selector
  @server_selector ||= se read_preference
    ServerSelector.obter(read_preference)
  mais
    ServerSelector.Principal
  end
end

#start_session(options = {}) ➤ Session

Observação:

Uma Sessão não pode ser usada por vários threads ao mesmo tempo; objetos de sessão não são seguros para threads.

Inicie uma sessão.

Se a implantação não suportar sessões, aumenta Mongo::Error::InvalidSession. Esta exceção também pode ser gerada quando o driver não está conectado a um servidor de obtenção de dados, por exemplo , durante o failover.

Exemplos:

Inicie uma sessão.

client.start_session(causal_consistency: true)

Parâmetros:

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

    As opções da sessão. Aceita as opções que Session#initialize aceita.

Retorna:

Desde:

  • 2.5.0

[Ver fonte]

1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
 
# File 'lib/mongo/ cliente.rb', linha 1011

def start_session(opções = {})
  session = get_session!(opções.mesclar(implícito: false))
  se block_given?
    começar
      rendimento session
    garantir
      session.end_session
    end
  mais
    session
  end
end

#resumo ➤ string

Observação:

O formato e o layout exatos da string de resumo retornada não fazem parte da API pública do driver e podem ser alterados a qualquer momento.

Obtenha um resumo do estado do cliente.

Retorna:

  • (string) —

    A string de resumo.

Desde:

  • 2.7.0

[Ver fonte]

686
687
688
 
# File 'lib/mongo/ cliente.rb', linha 686

def Resumo
  "#<Client cluster=#{cluster.resume}>"
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 valor da opção timeout_ms se definido.

Retorna:

  • (Inteiro | nil) —

    Valor da opção timeout_ms se definido.

Desde:

  • 2.0.0

[Ver fonte]

1184
1185
1186
 
# File 'lib/mongo/ cliente.rb', linha 1184

def timeout_ms
  @opções[:timeout_ms]
end

#timeout_sec ⇒ Float | 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 valor da opção timeout_ms convertido em segundos.

Retorna:

  • (Flutuante | nulo) —

    Valor da opção timeout_ms convertido em segundos.

Desde:

  • 2.0.0

[Ver fonte]

1190
1191
1192
1193
1194
1195
1196
 
# File 'lib/mongo/ cliente.rb', linha 1190

def timeout_sec
  se timeout_ms.nada?
    nada
  mais
    timeout_ms / 1_000.0
  end
end

#update_options(new_options) ⇒ 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.

Atualiza as opções deste cliente a partir de new_options, validando todas as opções.

As novas opções podem ser transformadas de acordo com várias regras. O hash final das opções realmente aplicadas ao cliente é retornado.

Se as opções falharem na validação, este método poderá avisar ou gerar uma exceção. Se esse método gerar uma exceção, o cliente deverá ser descartado (da mesma forma que se um construtor levantasse uma exceção).

Parâmetros:

  • new_options (Hash) —

    As novas opções a serem usadas.

Retorna:

  • (Hash) —

    Novas opções modificadas escritas no cliente.

Desde:

  • 2.0.0

[Ver fonte]

789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
 
# File 'lib/mongo/ cliente.rb', linha 789

def update_options(new_options)
  old_options = @opções

  new_options = auto.classe.canonicalize_ruby_options(new_options || {})

  validate_new_options!(new_options).toque fazer |opciona|
    # Nossas opções estão congeladas
    opções = @opções.dup
    se opções[:write] && opciona[:write_concern]
      opções.excluir(:write)
    end
    se opções[:write_concern] && opciona[:write]
      opções.excluir(:write_concern)
    end

    opções.update(opciona)
    @opções = opções.congelar

    auto_encryption_options_changed =
      @opções[:auto_encryption_options] != old_options[:auto_encryption_options]

    # Se houver novas auto_encryption_options, crie um novo criptografador.
    # Caso contrário, permita que o novo cliente compartilhe um criptografador com o
    #cliente original.
    #
    # Se auto_encryption_options forem nil, defina @encrypter como nil, mas não
    # feche o criptografador porque ele ainda pode ser usado pelo cliente original .
    se @opções[:auto_encryption_options] && auto_encryption_options_changed
      @connect_lock.sincronizar fazer
        build_encrypter
      end
    elsif @opções[:auto_encryption_options].nada?
      @connect_lock.sincronizar fazer
        @encrypter = nada
      end
    end

    validate_options!
    validate_authentication_options!
  end
end

#use(name) ➤ Mongo::Client

Observação:

O novo cliente compartilha o cluster com o cliente original e, como resultado, também compartilha a instância de monitoramento e os assinantes de eventos de monitoramento.

Cria um novo cliente configurado para utilizar o banco de dados com o nome fornecido e utilizando as outras opções configuradas neste cliente.

Exemplos:

Crie um cliente para o banco de dados dos "usuários".

client.use(:users)

Parâmetros:

  • name (string, símbolo) —

    O nome do banco de dados a ser usado.

Retorna:

Desde:

  • 2.0.0

[Ver fonte]

741
742
743
 
# File 'lib/mongo/ cliente.rb', linha 741

def Usar(name)
  com(database: name)
end

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

Observação:

Um change stream permite apenas a preocupação de leitura 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.

A partir da versão 3.6 do servidor MongoDB, um estágio de pipeline "$changeStream" é suportado no framework de aggregation. A partir da versão 4.0, esse estágio permite que os usuários solicitem que as notificações sejam enviadas para todas as alterações que ocorrem no cluster do cliente.

Exemplos:

Receba notificações de alteração para o cluster do cliente.

client.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, 'default', '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 pós-imagem 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 change stream 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 alterações que ocorreram no momento ou após o registro de data/hora especificado. Qualquer comando executado no servidor retornará um tempo de cluster que pode ser usado aqui. Reconhecido apenas pelas versões do servidor 4.0+.

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

[Ver fonte]

1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
 
# File 'lib/mongo/ cliente.rb', linha 1088

def assistir(gasoduto = [], opções = {})
  Método Usar(Database::ADMIN).assistir(gasoduto, opções) a menos que database.name == Database::ADMIN

  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(auto["#{Database::COMMAND}.aggregate"], {}, view_options),
    gasoduto,
    mongo::collection::Vista::Change stream::cluster,
    opções)
end

#com(new_options = nil) ➤ Mongo::Client

Observação:

Dependendo das opções fornecidas, o cliente retornado pode compartilhar o cluster com o cliente original ou ser criado com um novo cluster. Se um novo cluster for criado, os assinantes de eventos de monitoramento no novo cliente serão definidos para o conjunto de assinantes de eventos padrão e nenhum dos assinantes no cliente original será copiado.

Cria um novo cliente com as opções passadas mescladas sobre as opções existentes deste cliente. Útil para eventos únicos para alterar opções específicas sem alterar o cliente original.

Exemplos:

Obtenha um cliente com opções alteradas.

client.with(:read => { :mode => :primary_preferred })

Parâmetros:

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

    As novas opções a serem usadas.

Retorna:

Desde:

  • 2.0.0

[Ver fonte]

763
764
765
766
767
768
769
770
771
772
773
 
# File 'lib/mongo/ cliente.rb', linha 763

def com(new_options = nada)
  clonar.toque fazer |Cliente|
    opciona = Cliente.update_options(new_options || Opções::Editado.Novo)
    Database.criar(Cliente)
    # Não podemos usar o mesmo cluster se algumas opções que o afetariam
    # foram alterados.
    se cluster_modifying?(opciona)
      cluster.criar(Cliente, monitoramento: opciona[:monitoring])
    end
  end
end

#with_session(opções = {}, &block) ➤ 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.

Cria uma sessão para usar para operações, se possível, e a gera para o bloco fornecido.

Se a opção :session estiver definida, valida essa sessão e a utiliza. Caso contrário, se o sistema suportar sessões, crie uma nova sessão e use-a. Quando uma nova sessão é criada, a sessão será implícita (o ciclo de vida é gerenciado pelo driver) se a opção :implicit for fornecida, caso contrário, a sessão será explícita (o ciclo de vida gerenciado pelo aplicativo). Se a implantação não suportar sessão, produz zero para o bloco.

Quando o bloqueio terminar, se a sessão foi criada e foi implícita, ou se uma sessão implícita foi passada, a sessão é encerrada, o que a retorna para o pool de sessões disponíveis.

Parâmetros:

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

    um conjunto personalizável de opções

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

  • :implicit (verdadeiro | falso) —

    Quando nenhuma sessão é passada, se deseja criar uma sessão implícita.

  • :session (Sessão) —

    A sessão para validar e retornar.

Desde:

  • 2.0.0

[Ver fonte]

1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
 
# File 'lib/mongo/ cliente.rb', linha 1144

def with_session(opções = {}, &noum: bloco ; verb: bloquear)
  # TODO: Adicione isto de volta no RUBY-3174.
  # assert_not_closed

  session = get_session(opções)

  rendimento session
garantir
  se session && session.implícito?
    session.end_session
  end
end

#write_concern ➤ Mongo::WriteConcern

Obtenha a write concern para esse cliente. Se nenhuma opção tiver sido fornecida, será usada uma confirmação de servidor único padrão.

Exemplos:

Obtenha a preocupação de escrita do cliente.

client.write_concern

Retorna:

Desde:

  • 2.0.0

[Ver fonte]

852
853
854
 
# File 'lib/mongo/ cliente.rb', linha 852

def write_concern
  @write_concern ||= Escreva preocupação.obter(opções[:write_concern] || opções[:write])
end