Classe: Mongo::Collection

Herda:

Objeto

Objeto
Mongo::collection

mostrar tudo

Estendido por:: Encaminhável

Inclui:: Auxiliares, QueryableEncryption, Retryable

Definido em:: build/ruby-driver-v2.19/lib/mongo/collection.rb,
build/ruby-driver-v2.19/lib/mongo/collection/view.rb,
build/ruby-driver-v2.19/lib/mongo/collection/helpers.rb,
build/ruby-driver-v2.19/lib/mongo/collection/view/iterable.rb,
build/ruby-driver-v2.19/lib/mongo/collection/view/readable.rb,
build/ruby-driver-v2.19/lib/mongo/collection/view/writable.rb,
build/ruby-driver-v2.19/lib/mongo/collection/view/immutable.rb,
build/ruby-driver-v2.19/lib/mongo/collection/view/map_reduce.rb,
build/ruby-driver-v2.19/lib/mongo/collection/view/aggregation.rb,
build/ruby-driver-v2.19/lib/mongo/collection/view/explainable.rb,
build/ruby-driver-v2.19/lib/mongo/collection/view/change_stream.rb,
build/ruby-driver-v2.19/lib/mongo/collection/queryable_encryption.rb,
build/ruby-driver-v2.19/lib/mongo/collection/view/builder/map_reduce.rb,
build/ruby-driver-v2.19/lib/mongo/collection/view/builder/aggregation.rb,
build/ruby-driver-v2.19/lib/mongo/collection/view/change_stream/retryable.rb

Visão geral

Representa uma collection no banco de banco de dados e operações que podem ser aplicadas diretamente a uma.

Desde:

2.0.0

Definido sob namespace

Módulos: Auxiliares, Classes de QueryableEncryption : visualização

Colapsode resumo constante

CApped = A opção limitada. Desde: 2.1.0

'capped'.congelar

NS = A constante do campo ns. Desde: 2.1.0

'ns'.congelar

CHANGEABLE_OPTIONS = Opções que podem ser atualizadas em uma nova instância de Collection por meio do método #with. Desde: 2.1.0

[ :read, :read_concern, :write, :write_concern ].congelar

CREATE_COLLECTION_OPTIONS =

Essa constante faz parte de uma API privada. Você deve evitar usar essa constante, se possível, pois ela pode ser removida ou alterada no futuro.

Mapa de opções para transformar as opções de criação de collection.

Desde:

2.0.0

{
  :time_series => :timeseries,
  :expire_after => :expireAfterSeconds,
  :clustered_index => :clusteredIndex,
  :change_stream_pre_and_post_images => :changeStreamPreAndPostImages,
  :encrypted_fields => :encryptedFields,
  :validator => :validator,
  :view_on => :viewOn
}

Constantes incluídas de QueryableEncryption

QueryableEncryption::QE2_MIN_WIRE_VERSION

Recolhimento do Resumo do atributo de instância

#database ➤ Mongo::Database Somente leitura

O banco de dados de dados no qual a collection reside.
#name ➤ string Somente leitura

O nome da collection.
#opções ➤ Hash Somente leitura

As opções de collection.

Recolhimento do Resumo do método de instância

#==(outro) ➤ verdadeiro | false

Verifique se uma coleção é igual a outro objeto.
#agregado(pipeline, opções = {}) ➤ Visualizar::Aggregation

Realizar uma agregação na collection.
#bulk_write(requests, options = {}) ➤ BulkWrite::Result

Execute um lote de operações de gravação em massa.
#limitado? ➤ verdadeiro | false

A coleção é limitada?
#count(filter = nil, options = {}) ⇒ Inteiro obsoleto
Obsoleto.
Use #count_documents ou estimated_document_count em vez disso. No entanto, observe que os seguintes operadores precisarão ser substituídos ao mudar para #count_documents:
```
* $where should be replaced with $expr (only works on 3.6+)
* $near should be replaced with $geoWithin with $center
* $nearSphere should be replaced with $geoWithin with $centerSphere
```
#count_documents(filter = {}, options = {}) ➤ inteiro

Obtém o número de documentos correspondentes à query.
#create(opts = {}) ➤ Resultado

Forçar a criação da collection no banco de banco de dados.
#delete_many(filter = nil, options = {}) ➤ Resultado

Remover documentos da coleção.
#delete_one(filter = nil, options = {}) ➤ Resultado

Remover um documento da coleção.
#distinct(field_name, filter = nil, options = {}) ➤ Array<Object>

Obtenha uma lista de valores distintos para um campo específico .
#drop(opts = {}) ➤ Resultado

Solte a coleção.
No.

Obtém uma estimativa do número de documentos na collection usando os metadados da collection.
#encontrar(filter = nil, opções = {}) ➤ CollectionView

Encontre documentos na coleção.
#find_one_and_delete(filter, options = {}) ➤ BSON::Document^?

Localiza um único documento no banco de dados via findAndModify e o exclui, devolvendo o documento original.
#find_one_and_replace(filtro, substituição, opções = {}) ➤ BSON::Document

Localiza um único documento e o substitui, retornando o documento original, a menos que especificado de outra forma.
#find_one_and_update(filter, update, options = {}) ⇒ BSON::Document

Localiza um único documento via findAndModify e o atualiza, retornando o documento original, a menos que especificado de outra forma.
#indexes(options = {}) ⇒ Visualizar::Índice

Tenha uma visão de todos os índices dessa collection.
#initialize(banco de dados, name, options = {}) ➤ Collection construtor

Instanciar uma nova collection.
#insert_many(documents, options = {}) ⇒ Result

Insira os documentos fornecidos na coleção.
#insert_one(documento, opts = {}) ➤ Resultado

Insira um único documento na coleção.
#inspecionar ➤ string

Obtenha uma inspeção de string bem impressa para a coleção.
#namespace ➤ string

Obtenha o namespace totalmente qualificado da coleção.
#parallel_scan(cursor_count, options = {}) ➤ Array<Cursor>

Execute uma verificação paralela na visualização da collection.
#read_concern ➤ Hash

Obtenha a preocupação de leitura efetiva para esta instância de coleção.
#read_preference ➤ Hash

Obtenha a preferência de leitura efetiva para esta coleção.
#replace_one(filtro, substituição, opções = {}) ➤ Resultado

Substitui um único documento na coleção pelo novo documento.
#server_selector ➤ Mongo::ServerSelector

Obtenha o seletor de servidor para esta collection.
#system_collection? ➤ Booleano privado

