Transações

API de nível superior

Uma transação pode ser iniciada chamando o método transaction em uma instância de uma classe de documento Mongoid , em uma classe de documento Mongoid ou no módulo Mongoid :

Band.transaction do
  Band.create(title: 'Led Zeppelin')
end
band = Band.create(title: 'Deep Purple')
band.transaction do
  band.active = false
  band.save!
end
Mongoid.transaction do
  band.destroy
end

Quando o método transaction é chamado, o Mongoid faz o seguinte:

• cria uma sessão em um cliente que é usado pelo receptor da chamada de método transaction ;

• inicia uma transação na sessão;

• executa o bloco fornecido;

• confirma a transação se nenhuma exceção gerada no bloco;

  • chama after_commit retornos de chamada para todos os objetos modificados dentro da transação

• aborta a transação se uma exceção for gerada no bloco;

  • chama after_rollback retornos de chamada para todos os objetos modificados dentro da transação

• fecha a sessão

class Author
  include Mongoid::Document
  store_in client: :encrypted_client
end
class User
  include Mongoid::Document
  store_in client: :encrypted_client
end
class Article
  include Mongoid::Document
  # This class uses the :default client
end
# Transaction is started on the :encrypted_client
Author.transaction do
  # This operation uses the same client, so it is in the transaction
  Author.create!
  # This operation also uses the same client, so it is in the transaction
  User.create!
  # This operation uses a different client, so it is NOT in the transaction
  Article.create!
end

API de nível inferior

Para iniciar uma transação, o aplicativo deve ter uma sessão.

Uma transação pode ser iniciada ligando para o método start_transaction em uma sessão, que pode ser obtido chamando o método with_session em uma classe ou instância de modelo:

class Person
  include Mongoid::Document
end
Person.with_session do |session|
  session.start_transaction
end
person = Person.new
person.with_session do |session|
  session.start_transaction
end

Também é possível especificar a referência de leitura, referência de escrita e preferência de leitura ao iniciar uma transação:

Person.with_session do |session|
  session.start_transaction(
    read_concern: {level: :majority},
    write_concern: {w: 3},
    read: {mode: :primary})
end

Uma transação pode ser confirmada ou abortada. Os métodos correspondentes para fazer isso são commit_transaction e abort_transaction, novamente na instância da sessão:

Person.with_session do |session|
  session.commit_transaction
end
Person.with_session do |session|
  session.abort_transaction
end

Se uma sessão terminar com uma transação aberta, a transação será cancelada.

A confirmação da transação poderá ser repetida se falhar. Aqui está o código Ruby para fazer isso:

begin
  session.commit_transaction
rescue Mongo::Error => e
  if e.label?(Mongo::Error::UNKNOWN_TRANSACTION_COMMIT_RESULT_LABEL)
    retry
  else
    raise
  end
end

Observe que, para realizar operações dentro da transação, as operações devem usar o mesmo cliente em que a sessão foi iniciada. Por padrão, todas as operações serão feitas no cliente padrão:

class Person
  include Mongoid::Document
end
class Post
  include Mongoid::Document
end
Person.with_session do |s|
  s.start_transaction
  Person.create!
  Person.create!
  Post.create!
  s.commit_transaction
end

Para usar explicitamente um cliente diferente, use o método with :

Post.with(client: :other) do
  Person.with(client: :other) do
    Person.with_session do |s|
      s.start_transaction
      Person.create!
      Person.create!
      Post.create!
      s.commit_transaction
    end
  end
end