Classificação: Mongo::Client

Herda:
Objeto
  • Objeto
mostrar tudo
Estendido por:
Encaminhável
Inclui:
Logável
Definido em:
build/ruby-driver-v2.19/lib/mongo/client.rb

Visão geral

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

Desde:

  • 2.0.0

Colapsode resumo constante

CRUD_OPTIONS =

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

Desde:

  • 2.1.0

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

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

Opções válidas do cliente.

Desde:

  • 2.1.2

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

Os algoritmos de compressão suportados pelo driver.

Desde:

  • 2.5.0

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

As versões conhecidas da API do servidor.

Desde:

  • 2.0.0

%w(
  1
).congelar

Constantes incluídas do Loggable

Loggable::Prefix

Recolhimento do Resumo do atributo de instância

Recolhimento do Resumo do método de classe

Recolhimento do Resumo do método de instância

Métodos incluídos no Loggable

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

Detalhes do construtor

#initialize(addresses_or_uri, options = nil) ⇒ Cliente

Instancie um novo cliente de driver.

Exemplos:

Instancie um único servidor ou cliente mongos.

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

Instancie um cliente para um conjunto de réplicas.

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

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

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

Parâmetros:

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

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

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

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

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

  • :app_name (string, símbolo) —

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

  • :auth_mech (Símbolo) —

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

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

    A fonte da qual autenticar.

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

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

  • :compressors (Array<String>) —

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

  • :direct_connection (verdadeiro | falso) —

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

  • :connect (Símbolo) —

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

  • :connect_timeout (Flutuante) —

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

  • :database (string) —

    O banco de dados ao qual se conectar.

  • : heartbeat_frequency (Flutuante) —

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

  • :id_generator (Objeto) —

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

  • :load_balanced (verdadeiro | falso) —

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

  • :local_threshold (Inteiro) —

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

  • :logger (Registrador) —

    Um registrador personalizado para usar.

  • :log_prefix (string) —

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

  • :max_idle_time (Inteiro) —

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

  • :max_pool_size (Inteiro) —

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

  • :max_read_retry (Inteiro) —

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

  • :max_write_retry (Inteiro) —

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

  • :min_pool_size (Inteiro) —

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

  • :monitoring (verdadeiro, falso) —

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

  • :monitoring_io (verdadeiro, falso) —

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

  • :cleanup (verdadeiro | falso) —

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

  • :password (string) —

    A senha do usuário.

  • :platform (string) —

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

  • :read (Hash) —

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

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

    • :tag_sets – uma array de hashes.

    • :local_threshold.

  • :read_concern (Hash) —

    A opção read concern.

  • :read_retry_interval (Flutuante) —

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

  • :replica_set (Símbolo) —

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

  • :retry_reads (verdadeiro | falso) —

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

  • :retry_writes (verdadeiro | falso) —

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

  • :scan (verdadeiro | falso) —

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

  • :sdam_proc (Proc) —

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

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

  • :server_api (Hash) —

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

    • :version – string

    • :strict – boolean

    • :deprecation_errors – boolean

  • :server_selection_timeout (Inteiro) —

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

  • :socket_timeout (Flutuante) —

    O timeout, em segundos, para executar operações em um soquete.

  • :srv_max_hosts (Inteiro) —

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

  • :srv_service_name (string) —

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

  • :ssl (verdadeiro, falso) —

    Se deve usar o TLS.

  • :ssl_ca_cert (string) —

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

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

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

  • :ssl_ca_cert_string (string) —

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

  • :ssl_cert (string) —

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

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

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

  • :ssl_cert_string (string) —

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

  • :ssl_key (string) —

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

  • :ssl_key_object (OpenSSL::PKey) —

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

  • :ssl_key_pass_ phrase (string) —

    Uma senha para a chave privada.

  • :ssl_key_string (string) —

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

  • :ssl_verify (verdadeiro, falso) —

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

  • :ssl_verify_certificate (verdadeiro, falso) —

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

  • :ssl_verify_hostname (verdadeiro, falso) —

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

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

  • :wrapping_libraries (Array<Hash>) —

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

    metadata sent to the server. Specify the lower level libraries first.