Se a collection é uma collection de sistema.
#update_many(filter, update, options = {}) ⇒ Result

Atualizar documentos na coleção.
#update_one(filter, update, options = {}) ⇒ Result

Atualizar um único documento na coleção.
#watch(pipeline = [], options = {}) ➤ ChangeStream

A partir da versão 3.6 do servidor MongoDB, um estágio de pipeline "$changeStream" é suportado no framework de aggregation.
#com(new_options) ➤ Mongo::Collection

Uma nova instância de coleção.
#write_concern ➤ Mongo::WriteConcern

Obtenha a preocupação de escrita eficaz nesta coleção.
#write_concern_with_session(session) ➤ Mongo::WriteConcern privado

Obtenha a preocupação de gravação a ser usada para uma operação nessa coleção, dada uma sessão.

Detalhes do construtor

#initialize(banco de dados, name, options = {}) ➤ `Collection`

Instanciar uma nova collection.

Exemplos:

Instanciar uma nova collection.

Mongo::Collection.new(database, 'test')

Parâmetros:

database (Mongo::Database) —

O banco de banco de dados da coleção.
name (string, símbolo) —

O nome da collection.
opções (Hash) (padrão para: {}) —

As opções de collection.
opciona (Hash) —

um conjunto personalizável de opções

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

:read_concern (Hash) —
O hash de opções de preocupação de leitura , com as seguintes chaves opcionais:
- :level – o nível de preferência de leitura como um símbolo; valores válidos
```
are *:local*, *:majority*, and *:snapshot*
```
: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.

Aumenta:

(Erro::InvalidCollectionName)

Desde:

2.0.0

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 158

def inicializar(database, name, opções = {})
  aumentar Erro::InvalidCollectionName.Novo a menos que name
  se opções[:write] && opções[:write_concern] && opções[:write] != opções[:write_concern]
    aumentar ArgumentError, "Se :write e :write_concern forem fornecidos, eles devem ser idênticos: #{options.inspect}"
  end
  @database = database
  @name = name.to_s.congelar
  @opções = opções.dup
=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
end

Detalhes do atributo da instância

#database ➤ `Mongo::Database` (readonly)

Retorna o banco de dados de dados em que a collection reside.

Retorna:

(Mongo::Database) —

O banco de dados de dados no qual a collection reside.

Desde:

2.0.0



46
47
48

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 46

def database
  @database
end

#name ➤ `string` (somente leitura)

Retorna O nome da coleção.

Retorna:

(string) —

O nome da collection.

Desde:

2.0.0



49
50
51

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 49

def name
  @name
end

#opções ➤ `Hash` (somente leitura)

Retorna as opções de collection.

Retorna:

(Hash) —

As opções de collection.

Desde:

2.0.0



52
53
54

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 52

def opções
  @opções
end

Detalhes do método de instância

#==(outro) ➤ `verdadeiro | false`

Verifique se uma coleção é igual a outro objeto. Verificará o nome e o banco de dados de dados quanto à igualdade.

Exemplos:

Verifique a igualdade da coleção.

collection == other

Parâmetros:

Outro (Objeto) —

O objeto a ser verificado.

Retorna:

(verdadeiro | falso) —

Se os objetos forem iguais.

Desde:

2.0.0

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 89

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

#agregado(pipeline, opções = {}) ➤ `Visualizar::Aggregation`

Realizar uma agregação na collection.

Exemplos:

Execute uma agregação.

collection.aggregate([ { "$group" => { "_id" => "$city", "tpop" => { "$sum" => "$pop" }}} ])

Parâmetros:

gasoduto (Array<Hash>) —

O pipeline de agregação .
opções (Hash) (padrão para: {}) —

As opções de aggregation.

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

:allow_disk_use (verdadeiro | falso) —

Defina como verdadeiro se o uso do disco for permitido durante a agregação.
:batch_size (Inteiro) —

O número de documentos a serem devolvidos por lote.
:bypass_document_validation (verdadeiro | falso) —

Se deve ou não ignorar a validação em nível de documento .
:collation (Hash) —

O agrupamento a ser usado.
:comentário (Objeto) —

Um comentário fornecido pelo usuário para anexar a este comando.
:hint (string) —

O índice a ser usado para a agregação.
:let (Hash) —

Mapeamento de variáveis a serem usadas no pipeline. Consulte a documentação do servidor para obter detalhes.
:max_time_ms (Inteiro) —

A quantidade máxima de tempo em milissegundos para permitir a execução da agregação .
:use_cursor (verdadeiro | falso) —

Indica se o comando solicitará que o servidor forneça resultados usando um cursor. Observe que, a partir da versão do servidor 3.6, as aggregations sempre fornecem resultados usando um cursor e, portanto, essa opção não é válida.
:session (Sessão) —

A sessão a ser usada.

Retorna:

(Visualizar::Aggregation) —

O objeto de agregação .

Desde:

2.1.0



536
537
538

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 536

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

#bulk_write(requests, options = {}) `➤ BulkWrite::Result`

Execute um lote de operações de gravação em massa.

Exemplos:

Execute uma escrita em massa.

collection.bulk_write(operations, options)

Parâmetros:

pedidos (Enumerable<Hash>) —

As solicitações de escrita em massa.
opções (Hash) (padrão para: {}) —

As opções.

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

:ordered (verdadeiro | falso) —

Se as operações devem ser executadas em ordem.
:write_concern (Hash) —

As opções de preocupação de gravação . Pode ser :w => Inteiro, : fsync => Booleano, :j => Booleano.
:bypass_document_validation (verdadeiro | falso) —

Se deve ou não ignorar a validação em nível de documento .
:session (Sessão) —

A sessão a ser usada para o conjunto de operações.
:let (Hash) —

Mapeamento de variáveis a serem usadas no comando. Consulte a documentação do servidor para obter detalhes.

Retorna:

(BulkWrite::Result) —

O resultado da operação.

Desde:

2.0.0



845
846
847

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 845

def bulk_write(pedidos, opções = {})
  Gravação em massa.Novo(auto, pedidos, opções).executar, executar
end

#limitado? ➤ `verdadeiro | false`

A collection é limitada?

Exemplos:

A collection é limitada?

collection.capped?

Retorna:

(verdadeiro | falso) —

Se a coleção for limitada.

Desde:

2.0.0



316
317
318

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 316

def limitado?
  database.read_command(:collstats => name).documentos[0][CApped]
end

#count(filter = nil, options = {}) ⇒ `Inteiro`

