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,
  :max_adaptive_retry, :enable_overload_tartargeting,
  :timeout_ms,

  # 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 revisar
  # 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

%i[
  app_name
  auth_mech
  auth_mech_properties
  auth_source
  auto_encryption_options
  bg_error_backtrace
  limpeza
  compressors
  direct_connection
  enable_overload_targetting
  Conecte
  connect_timeout
  database
  heartbeat_frequency
  id_generator
  load_balanced
  local_threshold
  logger
  log_prefix
  max_adaptive_retry
  max_connecting
  max_idle_time
  max_pool_size
  max_read_retry
  max_write_retry
  min_pool_size
  Monitoramento
  monitoring_io
  Senha
  Plataforma
  populator_io
  ler
  read_concern
  read_retry_interval
  replica_set
  resolv_options
  retry_reads
  retry_writes
  digitalizar
  sdam_proc
  server_api
  server_monitoring_mode
  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
  rastreamento
  truncate_logs
  utilizador
  wait_queue_timeout
  wrap_libraries
  escrever
  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

  • :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, :fragmentado, :load_balanced. Se :connect estiver definido como :load_balanced, o driver se comportará como se o servidor fosse um balanceador de carga, mesmo que não esteja conectado a um balanceador 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.

  • :enable_overload_tartargeting (verdadeiro | falso) —

    Se o driver desprioriza um servidor que retorna um erro de sobrecarga, reduzindo a probabilidade de tentar novamente no mesmo servidor sobrecarregado. Esta opção funciona com o MongoDB Atlas servidor Versão 9.0 e superior. Padrão: false.

  • : 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_adaptive_retry (Inteiro) —

    O número máximo de tentativas a serem feitas quando o driver encontrar erros de sobrecarga. Esta opção funciona com o MongoDB Atlas servidor Versão 9.0 e superior. Padrão: 2.

  • :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. Obsoleto: esta opção afeta apenas a implementação de repetição legado, que está obsoleto e será removida em uma versão futura.

  • :max_write_retry (Inteiro) —

    O número máximo de tentativas de gravar quando as tentativas de gravar legado estão em uso. Obsoleto: esta opção afeta apenas a implementação de repetição legado, que está obsoleto e será removida em uma versão futura.

  • :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 a serem incluídas nos metadados impressos nos registros do mongod ao estabelecer uma conexão

  • :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; Valores válidos são :primary, :primary_preferred, :secondary, :secondary_preferred e :mais próximo.
    • :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. Obsoleto: esta opção afeta apenas a implementação de repetição legado, que está obsoleto e será removida em uma versão futura.

  • :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 repetir as gravações uma vez quando estiver conectado a um conjunto de réplicas ou a um cluster fragmentado. (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 -- booleano
    • :deprecation_errors -- booleano
  • :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 se resolver para mais hosts do que :srv_max_hosts, o cliente escolherá aleatoriamente um subconjunto de hosts do tamanho de :srv_max_hosts. Se srvMaxHosts for fornecido nas opções de URI, ele terá precedência sobre esta opção.

  • :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 para serem adicionadas aos metadados enviados ao servidor. Especifique primeiro as bibliotecas de nível inferior. Chaves de hash permitidas: :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. Consulte o módulo zlib do Ruby 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.

  • :trasing (Hash) —

    Opções de rastreamento OpenTelemetry.

    • :enabled => Booleano, se deseja ativar o rastreamento OpenTelemetry. O valor padrão é nil, o que significa que a configuração será retirada da variável de ambiente OTL_RUBY_Istrumentation_MONGODB_ENABLED.
    • :tracer => OpenTelemetry::Trace::Tracer, o traçador a ser usado para rastreamento. Deve ser uma implementação da interface OpenTelemetry::Trace::Tracer.
    • :query_text_max_long => Inteiro, o comprimento máximo do texto da query a ser incluído nos atributos da extensão. Se o texto da query exceder esse comprimento, ele será truncado. O valor 0 significa que nenhum texto de query será incluído nos atributos de extensão. O valor padrão é nil, o que significa que a configuração será obtida a partir da variável de ambiente OTL_RUBY_Istrumentation_MONGODB_QUERY_Text_MAX_LENGTH.
  • :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



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
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
 
# File 'lib/mongo/ cliente.rb', linha 539

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]) && 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

  # 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]
    v = default_v.mesclar(v) se default_v.is_a?(Hash)
    mescle_options[k] = v
  end
  opções = mescle_options

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

  @opções = validate_new_options!(opções)
  # Suporte ao objeto WriteConcern
  # if @options[:write_concern].is_a?(WriteConcern::Base)
  # # Cache a instância para que não a reconstruímos desnecessariamente.
  # @write_concern = @options[:write_concern]
  # @options[:write_concern] = @write_concern.options
  #       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)

  sdam_proc.Chame(auto) se sdam_proc

  @connect_lock = Mutex.Novo
  @retry_policy = Repetitivo::Política de repetição.Novo(
    max_retry: @opções[:max_adaptive_retry] || Repetitivo::Contrapressão::DEFAULT_MAX_RETRIES
  )
  @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 StandardError
    começar
      @cluster.Fechar
    salvar StandardError => e
      log_service("Erro ao fechar o cluster no manipulador de exceções do construtor do cliente: #{e.classe}: #{e}")
      # Solte esta exceção para que a exceção original seja gerada
    end
    aumentar
  end

  Método a menos que block_given?

  começar
    rendimento(auto)
  garantir
    Fechar
  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



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

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



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

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



