Módulo: Mongoid::Clients::Sessions::ClassMethods

Incluído em:
Mongoid
Definido em:
lib/mongoid/clients/sessions.rb

Colapsode resumo constante

CALLBACK_ACTIONS =

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.

Ações que podem ser usadas para trigger chamadas de resposta transacionais.

%i[criar destruir update]

Recolhimento do Resumo do método de instância

Detalhes do método de instância

#after_commit(*args, &block) ➤ Objeto

Define que um chamada de resposta de chamada é chamado após a confirmação de uma transação. A chamada de resposta de resposta é chamada somente se o documento for criado, atualizado ou destruído na transação.

Consulte ActiveSupport::Callbacks::ClassMethods::set_callback para mais informações sobre parâmetros de método e possíveis opções.



108
109
110
111
 
# Arquivo 'lib/mongoid/clients/sessions.rb', linha 108

def after_commit(*Args, &noum: bloco ; verb: bloquear)
  set_options_for_callbacks!(Args)
  set_callback(:commit, :after, *Args, &noum: bloco ; verb: bloquear)
end

#after_create_commit(*args, &block) ➤ Objeto

Atalho para after_commit :hook, on: :create.



120
121
122
123
 
# Arquivo 'lib/mongoid/clients/sessions.rb', linha 120

def after_create_commit(*Args, &noum: bloco ; verb: bloquear)
  set_options_for_callbacks!(Args, em: :create)
  set_callback(:commit, :after, *Args, &noum: bloco ; verb: bloquear)
end

#after_destroy_commit(*args, &block) ➤ Objeto

Atalho para after_commit :hook, on: :destroy.



132
133
134
135
 
# Arquivo 'lib/mongoid/clients/sessions.rb', linha 132

def after_destroy_commit(*Args, &noum: bloco ; verb: bloquear)
  set_options_for_callbacks!(Args, em: :destroy)
  set_callback(:commit, :after, *Args, &noum: bloco ; verb: bloquear)
end

#after_rollback(*args, &block) ➤ Objeto

Esse chamada de resposta de chamada é chamado depois que uma criação, atualização ou destruição é revertida.

Verifique a documentação do after_commit para opções.



140
141
142
143
 
# Arquivo 'lib/mongoid/clients/sessions.rb', linha 140

def after_rollback(*Args, &noum: bloco ; verb: bloquear)
  set_options_for_callbacks!(Args)
  set_callback(:rollback, :after, *Args, &noum: bloco ; verb: bloquear)
end

#after_save_commit(*args, &block) ➤ Objeto

Atalho para after_commit :hook, on: [ :create, :update ]



114
115
116
117
 
# Arquivo 'lib/mongoid/clients/sessions.rb', linha 114

def after_save_commit(*Args, &noum: bloco ; verb: bloquear)
  set_options_for_callbacks!(Args, em: %i[criar update])
  set_callback(:commit, :after, *Args, &noum: bloco ; verb: bloquear)
end

#after_update_commit(*args, &block) ➤ Objeto

Atalho para after_commit :hook, on: :update.



126
127
128
129
 
# Arquivo 'lib/mongoid/clients/sessions.rb', linha 126

def after_update_commit(*Args, &noum: bloco ; verb: bloquear)
  set_options_for_callbacks!(Args, em: :update)
  set_callback(:commit, :after, *Args, &noum: bloco ; verb: bloquear)
end

#transaction(options = { }, session_options: { }) { ... } ➤ Object

Executa um bloco dentro do contexto de uma transação.

Se o bloqueio não gerar um erro, a transação será confirmada. Se um erro for gerado, a transação será abortada. O erro é passado, exceto para Mongoid::Errors::Rollback. Este erro não é repassado, então você pode levantá-lo se quiser fazer o rollback da transação deliberadamente.

Parâmetros:

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

    As opções de transação. Consulte a documentação do driver para obter as opções de sessão disponíveis.

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

    As opções da sessão. Uma transação MongoDB deve ser iniciada dentro de uma sessão, portanto, uma sessão será iniciada. Consulte a documentação do driver para obter as opções de sessão disponíveis.

Rendimento:

  • O bloqueio fornecido será executado dentro de uma transação.

Aumenta:



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# Arquivo 'lib/mongoid/clients/sessions.rb', linha 83

def transação(opções = {}, session_options: {}, &noum: bloco ; verb: bloquear)
  with_session(session_options) fazer |session|
    session.with_transaction(opções, &noum: bloco ; verb: bloquear).toque { run_commit_callbacks(session) }
  salvar *transactions_not_supported_Exceptions
    aumentar Mongoid::Errors::TransactionsNotSupported
  salvar Mongoid::Errors::Rollback
    run_abort_callbacks(session)
  salvar Mongoid::Errors::InvalidSessionNesting
    # A sessão deve ser encerrada aqui.
    aumentar Mongoid::Errors::InvalidTransactionNesting.Novo
  salvar mongo::Erro::Sessão inválida, mongo::Erro::Operação de transação inválida => e
    run_abort_callbacks(session)
    aumentar Mongoid::Errors::TransactionError.Novo(e)
  salvar StandardError => e
    run_abort_callbacks(session)
    aumentar e
  end
end

#with_session(opções = {}) {|The| ... } ➤ Objeto

Execute um bloco dentro do contexto de uma sessão.

Exemplos:

Execute algumas operações no contexto de uma sessão.

Band.with_session(causal_consistency: true) do
  band = Band.create
  band.records << Record.new
  band.save
  band.reload.records
end

Parâmetros:

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

    As opções da sessão. Consulte a documentação do driver para obter as opções de sessão disponíveis.

Parâmetros de rendimento:

  • O (Mongo::Session) —

    sessão que está sendo usada para o bloco.

Retorna:

  • (Objeto) —

    O resultado de chamar o bloco.

Aumenta:

  • (Erros::InvalidSessionUse) —

    Se for tentada uma operação em um modelo usando outro cliente do qual a sessão foi iniciada ou se as sessões estiverem aninhadas.



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# Arquivo 'lib/mongoid/clients/sessions.rb', linha 38

def with_session(opções = {})
  aumentar Mongoid::Errors::InvalidSessionNesting.Novo se Threaded.get_session(cliente: persistence_context.Cliente)

  session = persistence_context.Cliente.start_session(opções)
  Threaded.set_session(session, cliente: persistence_context.Cliente)
  rendimento(session)
salvar mongo::Erro::Sessão inválida => e
  aumentar Mongoid::Errors::SessionsNotSupported.Novo se e.is_a?(mongo::Erro::SessionsNotSupported)

  aumentar e
salvar mongo::Erro::Falha de operação => e
  se (e.código == 40_415 && e.server_message =~ /startTransaction/) ||
     (e.código == 20 && e.server_message =~ /Transação/)
    aumentar Mongoid::Errors::TransactionsNotSupported.Novo
  mais
    aumentar e
  end
salvar *transactions_not_supported_Exceptions
  aumentar Mongoid::Errors::TransactionsNotSupported
garantir
  Threaded.clear_modified_documents(session)
  Threaded.clear_session(cliente: persistence_context.Cliente)
end