Obsoleto.

Use #count_documents ou estimated_document_count em vez disso. No entanto, observe que os seguintes operadores precisarão ser substituídos ao mudar para #count_documents:

* $where should be replaced with $expr (only works on 3.6+)
* $near should be replaced with $geoWithin with $center
* $nearSphere should be replaced with $geoWithin with $centerSphere

Obtém um número estimado de documentos correspondentes na collection.

Exemplos:

Faça a contagem.

collection.count(name: 1)

Parâmetros:

filtro, filtro (Hash) (padrão para: nil) —

Um filtro para documentos correspondentes.
opções (Hash) (padrão para: {}) —

As opções de contagem.

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

:hint (Hash) —

O índice a ser utilizado.
:limit (Inteiro) —

O número máximo de documentos a contar.
:max_time_ms (Inteiro) —

A quantidade máxima de tempo para permitir a execução do comando.
:skip (Inteiro) —

O número de documentos a ignorar antes de contar.
:read (Hash) —

As opções de preferência de leitura .
:collation (Hash) —

O agrupamento a ser usado.
: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:

(Inteiro) —

A contagem de documento .

Desde:

2.1.0



640
641
642

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 640

def contar(filtro, filtro = nada, opções = {})
  Vista.Novo(auto, filtro, filtro || {}, opções).contar(opções)
end

#count_documents(filter = {}, options = {}) ➤ `inteiro`

Obtém o número de documentos correspondentes à query. Ao contrário do método #count obsoleto, isso retornará o número exato de documentos que correspondem ao filtro (ou o número exato de documentos na coleção, se nenhum filtro for fornecido) em vez de uma estimativa.

Use #estimated_document_count para recuperar uma estimativa do número de documentos na coleção usando os metadados da coleção.

Parâmetros:

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

Um filtro para documentos correspondentes.
opções (Hash) (padrão para: {}) —

Opções para a operação.

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

:skip (Inteiro) —

O número de documentos a ignorar.
:hint (Hash) —

Substituir seleção de índice padrão e forçar o MongoDB a usar um índice específico para a query. Requer versão do servidor 3.6+.
:limit (Inteiro) —

Número máximo de Docs para contar.
:max_time_ms (Inteiro) —

A quantidade máxima de tempo para permitir a execução do comando.
:read (Hash) —

As opções de preferência de leitura .
:collation (Hash) —

O agrupamento a ser usado.
: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:

(Inteiro) —

A contagem de documento .

Desde:

2.6.0



670
671
672

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

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

#create(opts = {}) ➤ `Resultado`

Forçar a criação da collection no banco de banco de dados.

Exemplos:

Forçar a criação da collection.

collection.create

Parâmetros:

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

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

Hash de opções (opts):

:capped (verdadeiro | falso) —

Crie uma collection de tamanho fixo.
:change_stream_pre_and_post_images (Hash) —
Usado para habilitar pré e pós-imagens na coleção criada. O hash pode ter os seguintes itens:
- :enabled – verdadeiro ou falso.
:clustered_index (Hash) —
Crie um índice clusterizado. Esta opção especifica como esta coleção deve ser agrupada em _id. O hash pode ter os seguintes itens:
- :key – O campo-chave do índice clusterizado. Deve ser definido como { _id: 1 }.
- :unique – Deve ser definido como verdadeiro. A collection não aceitará documentos inseridos nem atualizados em que o valor da chave de índice clusterizado corresponda a um valor existente no índice.
- :name – Opcional. Um nome que identifica exclusivamente o índice clusterizado.
:collation (Hash) —

O agrupamento a ser usado.
:encrypted_fields (Hash) —

Hash que descreve campos criptografados para Queryable Encryption.
:expire_after (Inteiro) —

Número que indica após quantos segundos os dados da série temporal devem ser excluídos.
:max (Inteiro) —

O número máximo de documentos em uma collection limitada. O limite de tamanho tem precedência sobre o máximo.
:pipeline (Array<Hash>) —

Uma array de estágios do pipeline. Uma visualização será criada aplicando este pipeline à collection ou visualização view_on.
:session (Sessão) —

A sessão a ser usada para a operação.
:size (Inteiro) —

O tamanho da collection limitada.
:time_series (Hash) —
Crie uma coleção de séries temporais. O hash pode ter os seguintes itens:
- :timeField – O nome do campo que contém a data em cada documento de série temporal.
- :metaField – O nome do campo que contém metadados em cada documento de série temporal.
- :granularity – Defina a granularidade para o valor que é a correspondência mais próxima do intervalo de tempo entre as medições de entrada consecutivas. Os valores possíveis são "segundos" (padrão), "minutos" e "horas".
:validator (Hash) —

Hash descrevendo as opções de validação do documento para a coleção.
:view_on (string) —

O nome da coleção de origem ou visualização a partir da qual criar uma visualização.
:write (Hash) —

Obsoleto. Equivalente à opção :write_concern.
:write_concern (Hash) —

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

Retorna:

(Resultado) —

O resultado do comando.

Desde:

2.0.0

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 373

def criar(opciona = {})
  # Passar opções de leitura para criar um comando faz com que ele seja interrompido.
  # Filtre as opções de leitura. A sessão também é excluída aqui, pois fica
  # usado pela chamada para with_session e não deve fazer parte do
  # operação. Se for passado para a operação, falhará BSON
  # serialização.
  # TODO coloca a lista de opções de leitura em uma constante de nível de classe quando
  # descobrirmos qual é o conjunto completo deles.
  opções = Hash[auto.opções.mesclar(opciona).rejeitar fazer |chave, valor|
    %w(ler read_preference read_concern session).incluir?(chave.to_s)
  end]
  # Convertendo opções Ruby para estilo de servidor .
  CREATE_COLLECTION_OPTIONS.cada fazer |ruby_key, server_key|
    se opções.chave?(ruby_key)
      opções[server_key] = opções.excluir(ruby_key)
    end
  end
  operação = { :create => name }.mesclar(opções)
  operação.excluir(:write)
  operação.excluir(:write_concern)
  Cliente.enviar(:with_session, opciona) fazer |session|
    write_concern = se opciona[:write_concern]
      Escreva preocupação.obter(opciona[:write_concern])
    mais
      auto.write_concern
    end

    Contexto = (operação)::Contexto.Novo(cliente: Cliente, sessão: session)
    talvez_create_qe_collections(opciona[:encrypted_fields], Cliente, session) fazer |campos_criptografados|
      (operação)::criar.Novo(
        seletor: operação,
        db_name: database.name,
        write_concern: write_concern,
        sessão: session,
        # Observe que essas são opções de collection e o agrupamento não é
        # retirado das opções passadas para o método de criação.
        agrupamento: opções[:collation] || opções['agrupamento'],
        encryption_fields: campos_criptografados,
        validator: opções[:validator],
      ).executar, executar(próximo_primary(nada, session), contexto: Contexto)
    end
  end
