Módulo: Mongoid::Clientes::Sesiones::MétodosDeClase

Incluido en:
Mongoid
Definido en:
lib/mongoid/clients/sessions.rb

Resumen de constantes colapsar

CALLBACK_ACTIONS =

Esta constante es parte de una API privada. Deberías evitar usar esta constante si es posible, ya que podría ser retirada o cambiada en el futuro.

Acciones que se pueden utilizar para activar devoluciones de llamada transaccionales.

%i[Cree destruir update]

Resumen del método de instancia colapsar

Detalles del método de instancia

#after_commit(*args, &block) ⇒ Objeto

Configura una función de retorno que se llama después de una confirmación de una transacción. La función de retorno se llama solo si el documento se crea, actualiza o destruye en la transacción.

Consulta ActiveSupport::Callbacks::ClassMethods::set_callback para obtener más información sobre los parámetros del método y las posibles opciones.



108
109
110
111
 
# Archivo 'lib/mongoid/clients/sessions.rb', línea 108

def después_de_confirmar(*args, &bloque)
  set_options_for_callbacks!(args)
  set_callback(Commit, después de, *args, &bloque)
end

#after_create_commit(*args, &block) ⇒ Object

Atajo para after_commit :hook, on: :create.



120
121
122
123
 
# Archivo 'lib/mongoid/clients/sessions.rb', línea 120

def after_create_commit(*args, &bloque)
  set_options_for_callbacks!(args, on: crear:)
  set_callback(Commit, después de, *args, &bloque)
end

#after_destroy_commit(*args, &block) ⇒ objeto

Atajo para after_commit :hook, on: :destroy.



132
133
134
135
 
# Archivo 'lib/mongoid/clients/sessions.rb', línea 132

def after_destroy_commit(*args, &bloque)
  set_options_for_callbacks!(args, on: :destroy)
  set_callback(Commit, después de, *args, &bloque)
end

#after_rollback(*args, &block) ⇒ Object

Esta función de retorno se llama después de que se revoque una creación, actualización o eliminación.

Consulta la documentación de after_commit para conocer las opciones disponibles.



140
141
142
143
 
# Archivo 'lib/mongoid/clients/sessions.rb', línea 140

def after_rollback(*args, &bloque)
  set_options_for_callbacks!(args)
  set_callback(:rollback, después de, *args, &bloque)
end

#after_save_commit(*args, &block) ⇒ Object

Acceso directo para after_commit :hook, on: [ :create, :update ]



114
115
116
117
 
# Archivo 'lib/mongoid/clients/sessions.rb', línea 114

def after_save_commit(*args, &bloque)
  set_options_for_callbacks!(args, on: %i[Cree update])
  set_callback(Commit, después de, *args, &bloque)
end

#after_update_commit(*args, &block) ⇒ objeto

Atajo para after_commit :hook, on: :update.



126
127
128
129
 
# Archivo 'lib/mongoid/clients/sessions.rb', línea 126

def after_update_commit(*args, &bloque)
  set_options_for_callbacks!(args, on: :update)
  set_callback(Commit, después de, *args, &bloque)
end

#transacción(options = {}, session_options: {}) { ... } ⇒ objeto

Ejecuta un bloque dentro del contexto de una transacción.

Si el bloque no genera un error, la transacción se realiza. Si se produce un error, la transacción se anula. El error se transmite excepto para el Mongoid::Errors::Rollback. Este error no se transmite, por lo que puede generarlo si deseas deliberadamente rollback la transacción.

Parámetros:

  • opciones (encriptada) (por defecto: {}) —

    Las opciones de transacción. Por favor, consulta la documentación del driver para conocer las opciones de sesión disponibles.

  • session_options (encriptada) (por defecto: {}) —

    Las opciones de la sesión. Una transacción de MongoDB debe iniciarse dentro de una sesión; por lo tanto, se iniciará una sesión. Consulta la documentación del controlador para conocer las opciones de sesión disponibles.

Rendimientos:

  • El bloque proporcionado se ejecutará dentro de una transacción.

Aumenta:



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

def transacción(opciones = {}, session_options: {}, &bloque)
  con_sesión(session_options) hacer |sesión|
    sesión.with_transaction(opciones, &bloque).tocar { run_commit_callbacks(sesión) }
  rescate *transactions_not_supported_exceptions
    propagar Mongoid::Errors::transacciones no admitidas
  rescate Mongoid::Errors::Rollback
    run_abort_callbacks(sesión)
  rescate Mongoid::Errors::InvalidSessionNesting
    # La sesión debe finalizarse aquí.
    propagar Mongoid::Errors::InvalidTransactionNesting.Nuevo
  rescate mongo::Error::InvalidSession, mongo::Error::OperaciónTransacciónInválida => e
    run_abort_callbacks(sesión)
    propagar Mongoid::Errors::TransactionError.Nuevo(e)
  rescate StandardError => e
    run_abort_callbacks(sesión)
    propagar e
  end
end

#con_sesión(opciones = {}) {|El| ... } ⇒ Objeto

Ejecuta un bloque dentro del contexto de una sesión.

Ejemplos:

Ejecuta algunas operaciones en el contexto de una sesión.

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

Parámetros:

  • opciones (encriptada) (por defecto: {}) —

    Las opciones de la sesión. Por favor, consulta la documentación del driver para conocer las opciones de sesión disponibles.

Parámetros de rendimiento:

  • La (Mongo::Session) —

    sesión en uso para el bloque.

Devuelve:

  • (objeto) —

    El resultado de llamar al bloque.

Aumenta:

  • (Errores::InvalidSessionUse) —

    Si se intenta realizar una operación en un modelo utilizando otro cliente desde el que se inició la sesión o si las sesiones están anidadas.



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

def con_sesión(opciones = {})
  propagar Mongoid::Errors::InvalidSessionNesting.Nuevo si Con hilo.get_session(cliente: persistence_context.Cliente)

  sesión = persistence_context.Cliente.start_session(opciones)
  Con hilo.set_session(sesión, cliente: persistence_context.Cliente)
  rendimiento(sesión)
rescate mongo::Error::InvalidSession => e
  propagar Mongoid::Errors::SessionsNotSupported.Nuevo si e.is_a?(mongo::Error::SessionsNotSupported)

  propagar e
rescate mongo::Error::OperationFailure => e
  si (e.Código == 40_415 && e.server_message =~ /startTransaction/) ||
     (e.Código == 20 && e.server_message =~ /transacción/)
    propagar Mongoid::Errors::transacciones no admitidas.Nuevo
  else
    propagar e
  end
rescate *transactions_not_supported_exceptions
  propagar Mongoid::Errors::transacciones no admitidas
asegurar
  Con hilo.clear_modified_documents(sesión)
  Con hilo.clear_session(cliente: persistence_context.Cliente)
end