Allowed hash keys: :name, :version, :platform.
  • :write (Hash) —

    Obsoleto. Equivalente à opção :write_concern.

  • :write_concern (Hash) —

    As opções de write concern. Pode ser :w => inteiro|String, :wtimeout => inteiro (em milissegundos), :j => booleano, :fsync => booleano.

  • :zlib_compression_level (Inteiro) —

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

  • :resolv_options (Hash) —

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

  • :auto_encryption_options (Hash) —

    Opções relacionadas à criptografia automática.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Notas sobre criptografia automática:

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

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

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

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

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

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

Desde:

  • 2.0.0



489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 489

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

  srv_uri = nada
  se endereços_or_uri.is_a?(::String)
    uri = URI.obter(endereços_or_uri, opções)
    se uri.is_a?(URI::Protocolo SRV)
      # 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
    end
    Endereços = uri.Servidores
    uri_options = uri.client_options.dup
    # Entrega especial para :write e :write_concern: allow cliente Ruby
    # opções para substituir as opções de URI, mesmo quando a opção Ruby usa a
    # preterida :write key e a opção URI usa a atual
    # :write_concern key
    se opções[:write]
      uri_options.excluir(:write_concern)
    end
    opções = uri_options.mesclar(opções)
    @srv_records = uri.srv_records
  mais
    Endereços = endereços_or_uri
    Endereços.cada fazer |addr|
      se addr =~ /\Amongodb(\+srv)?:\/\//i
        aumentar ArgumentError, "O host '#{addr}' não deve conter protocolo. Você média não usar uma array?"
      end
    end

    @srv_records = nada
  end

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

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

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

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

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

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

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

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

  se sdam_proc
    sdam_proc.Chame(auto)
  end

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

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

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

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

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

Detalhes do atributo da instância

#cluster ➤ Mongo::Cluster (readonly)

Retorna cluster O cluster de servidores para o cliente.

Retorna:

  • (Mongo::Cluster) —

    cluster O cluster de servidores para o cliente.

Desde:

  • 2.0.0



137
138
139
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 137

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



140
141
142
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 140

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



147
148
149
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 147

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



143
144
145
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 143

def opções
  @opções
end

Detalhes do método de classe

.canonicalize_ruby_options(opções) ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

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

Desde:

  • 2.0.0



1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 1161

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

Detalhes do método de instância

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

Determine se este cliente é equivalente a outro objeto.

Exemplos:

Verifique a igualdade do cliente.

client == other

Parâmetros:

  • Outro (Objeto) —

    O objeto com o qual comparar.

Retorna:

  • (verdadeiro, falso) —

    Se os objetos forem iguais.

Desde:

  • 2.0.0



176
177
178
179
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 176

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



193
194
195
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 193

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



872
873
874
875
876
877
878
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 872

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



883
884
885
886
887
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 883

def close_encrypter
  @encrypter.Fechar se @encrypter

  true
end

#fechado? ➤ Booleano

Retorna:

  • (Booleano)

Desde:

  • 2.0.0



863
864
865
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 863

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



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 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 618

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

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

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

Obtenha os nomes de todos os bancos de dados.

Exemplos:

Obtenha os nomes do banco de dados.

client.database_names

Parâmetros:

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

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

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

    As opções de comando.

  • opções (Hash) —

    um conjunto personalizável de opções

Hash de opções (opts):

  • : authorized_databases (verdadeiro, falso) —

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

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

  • :session (Sessão) —

    A sessão a ser usada.

Retorna:

  • (Array<String>) —

    Os nomes dos bancos de dados.

Desde:

  • 2.0.5



936
937
938
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 936

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



1177
1178
1179
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 1177

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



1117
1118
1119
1120
1121
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 1117

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



205
206
207
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 205

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



681
682
683
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 681

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.

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 ativado

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

  • :session (Sessão) —

    A sessão a ser usada.

Retorna:

  • (Array<Hash>) —

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

Desde:

  • 2.0.5