end

#delete_many(filter = nil, options = {}) ➤ `Resultado`

Remover documentos da coleção.

Exemplos:

Remover vários documentos da coleção.

collection.delete_many

Parâmetros:

filtro, filtro (Hash) (padrão para: nil) —

O filtro a ser usado.
opções (Hash) (padrão para: {}) —

As opções.

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

:collation (Hash) —

O agrupamento a ser usado.
:session (Sessão) —

A sessão a ser usada.
:hint (Hash | string) —

O índice a ser usado para essa operação. Pode ser especificado como um Hash (por exemplo { _id: 1 }) ou uma string (por exemplo "ID ").
:let (Hash) —

Mapeamento de variáveis a serem usadas no comando. Consulte a documentação do servidor para obter detalhes.

Retorna:

(Resultado) —

A resposta do banco de banco de dados.

Desde:

2.1.0



889
890
891

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 889

def delete_many(filtro, filtro = nada, opções = {})
  find(filtro, filtro, opções).delete_many(opções)
end

#delete_one(filter = nil, options = {}) ➤ `Resultado`

Remover um documento da coleção.

Exemplos:

Remova um único documento da coleção.

collection.delete_one

Parâmetros:

filtro, filtro (Hash) (padrão para: nil) —

O filtro a ser usado.
opções (Hash) (padrão para: {}) —

As opções.

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

:collation (Hash) —

O agrupamento a ser usado.
:session (Sessão) —

A sessão a ser usada.
:hint (Hash | string) —

O índice a ser usado para essa operação. Pode ser especificado como um Hash (por exemplo { _id: 1 }) ou uma string (por exemplo "ID ").
:let (Hash) —

Mapeamento de variáveis a serem usadas no comando. Consulte a documentação do servidor para obter detalhes.

Retorna:

(Resultado) —

A resposta do banco de banco de dados.

Desde:

2.1.0



867
868
869

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 867

def delete_one(filtro, filtro = nada, opções = {})
  find(filtro, filtro, opções).delete_one(opções)
end

#distinct(field_name, filter = nil, options = {}) ➤ `Array<Object>`

Obtenha uma lista de valores distintos para um campo específico .

Exemplos:

Obtenha os valores distintos.

collection.distinct('name')

Parâmetros:

field_name (Símbolo, string) —

O nome do campo.
filtro, filtro (Hash) (padrão para: nil) —

Os documentos a partir dos quais recuperar os valores distintos.
opções (Hash) (padrão para: {}) —

As distintas opções de comando.

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

:max_time_ms (Inteiro) —

A quantidade máxima de tempo para permitir a execução do comando.
:read (Hash) —

As opções de preferência de leitura .
:collation (Hash) —

O agrupamento a ser usado.
:session (Sessão) —

A sessão a ser usada.

Retorna:

(Array<Object>) —

A lista de valores distintos.

Desde:

2.1.0



712
713
714

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 712

def distinto(field_name, filtro, filtro = nada, opções = {})
  Vista.Novo(auto, filtro, filtro || {}, opções).distinto(field_name, opções)
end

#drop(opts = {}) ➤ `Resultado`

Observação:

Um erro retornado se a coleção não existir será suprimido.

Solte a coleção. Também eliminará todos os índices associados à coleção, bem como as coleções de Queryable Encryption associadas.

Exemplos:

Solte a coleção.

collection.drop

Parâmetros:

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

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

Hash de opções (opts):

:session (Sessão) —

A sessão a ser usada para a operação.
:write_concern (Hash) —

As opções de preocupação de gravação .
:encrypted_fields (Hash | nulo) —

Hash de campos criptografados que foi fornecido para o assistente de coleção 'create'.

Retorna:

(Resultado) —

O resultado do comando.

Desde:

2.0.0

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 435

def derrubar(opciona = {})
  Cliente.enviar(:with_session, opciona) fazer |session|
    talvez_drop_emm_coleções(opciona[:encrypted_fields], Cliente, session) fazer
      temp_write_concern = write_concern
      write_concern = se opciona[:write_concern]
        Escreva preocupação.obter(opciona[:write_concern])
      mais
        temp_write_concern
      end
      Contexto = (operação)::Contexto.Novo(cliente: Cliente, sessão: session)
      operação = (operação)::descartar.Novo({
        seletor: { :drop => name },
        db_name: database.name,
        write_concern: write_concern,
        sessão: session,
      })
      do_drop(operação, session, Contexto)
    end
  end
end

No.

Obtém uma estimativa do número de documentos na collection usando os metadados da collection.

Use #count_documents para recuperar o número exato de documentos na coleta ou para contar documentos correspondentes a um filtro.

Parâmetros:

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

Opções para a operação.

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

:max_time_ms (Inteiro) —

A quantidade máxima de tempo para permitir que o comando seja executado no servidor.
:read (Hash) —

As opções de preferência de leitura .
:comentário (Objeto) —

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

Retorna:

(Inteiro) —

A contagem de documento .

Desde:

2.6.0



691
692
693

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 691

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

#encontrar(filter = nil, opções = {}) ➤ `CollectionView`

Encontre documentos na coleção.

Exemplos:

Encontre documentos na coleção por um seletor.

collection.find(name: 1)

Obtenha todos os documentos em uma coleção.

collection.find

Parâmetros:

filtro, filtro (Hash) (padrão para: nil) —

O filtro a ser usado no find.
opções (Hash) (padrão para: {}) —

As opções para a descoberta.

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

:allow_disk_use (verdadeiro | falso) —

When set to true, the server can write temporary data to disk while executing the find operation. Esta opção só está disponível nas versões 4.4 e mais recentes do MongoDB Server.
:allow_partial_results (verdadeiro | falso) —

Permite que a query obtenha resultados parciais se alguns shards estiverem inativos.
:batch_size (Inteiro) —

O número de documentos retornados em cada lote de resultados do MongoDB.
:collation (Hash) —

O agrupamento a ser usado.
:comentário (Objeto) —

Um comentário fornecido pelo usuário para anexar a este comando.
:cursor_type (:tailable, :tailable_await) —