153
154
155
 
# File 'lib/mongo/ cliente.rb', linha 153

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



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

def opções
  @opções
end

#retry_policy ⇒ Mongo::Retryable::RetryPolicy (readonly)

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 a política de repetição para contrapressão e novas tentativas adaptáveis.

Retorna:

Desde:

  • 2.0.0



158
159
160
 
# File 'lib/mongo/ cliente.rb', linha 158

def retry_policy
  @retry_policy
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



1215
1216
1217
1218
1219
1220
1221
1222
 
# File 'lib/mongo/ cliente.rb', linha 1215

def canonicalize_ruby_options(opções)
  Opções::Editado.Novo(Hash[opções.map fazer |k, v|
    se [ :auth_mech_properties, 'auth_mech_properties' ].incluir?(k) && v
      v = Hash[v.map { |pk, pv| [ pk.downcase, pv ] }]
    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



186
187
188
189
190
 
# File 'lib/mongo/ cliente.rb', linha 186

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



204
205
206
 
# File 'lib/mongo/ cliente.rb', linha 204

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



916
917
918
919
920
921
922
 
# File 'lib/mongo/ cliente.rb', linha 916

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



927
928
929
930
931
 
# File 'lib/mongo/ cliente.rb', linha 927

def close_encrypter
  @encrypter.Fechar se @encrypter

  true
end

#fechado? ➤ Booleano

Retorna:

  • (Booleano)

Desde:

  • 2.0.0



907
908
909
 
# File 'lib/mongo/ cliente.rb', linha 907

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



644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
 
# File 'lib/mongo/ cliente.rb', linha 644

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, _value|
    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],
    rastreador: rastreador
  ).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.
    opções.update(srv_uri: cluster.opções[:srv_uri]) se cluster
  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 https://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



985
986
987
 
# File 'lib/mongo/ cliente.rb', linha 985

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



1229
1230
1231
 
# File 'lib/mongo/ cliente.rb', linha 1229

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



1173
1174
1175
1176
1177
 
# File 'lib/mongo/ cliente.rb', linha 1173

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



216
217
218
 
# File 'lib/mongo/ cliente.rb', linha 216

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



706
707
708
 
# File 'lib/mongo/ cliente.rb', linha 706

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



1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
 
# File 'lib/mongo/ cliente.rb', linha 1016

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.mesclar(op_name: 'listDatabases'))
    .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



1042
1043
1044
1045
1046
 
# File 'lib/mongo/ cliente.rb', linha 1042

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



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

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



694
695
696
 
# File 'lib/mongo/ cliente.rb', linha 694

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

#monitoring ⇒ Monitoring

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.

Monitoramento de retornos O monitoramento.

Retorna:

Desde:

  • 2.0.0



168
169
170
171
172
173
174
 
# File 'lib/mongo/ cliente.rb', linha 168

