/ /

Transações

Visão geral

Neste guia, você pode aprender a usar o driver Ruby para executar transações. As transações permitem que você execute uma série de operações que alteram os dados somente se toda a transação estiver confirmada. Se qualquer operação na transação não for bem-sucedida, o driver interromperá a transação e descartará todas as alterações de dados antes que elas se tornem visíveis. Esse recurso é chamado de atomicidade.

No MongoDB, as transações são executadas dentro de sessões lógicas . Uma sessão é um agrupamento de operações de leitura ou escrita relacionadas que você deseja executar sequencialmente. As sessões permitem consistência causal para um grupo de operações e permitem executar operações em uma transação compatível com ACID, que é uma transação que atende a uma expectativa de atomicidade, consistência, isolamento e durabilidade. O MongoDB garante que os dados envolvidos em suas operações de transação permaneçam consistentes, mesmo que as operações encontrem erros inesperados.

Ao usar o driver Ruby, você pode iniciar uma sessão chamando o método start_session no seu cliente. Em seguida, você pode realizar transações dentro da sessão.

Aviso

Use uma sessão somente em operações em execução no Mongo::Client que a criou. Utilizar uma sessão com um Mongo::Client diferente resulta em erros de operação.

Consistência causal

O MongoDB permite consistência causal em determinadas sessões de cliente. O modelo de consistência causal garante que, em um sistema distribuído, as operações dentro de uma sessão sejam executadas em uma ordem causal. Os clientes observam resultados consistentes com as relações causais ou as dependências entre as operações. Por exemplo, se você executar uma série de operações em que uma operação depende logicamente do resultado de outra, todas as leituras subsequentes refletirão o relacionamento de dependência .

Para garantir a consistência causal, as sessões de cliente devem atender aos seguintes requisitos:

Ao iniciar uma sessão, o driver deve habilitar a opção de consistência causal. Esta opção está habilitada por padrão.
As operações devem ser executadas em uma única sessão em um único thread. Caso contrário, as sessões ou threads devem comunicar os valores de optime e tempo de cluster uns aos outros. Para visualizar um exemplo de duas sessões que comunicam estes valores, consulte os exemplos de Consistência causal no manual do MongoDB Server.
Você deve usar uma preocupação de leitura :majority .
Você deve usar uma preocupação de gravação :majority . Este é o valor padrão de preocupação de gravação .

A tabela a seguir descreve as garantias que as sessões causalmente consistentes oferecem:

Garantia	Descrição
Ler suas gravações	As operações de leitura refletem os resultados das operações de gravação anteriores.
Leituras monotônicas	As operações de leitura não retornam resultados que reflitam um estado de dados anterior a uma operação de leitura anterior.
Escritas monotônicas	Se uma operação de gravação precisar preceder outras operações de gravação, o servidor executará essa operação de gravação primeiro. Por exemplo, se você chamar `insert_one()` para inserir um documento e, em seguida, chamar `update_one()` para modificar o documento inserido, o servidor executará a operação de inserção primeiro.
Escritas que seguem as leituras	Se uma operação de gravação precisar seguir outras operações de leitura, o servidor executará primeiro as operações de leitura. Por exemplo, se você chamar `find()` para recuperar um documento e, em seguida, chamar `delete_one()` para excluir o documento recuperado, o servidor executará primeiro a operação de localização.

Dica

Para saber mais sobre os conceitos mencionados nesta seção, consulte as seguintes entradas de manual do MongoDB Server :

Métodos

Após chamar o método start_session para iniciar uma sessão, você pode utilizar métodos da classe Mongo::Session para gerenciar o estado da sessão. A tabela a seguir descreve os métodos que você pode usar para gerenciar uma transação:

Método	Descrição
`start_transaction`	Starts a new transaction on this session. You cannot start a transaction if there's already an active transaction running in the session. You can set transaction options including read concern, write concern, and read preference by passing a `Hash` as a parameter.
`commit_transaction`	Commits the active transaction for this session. This method returns an error if there is no active transaction for the session, the transaction was previously ended, or if there is a write conflict.
`abort_transaction`	Ends the active transaction for this session. This method returns an error if there is no active transaction for the session or if the transaction was committed or ended.
`with_transaction`	Starts a transaction prior to calling the supplied block, and commits the transaction when the block finishes. If any of the operations in the block, or the commit operation, result in a transient transaction error, the block and/or the commit will be executed again.

Exemplo de transação

Este exemplo define um método run_transaction que modifica dados nas collections do banco de dados sample_mflix. O código executa as seguintes ações:

Cria instâncias Mongo::Collection para acessar as coleções movies e users.
Especifica as write concerns da transação.
Inicia a transação.
Insere um documento na coleção movies e imprime os resultados.
Atualiza um documento na collection users e imprime os resultados.

database = client.use('sample_mflix')
movies_collection = database[:movies]
users_collection = database[:users]
def run_transaction(session, movies_collection, users_collection)
  transaction_options = {
    read_concern: { level: "snapshot" },
    write_concern: { w: "majority" }
  }
session.with_transaction(transaction_options) do
  # Inserts document into the "movies" collection
  insert_result = movies_collection.insert_one({ name: 'The Menu', runtime: 107 }, session: session)
  puts "Insert completed: #{insert_result.inspect}"
  # Updates document in the "users" collection
  update_result = users_collection.update_one({ name: 'Amy Phillips'}, { "$set" => { name: 'Amy Ryan' }}, session: session)
  puts "Update completed: #{update_result.inspect}"
  end
end
# Starts a session
session = client.start_session
begin
  # Runs the transaction
  run_transaction(session, movies_collection, users_collection)
  puts "Transaction committed successfully."
rescue Mongo::Error::OperationFailure => e
  puts "Transaction failed and was aborted. Error: #{e.message}"
ensure
  session.end_session
end

Observação

Operações paralelas não suportadas

O driver Ruby não suporta a execução de operações paralelas em uma única transação.

Se você estiver usando o MongoDB Server v8.0 ou posterior, poderá executar operações de gravação em vários namespaces em uma única transação usando o método bulk_write. Para obter mais informações, consulte o guiade Operações de Gravação em Massa.

Informações adicionais

Para saber mais sobre os conceitos mencionados neste guia, consulte as seguintes páginas no manual do MongoDB Server :

Para saber mais sobre a conformidade com ACID , consulte o artigo Um guia para propriedades ACID em sistemas de gerenciamento de banco de dados no site do MongoDB .

Para saber mais sobre operações de inserção, consulte o guia Inserir documento .

Documentação da API

Para saber mais sobre os métodos e tipos mencionados neste guia, consulte a documentação da API abaixo:

Voltar

Operações de gravação em massa

Configurar operações CRUD