O tipo de cursor a ser usado.
:limit (Inteiro) —

O número máximo de Docs a retornar da consulta.
:max_time_ms (Inteiro) —

A quantidade máxima de tempo para permitir a execução da query, em milissegundos.
:modifiers (Hash) —

Um documento contendo meta-operadores modificando a saída ou comportamento de uma query.
:no_cursor_timeout (verdadeiro | falso) —

O servidor normalmente atinge o tempo limite dos cursores ociosos após um período de inatividade (10 minutos) para evitar o uso excessivo de memória. Defina esta opção para evitar isso.
:oplog_replay (verdadeiro | falso) —

Somente para uso de replicação interna, os aplicativos não devem definir essa opção.
:projection (Hash) —

Os campos a incluir ou excluir de cada documento no conjunto de resultados.
:session (Sessão) —

A sessão a ser usada.
:skip (Inteiro) —

O número de Docs a ignorar antes de retornar os resultados.
:sort (Hash) —

Os pares de chave e direção pelos quais o conjunto de resultados será classificado.
:let (Hash) —

Mapeamento de variáveis a serem usadas no comando. Consulte a documentação do servidor para obter detalhes.

Retorna:

(CollectionView) —

A visualização da collection.

Desde:

2.0.0



501
502
503

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 501

def find(filtro, filtro = nada, opções = {})
  Vista.Novo(auto, filtro, filtro || {}, opções)
end

#find_one_and_delete(filter, options = {}) ➤ `BSON::Document`^?

Localiza um único documento no banco de dados via findAndModify e o exclui, devolvendo o documento original.

Exemplos:

Encontre um documento e exclua-o.

collection.find_one_and_delete(name: 'test')

Parâmetros:

filtro, filtro (Hash) —

O filtro a ser usado.
opções (Hash) (padrão para: {}) —

As opções.

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

:max_time_ms (Inteiro) —

A quantidade máxima de tempo para permitir que o comando seja executado em milissegundos.
:projection (Hash) —

Os campos a serem incluídos ou excluídos no documento retornado.
:sort (Hash) —

Os pares de chave e direção pelos quais o conjunto de resultados será classificado.
:write_concern (Hash) —

As opções de write concern. O padrão é a preocupação de escrita da coleção.
:collation (Hash) —

O agrupamento a ser usado.
:session (Sessão) —

A sessão a ser usada.
:hint (Hash | string) —

O índice a ser usado para essa operação. Pode ser especificado como um Hash (por exemplo { _id: 1 }) ou uma string (por exemplo "ID ").
:let (Hash) —

Mapeamento de variáveis a serem usadas no comando. Consulte a documentação do servidor para obter detalhes.

Retorna:

(BSON::Document, nil) —

O documento, se encontrado.

Desde:

2.1.0



1027
1028
1029

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 1027

def find_one_and_delete(filtro, filtro, opções = {})
  find(filtro, filtro, opções).find_one_and_delete(opções)
end

#find_one_and_replace(filtro, substituição, opções = {}) ➤ `BSON::Document`

Localiza um único documento e o substitui, retornando o documento original, a menos que especificado de outra forma.

Exemplos:

Encontre um documento e substitua-o, devolvendo o original.

collection.find_one_and_replace({ name: 'test' }, { name: 'test1' })

Encontre um documento e substitua-o, retornando o novo documento.

collection.find_one_and_replace({ name: 'test' }, { name: 'test1' }, :return_document => :after)

Parâmetros:

filtro, filtro (Hash) —

O filtro a ser usado.
substituição (BSON::Document) —

O documento de substituição.
opções (Hash) (padrão para: {}) —

As opções.

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

:max_time_ms (Inteiro) —

A quantidade máxima de tempo para permitir que o comando seja executado em milissegundos.
:projection (Hash) —

Os campos a serem incluídos ou excluídos no documento retornado.
:sort (Hash) —

Os pares de chave e direção pelos quais o conjunto de resultados será classificado.
:return_document (Símbolo) —

:before ou :after.
:upsert (verdadeiro | falso) —

Se deve ser atualizado se o documento não existe.
:bypass_document_validation (verdadeiro | falso) —

Se deve ou não ignorar a validação em nível de documento .
:write_concern (Hash) —

As opções de write concern. O padrão é a preocupação de escrita da coleção.
:collation (Hash) —

O agrupamento a ser usado.
:session (Sessão) —

A sessão a ser usada.
:hint (Hash | string) —

O índice a ser usado para essa operação. Pode ser especificado como um Hash (por exemplo { _id: 1 }) ou uma string (por exemplo "ID ").
:let (Hash) —

Mapeamento de variáveis a serem usadas no comando. Consulte a documentação do servidor para obter detalhes.

Retorna:

(BSON::Document) —

O documento.

Desde:

2.1.0



1105
1106
1107

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 1105

def find_one_and_replace(filtro, filtro, substituição, opções = {})
  find(filtro, filtro, opções).find_one_and_update(substituição, opções)
end

#find_one_and_update(filter, update, options = {}) ➤ `BSON::Document`

Localiza um único documento via findAndModify e o atualiza, retornando o documento original, a menos que especificado de outra forma.

Exemplos:

Encontre um documento e atualize-o, devolvendo o original.

collection.find_one_and_update({ name: 'test' }, { "$set" => { name: 'test1' }})

Encontre um documento e atualize-o, retornando o documento atualizado.

collection.find_one_and_update({ name: 'test' }, { "$set" => { name: 'test1' }}, :return_document => :after)

Parâmetros:

filtro, filtro (Hash) —

O filtro a ser usado.
update (Hash | Array<Hash>) —

O documento ou pipeline de atualização.
opções (Hash) (padrão para: {}) —

As opções.

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

:max_time_ms (Inteiro) —

A quantidade máxima de tempo para permitir que o comando seja executado em milissegundos.
:projection (Hash) —

Os campos a serem incluídos ou excluídos no documento retornado.
:sort (Hash) —

Os pares de chave e direção pelos quais o conjunto de resultados será classificado.
:return_document (Símbolo) —

:before ou :after.
:upsert (verdadeiro | falso) —

Se deve ser atualizado se o documento não existe.
:bypass_document_validation (verdadeiro | falso) —

Se deve ou não ignorar a validação em nível de documento .
:write_concern (Hash) —

As opções de write concern. O padrão é a preocupação de escrita da coleção.
:collation (Hash) —

O agrupamento a ser usado.
:array_filters (Array) —