def Monitoramento
  se cluster
    cluster.Monitoramento
  mais
    @monitoring
  end
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



890
891
892
 
# File 'lib/mongo/ cliente.rb', linha 890

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; Valores válidos são :primary, :primary_preferred, :secondary, :secondary_preferred e :mais próximo.
    • :tag_sets - uma array de hashes.
    • :local_threshold.

Desde:

  • 2.0.0



754
755
756
 
# File 'lib/mongo/ cliente.rb', linha 754

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



684
685
686
 
# File 'lib/mongo/ cliente.rb', linha 684

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



941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
 
# File 'lib/mongo/ cliente.rb', linha 941

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

  @connect_lock.sincronizar fazer
    começar
      do_close
    salvar StandardError
      nada
    end

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

    build_encrypter se @opções[:auto_encryption_options]

    @closed = false
  end

  true
end

#reset_cluster!(monitoramento: nil) ⇒ Object

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.

Substitui o cluster deste cliente por uma nova instância criada a partir das opções atuais do cliente. Usado por #with para que um cliente reconfigurado não compartilhe seu cluster com o cliente do qual foi clonado.

Parâmetros:

  • Monitoramento (Monitoring | nil) (padrão para: nil) —

    A instância de monitoramento a ser usada com o novo cluster. Se nulo, uma nova instância de Monitoramento será criada.

Desde:

  • 2.0.0



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

def reset_cluster!(monitoramento: nada)
  @cluster = cluster.Novo(
    cluster.Endereços.map(&:to_s),
    Monitoramento || Monitoramento.Novo,
    cluster_options
  )
end

#reset_database! ⇒ Object

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.

Substitui o banco de dados deste cliente por uma nova instância criada a partir das opções atuais do cliente. Usado por #with para que um cliente reconfigurado não compartilhe seu banco de dados com o cliente do qual foi clonado.

Desde:

  • 2.0.0



862
863
864
 
# File 'lib/mongo/ cliente.rb', linha 862

def reset_database!
  @database = Database.Novo(auto, opções[:database], opções)
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



732
733
734
735
736
737
738
 
# File 'lib/mongo/ cliente.rb', linha 732

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



1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
 
# File 'lib/mongo/ cliente.rb', linha 1067

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



718
719
720
 
# File 'lib/mongo/ cliente.rb', linha 718

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



1235
1236
1237
 
# File 'lib/mongo/ cliente.rb', linha 1235

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



1241
1242
1243
1244
1245
1246
1247
 
# File 'lib/mongo/ cliente.rb', linha 1241

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

#traçar ➤ Rastreamento::Tracer | nada

Obtenha o rastreador configurado para este cliente.

Retorna:

  • (Rastreando::Tracer | nil) —

    O rastreador configurado para este cliente.

Desde:

  • 2.0.0



1252
1253
1254
1255
1256
1257
1258
1259
 
# File 'lib/mongo/ cliente.rb', linha 1252

def rastreador
  rastreamento_opts = @opções[:trasing] || {}
  @tracer ||= Rastreamento.create_tracer(
    habilitado: rastreamento_opts[:enabled],
    query_text_max_long: rastreamento_opts[:query_text_max_longitude],
    omel_tracer: rastreamento_opts[:tracer]
  )
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



819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
 
# File 'lib/mongo/ cliente.rb', linha 819

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
    opções.excluir(:write) se opções[:write] && opciona[:write_concern]
    opções.excluir(:write_concern) se opções[:write_concern] && opciona[:write]

    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



773
774
775
 
# File 'lib/mongo/ cliente.rb', linha 773

def Usar(name)
  com(database: name)
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 que sejam enviadas notificações 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, '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 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.

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



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

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



795
796
797
798
799
800
801
802
803
 
# File 'lib/mongo/ cliente.rb', linha 795

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

#with_session(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.

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



1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
 
# File 'lib/mongo/ cliente.rb', linha 1199

def with_session(opções = {})
  # RUBY-3174 reativará esta proteção; consulte #assert_not_closed.
  # assert_not_closed

  session = get_session(opções)

  rendimento session
garantir
  session.end_session se session && session.implícito?
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



903
904
905
 
# File 'lib/mongo/ cliente.rb', linha 903

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