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) —

    Quando passados em uma string de conexão como authMechanismProperties, os pares de valores-chave são delimitados por vírgulas, portanto, um valor que contenha uma vírgula (""," ") não deve ser fornecido como parte da string de conexão. Em vez disso, esse valor deve ser passado por essa opção. Os valores podem conter dois pontos (":").

  • :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: fornecer um encryption_fields_map fornece mais segurança do que depender de um encryptionFields obtido do servidor. Ele protege contra um servidor malicioso que anuncia um falso encryptionFields.
      • 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.
    • :key_expiration_ms => Inteiro | nil, a vida útil do cache da chave de criptografia de dados, em milissegundos. Deve ser um número inteiro não negativo. Um valor de 0 significa que o cache nunca expira. O padrão é 60000.

    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



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
642
643
644
645
646
647
648
649
650
651
652
653
654
655
 
# File 'lib/mongo/ cliente.rb', linha 551

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 = build_retry_policy
  @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
  # O ScriptError é salvo além do StandardError porque
  # Mongo::Crypt::Binding gera um LoadError quando libmongocrypt não pode ser
  # encontrado. Sem ele, o cluster construído acima seria deixado aberto, vazando
  # seus threads de pool de conexões .
  salvar StandardError, Erro de script
    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



1235
1236
1237
1238
1239
1240
1241
1242
 
# File 'lib/mongo/ cliente.rb', linha 1235

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



936
937
938
939
940
941
942
 
# File 'lib/mongo/ cliente.rb', linha 936

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



947
948
949
950
951
 
# File 'lib/mongo/ cliente.rb', linha 947

def close_encrypter
  @encrypter.Fechar se @encrypter

  true
end

#fechado? ➤ Booleano

Retorna:

  • (Booleano)

Desde:

  • 2.0.0



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

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



658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
 
# File 'lib/mongo/ cliente.rb', linha 658

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



1005
1006
1007
 
# File 'lib/mongo/ cliente.rb', linha 1005

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



1249
1250
1251
 
# File 'lib/mongo/ cliente.rb', linha 1249

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



1193
1194
1195
1196
1197
 
# File 'lib/mongo/ cliente.rb', linha 1193

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



720
721
722
 
# File 'lib/mongo/ cliente.rb', linha 720

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



1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
 
# File 'lib/mongo/ cliente.rb', linha 1036

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



1062
1063
1064
1065
1066
 
# File 'lib/mongo/ cliente.rb', linha 1062

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



688
689
690
 
# File 'lib/mongo/ cliente.rb', linha 688

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



708
709
710
 
# File 'lib/mongo/ cliente.rb', linha 708

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



910
911
912
 
# File 'lib/mongo/ cliente.rb', linha 910

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



768
769
770
 
# File 'lib/mongo/ cliente.rb', linha 768

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



698
699
700
 
# File 'lib/mongo/ cliente.rb', linha 698

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



961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
 
# File 'lib/mongo/ cliente.rb', linha 961

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



894
895
896
897
898
899
900
 
# File 'lib/mongo/ cliente.rb', linha 894

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



882
883
884
 
# File 'lib/mongo/ cliente.rb', linha 882

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



746
747
748
749
750
751
752
 
# File 'lib/mongo/ cliente.rb', linha 746

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



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

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



732
733
734
 
# File 'lib/mongo/ cliente.rb', linha 732

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



1255
1256
1257
 
# File 'lib/mongo/ cliente.rb', linha 1255

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



1261
1262
1263
1264
1265
1266
1267
 
# File 'lib/mongo/ cliente.rb', linha 1261

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



1272
1273
1274
1275
1276
1277
1278
1279
 
# File 'lib/mongo/ cliente.rb', linha 1272

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



833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
 
# File 'lib/mongo/ cliente.rb', linha 833

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

    # A política de novas tentativas é criada a partir das opções, portanto, um cliente criado por
    # #with precisa de sua própria política quando a opção for alterada.
    se @opções[:max_adaptive_retry] != old_options[:max_adaptive_retry]
      @retry_policy = build_retry_policy
    end

    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



787
788
789
 
# File 'lib/mongo/ cliente.rb', linha 787

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



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

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



809
810
811
812
813
814
815
816
817
 
# File 'lib/mongo/ cliente.rb', linha 809

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



1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
 
# File 'lib/mongo/ cliente.rb', linha 1219

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



923
924
925
 
# File 'lib/mongo/ cliente.rb', linha 923

def write_concern
  @write_concern ||= WriteConcern.obter(opções[:write_concern] || opções[:write])
end