Um conjunto de filtros que especificam a quais elementos da array uma atualização deve ser aplicada.
:session (Sessão) —

A sessão a ser usada.
:hint (Hash | string) —

O índice a ser usado para essa operação. Pode ser especificado como um Hash (por exemplo { _id: 1 }) ou uma string (por exemplo "ID ").
:let (Hash) —

Mapeamento de variáveis a serem usadas no comando. Consulte a documentação do servidor para obter detalhes.

Retorna:

(BSON::Document) —

O documento.

Desde:

2.1.0



1067
1068
1069

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 1067

def find_one_and_update(filtro, filtro, update, opções = {})
  find(filtro, filtro, opções).find_one_and_update(update, opções)
end

#indexes(options = {}) ⇒ `View::Index`

Tenha uma visão de todos os índices dessa collection. Pode ser iterado ou tem mais operações.

Exemplos:

Obtenha a visualização do índice.

collection.indexes

Parâmetros:

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

Opções para obter uma lista de todos os índices.

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

:session (Sessão) —

A sessão a ser usada.

Retorna:

(Visualizar::Índice) —

A visualização do índice.

Desde:

2.0.0



729
730
731

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

def Índices(opções = {})
  Index::Vista.Novo(auto, opções)
end

#insert_many(documents, options = {}) ⇒ `Result`

Insira os documentos fornecidos na coleção.

Exemplos:

Insira documento na collection.

collection.insert_many([{ name: 'test' }])

Parâmetros:

documentos (Enumerable<Hash>) —

Os documentos a inserir.
opções (Hash) (padrão para: {}) —

As opções de inserção.

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

:bypass_document_validation (verdadeiro | falso) —

Se deve ou não ignorar a validação em nível de documento .
:comentário (Objeto) —

Um comentário fornecido pelo usuário para anexar a este comando.
:ordered (verdadeiro | falso) —

Se as operações devem ser executadas em ordem.
:session (Sessão) —

A sessão a ser usada para a operação.
:write_concern (Hash) —

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

Retorna:

(Resultado) —

O wrapper de resposta do banco de dados de dados.

Desde:

2.0.0

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 817

def insert_many(documentos, opções = {})
  Cache de consulta.clear_namespace(namespace)

  Inserções = documentos.map{ |doc| { :insert_one => doc }}
  bulk_write(Inserções, opções)
end

#insert_one(documento, opts = {}) ➤ `Resultado`

Insira um único documento na coleção.

Exemplos:

Inserir um documento na coleção.

collection.insert_one({ name: 'test' })

Parâmetros:

documento (Hash) —

O documento a inserir.
opciona (Hash) (padrão para: {}) —

As opções de inserção.

Hash de opções (opts):

:bypass_document_validation (verdadeiro | falso) —

Se deve ou não ignorar a validação em nível de documento .
:comentário (Objeto) —

Um comentário fornecido pelo usuário para anexar a este comando.
:session (Sessão) —

A sessão a ser usada para a operação.
:write_concern (Hash) —

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

Retorna:

(Resultado) —

O wrapper de resposta do banco de dados de dados.

Desde:

2.0.0

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 764

def insert_one(documento, opciona = {})
  Cache de consulta.clear_namespace(namespace)

  Cliente.enviar(:with_session, opciona) fazer |session|
    write_concern = se opciona[:write_concern]
      Escreva preocupação.obter(opciona[:write_concern])
    mais
      write_concern_with_session(session)
    end

    se documento.nada?
      aumentar ArgumentError, "O documento a ser inserido não pode ser nulo"
    end

    Contexto = (operação)::Contexto.Novo(cliente: Cliente, sessão: session)
    write_with_retry(write_concern, contexto: Contexto) fazer |Conexão, txn_num, Contexto|
      (operação)::Insert.Novo(
        :documents => [ documento ],
        :db_name => database.name,
        :coll_name => name,
        :write_concern => write_concern,
        :bypass_document_validation => !!opciona[:bypass_document_validation],
        :opções => opciona,
        :id_generator => Cliente.opções[:id_generator],
        :session => session,
        :txn_num => txn_num,
        :comentário => opciona[:comentário]
      ).execute_with_connection(Conexão, contexto: Contexto)
    end
  end
end

#inspecionar ➤ `string`

Obtenha uma inspeção de string bem impressa para a coleção.

Exemplos:

Inspecione a coleção.

collection.inspect

Retorna:

(string) —

A inspeção da collection.

Desde:

2.0.0



741
742
743

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 741

def inspecionar
  "#<Mongo::Collection:0x#{object_id} namespace=#{namespace}>"
end

#namespace ➤ `string`

Obtenha o namespace totalmente qualificado da coleção.

Exemplos:

Obtenha o namespace totalmente qualificado .

collection.namespace

Retorna:

(string) —

O namespace da collection.

Desde:

2.0.0



1117
1118
1119

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 1117

def namespace
  "#{banco de dados.name}.#{name}"
end

#parallel_scan(cursor_count, options = {}) ➤ `Array<Cursor>`

Execute uma verificação paralela na visualização da collection.

Retorna uma lista de até cursor_count cursores que podem ser iterados simultaneamente. Desde que a coleção não seja modificada durante a digitalização, cada documento aparece uma vez em um dos conjuntos de resultados dos cursores.

Exemplos:

Execute uma varredura de coleção paralela.

collection.parallel_scan(2)

Parâmetros:

cursor_count (Inteiro) —

O número máximo de cursores a serem retornados.
opções (Hash) (padrão para: {}) —

As opções de comando de varredura paralela.

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

:max_time_ms (Inteiro) —

A quantidade máxima de tempo para permitir que o comando seja executado em milissegundos.
:session (Sessão) —

A sessão a ser usada.

Retorna:

(Array <Cursor>) —

Uma array de cursores.

Desde:



912
913
914

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 912

def parallel_scan(cursor_count, opções = {})
  find({}, opções).enviar(:parallel_scan, cursor_count, opções)
end

#read_concern ➤ `Hash`

Obtenha a preocupação de leitura efetiva para esta instância de coleção.

Se uma read concern for fornecida nas opções de collection, essa read concern será retornada, caso contrário, a read concern efetiva do banco de dados será retornada.

Exemplos:

Obtenha a preocupação de leitura.

collection.read_concern

Retorna:

(Hash) —

A read concern.

Desde:

2.2.0



188
189
190

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 188

def read_concern
  opções[:read_concern] || database.read_concern
end

#read_preference ➤ `Hash`