962
963
964
965
966
967
968
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 962

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

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

Retorna uma lista de objetos Mongo::Database.

Exemplos:

Obtenha uma lista de objetos Mongo::Database.

client.list_mongo_databases

Parâmetros:

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

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

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

    As opções de comando.

  • opções (Hash) —

    um conjunto personalizável de opções

Hash de opções (opts):

  • :session (Sessão) —

    A sessão a ser usada.

Retorna:

Desde:

  • 2.5.0



985
986
987
988
989
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 985

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



649
650
651
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 649

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



669
670
671
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 669

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

#read_concern ➤ Hash

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

Exemplos:

Obtenha a preocupação de leitura do cliente.

client.read_concern

Retorna:

  • (Hash) —

    A read concern.

Desde:

  • 2.6.0



846
847
848
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 846

def read_concern
  opções[:read_concern]
end

#read_preference ➤ BSON::Document

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

Exemplos:

Obtenha a read preference.

client.read_preference

Retorna:

  • (BSON::Document) —

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

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

    • :tag_sets – uma array de hashes.

    • :local_threshold.

Desde:

  • 2.0.0



729
730
731
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 729

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



659
660
661
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 659

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



897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 897

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

  @connect_lock.sincronizar fazer
    do_close salvar nada

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

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

    @closed = false
  end

  true
end

#server_selector ➤ Mongo::ServerSelector

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

Exemplos:

Obtenha o seletor de servidor.

client.server_selector

Retorna:

  • (Mongo::ServerSelector) —

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

Desde:

  • 2.5.0



707
708
709
710
711
712
713
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 707

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



1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 1010

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



693
694
695
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 693

def Resumo
  "#<Client cluster=#{cluster.resume}>"
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



796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 796

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

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

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

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

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

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

    validate_options!
    validate_authentication_options!
  end
end

#use(name) ➤ Mongo::Client

Observação:

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

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

Exemplos:

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

client.use(:users)

Parâmetros:

  • name (string, símbolo) —

    O nome do banco de dados a ser usado.

Retorna:

Desde:

  • 2.0.0



748
749
750
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 748

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

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

Observação:

Um change stream permite apenas a preocupação de leitura de "maioria".

Observação:

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

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

Exemplos:

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

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

Parâmetros:

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

    Operadores de filtro adicionais opcionais.

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

    As opções de change stream.

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

  • :full_document (string) —

    Valores permitidos: nil, 'default', 'updateLookup', 'whenAvailable', 'required'.

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

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

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

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

  • :full_document_before_change (string) —

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

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

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

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

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

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

  • :max_await_time_ms (Inteiro) —

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

  • :batch_size (Inteiro) —

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

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

    O agrupamento a ser usado.

  • :session (Sessão) —

    A sessão a ser usada.

  • :start_at_operation_time (BSON::Timestamp) —

    Retornar apenas alterações que ocorreram no momento ou após o registro de data/hora especificado. Qualquer comando executado no servidor retornará um tempo de cluster que pode ser usado aqui. Reconhecido apenas pelas versões do servidor 4.0+.

  • :comentário (Objeto) —

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

  • :show_expanded_events (Booleano) —

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

Retorna:

  • (ChangeStream) —

    O objeto de fluxo de alterações.

Desde:

  • 2.6.0



1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 1087

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[:await_data] = true 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



770
771
772
773
774
775
776
777
778
779
780
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 770

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

#with_session(opções = {}, &block) ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

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

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

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

Parâmetros:

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

    um conjunto personalizável de opções

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

  • :implicit (verdadeiro | falso) —

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

  • :session (Sessão) —

    A sessão para validar e retornar.

Desde:

  • 2.0.0



1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 1143

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

  session = get_session(opções)

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

#write_concern ➤ Mongo::WriteConcern

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

Exemplos:

Obtenha a preocupação de escrita do cliente.

client.write_concern

Retorna:

Desde:

  • 2.0.0



859
860
861
 
# File 'build/ruby-driver-v2.19/lib/mongo/client.rb', linha 859

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