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.

[:create, :destroy, :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.



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

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.



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

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.



143
144
145
146
 
# Arquivo 'lib/mongoid/clients/sessions.rb', linha 143

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.



151
152
153
154
 
# Arquivo 'lib/mongoid/clients/sessions.rb', linha 151

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 ]



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

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

#after_update_commit(*args, &block) ➤ Objeto

Atalho para after_commit :hook, on: :update.



137
138
139
140
 
# Arquivo 'lib/mongoid/clients/sessions.rb', linha 137

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 o 'Mongoid::Errors::Rollback'. Este erro não é repassado, então você pode levantá-lo se quiser reverter a 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:



90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# Arquivo 'lib/mongoid/clients/sessions.rb', linha 90

def transação(opções = {}, session_options: {})
  with_session(session_options) fazer |session|
    começar
      session.with_transaction(opções) fazer
        rendimento
      end.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
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.



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# Arquivo 'lib/mongoid/clients/sessions.rb', linha 42

def with_session(opções = {})
  se Threaded.get_session(cliente: persistence_context.Cliente)
    aumentar Mongoid::Errors::InvalidSessionNesting.Novo
  end
  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 => ex
  se mongo::Erro::SessionsNotSupported === ex
    aumentar Mongoid::Errors::SessionsNotSupported.Novo
  mais
    aumentar ex
  end
salvar mongo::Erro::Falha de operação => ex
  se (ex.código == 40415 && ex.server_message =~ /startTransaction/) ||
     (ex.código == 20 && ex.server_message =~ /Transação/)
    aumentar Mongoid::Errors::TransactionsNotSupported.Novo
  mais
    aumentar ex
  end
salvar *transactions_not_supported_Exceptions
  aumentar Mongoid::Errors::TransactionsNotSupported
garantir
  Threaded.clear_modified_documents(session)
  Threaded.clear_session(cliente: persistence_context.Cliente)
end