Obtenha a preferência de leitura efetiva para esta coleção.

Se uma preferência de leitura foi fornecida nas opções de coleta, essa preferência de leitura será retornada, caso contrário, a preferência de leitura efetiva do banco de dados será retornada.

Exemplos:

Obtenha a read preference.

collection.read_preference

Retorna:

(Hash) —

A preferência de leitura.

Desde:

2.0.0



216
217
218

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 216

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

#replace_one(filtro, substituição, opções = {}) ➤ `Resultado`

Substitui um único documento na coleção pelo novo documento.

Exemplos:

Substitui um único documento.

collection.replace_one({ name: 'test' }, { name: 'test1' })

Parâmetros:

filtro, filtro (Hash) —

O filtro a ser usado.
substituição (Hash) —

O documento de substituição ..
opções (Hash) (padrão para: {}) —

As opções.

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

:upsert (verdadeiro | falso) —

Se deve ser atualizado se o documento não existe.
:bypass_document_validation (verdadeiro | falso) —

Se deve ou não ignorar a validação em nível de documento .
:collation (Hash) —

O agrupamento a ser usado.
:session (Sessão) —

A sessão a ser usada.
:hint (Hash | string) —

O índice a ser usado para essa operação. Pode ser especificado como um Hash (por exemplo { _id: 1 }) ou uma string (por exemplo "ID ").
:let (Hash) —

Mapeamento de variáveis a serem usadas no comando. Consulte a documentação do servidor para obter detalhes.

Retorna:

(Resultado) —

A resposta do banco de banco de dados.

Desde:

2.1.0



939
940
941

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 939

def replace_one(filtro, filtro, substituição, opções = {})
  find(filtro, filtro, opções).replace_one(substituição, opções)
end

#server_selector ➤ `Mongo::ServerSelector`

Obtenha o seletor de servidor para esta collection.

Exemplos:

Obtenha o seletor de servidor.

collection.server_selector

Retorna:

(Mongo::ServerSelector) —

O seletor de servidor.

Desde:

2.0.0



200
201
202

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 200

def server_selector
  @server_selector ||= ServerSelector.obter(read_preference || database.server_selector)
end

#system_collection? ➤ `Booleano`

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.

Se a collection é uma collection de sistema.

Retorna:

(Booleano) —

Se o sistema é uma collection de sistema.

Desde:

2.0.0



1126
1127
1128

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 1126

def system_collection?
  name.start_with?('.')
end

#update_many(filter, update, options = {}) ⇒ `Result`

Atualizar documentos na coleção.

Exemplos:

Atualizar vários documentos na coleção.

collection.update_many({ name: 'test'}, '$set' => { name: 'test1' })

Parâmetros:

filtro, filtro (Hash) —

O filtro a ser usado.
update (Hash | Array<Hash>) —

O documento ou pipeline de atualização.
opções (Hash) (padrão para: {}) —

As opções.

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

:upsert (verdadeiro | falso) —

Se deve ser atualizado se o documento não existe.
:bypass_document_validation (verdadeiro | falso) —

Se deve ou não ignorar a validação em nível de documento .
:collation (Hash) —

O agrupamento a ser usado.
:array_filters (Array) —

Um conjunto de filtros que especificam a quais elementos da array uma atualização deve ser aplicada.
:session (Sessão) —

A sessão a ser usada.
:hint (Hash | string) —

O índice a ser usado para essa operação. Pode ser especificado como um Hash (por exemplo { _id: 1 }) ou uma string (por exemplo "ID ").
:let (Hash) —

Mapeamento de variáveis a serem usadas no comando. Consulte a documentação do servidor para obter detalhes.

Retorna:

(Resultado) —

A resposta do banco de banco de dados.

Desde:

2.1.0



968
969
970

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 968

def update_many(filtro, filtro, update, opções = {})
  find(filtro, filtro, opções).update_many(update, opções)
end

#update_one(filter, update, options = {}) ⇒ `Result`

Atualizar um único documento na coleção.

Exemplos:

Atualizar um único documento na coleção.

collection.update_one({ name: 'test'}, '$set' => { name: 'test1'})

Parâmetros:

filtro, filtro (Hash) —

O filtro a ser usado.
update (Hash | Array<Hash>) —

O documento ou pipeline de atualização.
opções (Hash) (padrão para: {}) —

As opções.

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

:upsert (verdadeiro | falso) —

Se deve ser atualizado se o documento não existe.
:bypass_document_validation (verdadeiro | falso) —

Se deve ou não ignorar a validação em nível de documento .
:collation (Hash) —

O agrupamento a ser usado.
:array_filters (Array) —

Um conjunto de filtros que especificam a quais elementos da array uma atualização deve ser aplicada.
:session (Sessão) —

A sessão a ser usada.
:hint (Hash | string) —

O índice a ser usado para essa operação. Pode ser especificado como um Hash (por exemplo { _id: 1 }) ou uma string (por exemplo "ID ").
:let (Hash) —

Mapeamento de variáveis a serem usadas no comando. Consulte a documentação do servidor para obter detalhes.

Retorna:

(Resultado) —

A resposta do banco de banco de dados.

Desde:

2.1.0



997
998
999

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 997

def update_one(filtro, filtro, update, opções = {})
  find(filtro, filtro, opções).update_one(update, opções)
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. Este estágio permite que os usuários solicitem o envio de notificações para todas as alterações em uma coleção específica.

Exemplos:

Receba notificações de alteração para uma determinada collection.

collection.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.5.0

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 607

def assistir(gasoduto = [], opções = {})
  view_options = opções.dup
  view_options[:await_data] = true se opções[:max_await_time_ms]
  Vista::Change stream.Novo(Vista.Novo(auto, {}, view_options), gasoduto, nada, opções)
end

#com(new_options) ➤ `Mongo::Collection`

Retorna Uma nova instância de coleção.

Exemplos:

Obtenha uma coleção com uma preocupação de leitura alterada.

collection.with(read_concern: { level: :majority })

Obtenha uma collection com uma preocupação de gravação alterada.

collection.with(write_concern: { w:  3 })

Parâmetros:

new_options (Hash) —

As novas opções a serem usadas.

Opções de hash (new_options):

: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) —
O hash de opções de preocupação de leitura , com as seguintes chaves opcionais:
- :level – o nível de preferência de leitura como um símbolo; valores válidos
```
are *:local*, *:majority*, and *:snapshot*
```
:write (Hash) —

Obsoleto. Equivalente à opção :write_concern.
:write_concern (Hash) —

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

Retorna:

(Mongo::Collection) —

Uma nova instância de coleção.

Desde:

2.1.0

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 294

def com(new_options)
  new_options.keys.cada fazer |k|
    aumentar Erro::UnchangeableCollectionOption.Novo(k) a menos que CHANGEABLE_OPTIONS.incluir?(k)
  end
  opções = @opções.dup
  se opções[:write] && new_options[:write_concern]
    opções.excluir(:write)
  end
  se opções[:write_concern] && new_options[:write]
    opções.excluir(:write_concern)
  end
  collection.Novo(database, name, opções.update(new_options))
end

#write_concern ➤ `Mongo::WriteConcern`

Obtenha a preocupação de escrita eficaz nesta coleção.

Se uma write concern for fornecida nas opções de collection, essa write concern será retornada, caso contrário, a write concern efetiva do banco de dados será retornada.

Exemplos:

Obtenha a preocupação de gravação.

collection.write_concern

Retorna:

(Mongo::WriteConcern) —

A preocupação de gravação.

Desde:

2.0.0

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 232

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

#write_concern_with_session(session) ➤ `Mongo::WriteConcern`

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 a preocupação de gravação a ser usada para uma operação nessa coleção, dada uma sessão.

Se a sessão estiver em uma transação e a collection tiver uma write concern não reconhecida, remova a opção :w da write concern. Caso contrário, retorne a write concern inalterada.

Retorna:

(Mongo::WriteConcern) —

A preocupação de gravação.

Desde:

2.0.0

# File 'build/ruby-driver-v2.19/lib/mongo/collection.rb', linha 248

def write_concern_with_session(session)
  wc = write_concern
  se session && session.in_transaction?
    se wc && !wc.reconhecido?
      opciona = wc.opções.dup
      opciona.excluir(:w)
      Método Escreva preocupação.obter(opciona)
    end
  end
  wc
end

Classe: Mongo::Collection

Visão geral

Definido sob namespace

Colapsode resumo constante

Constantes incluídas de QueryableEncryption

Recolhimento do Resumo do atributo de instância

Recolhimento do Resumo do método de instância

Métodos incluídos de auxiliares

Métodos incluídos do QueryableEncryption

Métodos incluídos no Retryable

Detalhes do construtor

#initialize(banco de dados, name, options = {}) ➤ Collection

Detalhes do atributo da instância

#database ➤ Mongo::Database (readonly)

#name ➤ string (somente leitura)

#opções ➤ Hash (somente leitura)

Detalhes do método de instância

#==(outro) ➤ verdadeiro | false

#agregado(pipeline, opções = {}) ➤ Visualizar::Aggregation

#bulk_write(requests, options = {}) ➤ BulkWrite::Result

#limitado? ➤ verdadeiro | false

#count(filter = nil, options = {}) ⇒ Inteiro

#count_documents(filter = {}, options = {}) ➤ inteiro

#create(opts = {}) ➤ Resultado

#delete_many(filter = nil, options = {}) ➤ Resultado

#delete_one(filter = nil, options = {}) ➤ Resultado

#distinct(field_name, filter = nil, options = {}) ➤ Array<Object>

#drop(opts = {}) ➤ Resultado

No.

#encontrar(filter = nil, opções = {}) ➤ CollectionView

#find_one_and_delete(filter, options = {}) ➤ BSON::Document?

#find_one_and_replace(filtro, substituição, opções = {}) ➤ BSON::Document

#find_one_and_update(filter, update, options = {}) ➤ BSON::Document

#indexes(options = {}) ⇒ View::Index

#insert_many(documents, options = {}) ⇒ Result

#insert_one(documento, opts = {}) ➤ Resultado

#inspecionar ➤ string

#namespace ➤ string

#parallel_scan(cursor_count, options = {}) ➤ Array<Cursor>

#read_concern ➤ Hash

#read_preference ➤ Hash

#replace_one(filtro, substituição, opções = {}) ➤ Resultado

#server_selector ➤ Mongo::ServerSelector

#system_collection? ➤ Booleano

#update_many(filter, update, options = {}) ⇒ Result

#update_one(filter, update, options = {}) ⇒ Result

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

#com(new_options) ➤ Mongo::Collection

#write_concern ➤ Mongo::WriteConcern

#write_concern_with_session(session) ➤ Mongo::WriteConcern

#initialize(banco de dados, name, options = {}) ➤ `Collection`

#database ➤ `Mongo::Database` (readonly)

#name ➤ `string` (somente leitura)

#opções ➤ `Hash` (somente leitura)

#==(outro) ➤ `verdadeiro | false`

#agregado(pipeline, opções = {}) ➤ `Visualizar::Aggregation`

#bulk_write(requests, options = {}) `➤ BulkWrite::Result`

#limitado? ➤ `verdadeiro | false`

#count(filter = nil, options = {}) ⇒ `Inteiro`

#count_documents(filter = {}, options = {}) ➤ `inteiro`

#create(opts = {}) ➤ `Resultado`

#delete_many(filter = nil, options = {}) ➤ `Resultado`

#delete_one(filter = nil, options = {}) ➤ `Resultado`

#distinct(field_name, filter = nil, options = {}) ➤ `Array<Object>`

#drop(opts = {}) ➤ `Resultado`

#encontrar(filter = nil, opções = {}) ➤ `CollectionView`

#find_one_and_delete(filter, options = {}) ➤ `BSON::Document`^?

#find_one_and_replace(filtro, substituição, opções = {}) ➤ `BSON::Document`

#find_one_and_update(filter, update, options = {}) ➤ `BSON::Document`

#indexes(options = {}) ⇒ `View::Index`

#insert_many(documents, options = {}) ⇒ `Result`

#insert_one(documento, opts = {}) ➤ `Resultado`

#inspecionar ➤ `string`

#namespace ➤ `string`

#parallel_scan(cursor_count, options = {}) ➤ `Array<Cursor>`

#read_concern ➤ `Hash`

#read_preference ➤ `Hash`

#replace_one(filtro, substituição, opções = {}) ➤ `Resultado`

#server_selector ➤ `Mongo::ServerSelector`

#system_collection? ➤ `Booleano`

#update_many(filter, update, options = {}) ⇒ `Result`

#update_one(filter, update, options = {}) ⇒ `Result`

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

#com(new_options) ➤ `Mongo::Collection`

#write_concern ➤ `Mongo::WriteConcern`

#write_concern_with_session(session) ➤ `Mongo::WriteConcern`