/usr/lib/ruby/vendor_ruby/sequel/database/transactions.rb is in ruby-sequel 4.15.0-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 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 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 | module Sequel
class Database
# ---------------------
# :section: 8 - Methods related to database transactions
# Database transactions make multiple queries atomic, so
# that either all of the queries take effect or none of
# them do.
# ---------------------
SQL_BEGIN = 'BEGIN'.freeze
SQL_COMMIT = 'COMMIT'.freeze
SQL_RELEASE_SAVEPOINT = 'RELEASE SAVEPOINT autopoint_%d'.freeze
SQL_ROLLBACK = 'ROLLBACK'.freeze
SQL_ROLLBACK_TO_SAVEPOINT = 'ROLLBACK TO SAVEPOINT autopoint_%d'.freeze
SQL_SAVEPOINT = 'SAVEPOINT autopoint_%d'.freeze
TRANSACTION_BEGIN = 'Transaction.begin'.freeze
TRANSACTION_COMMIT = 'Transaction.commit'.freeze
TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
TRANSACTION_ISOLATION_LEVELS = {:uncommitted=>'READ UNCOMMITTED'.freeze,
:committed=>'READ COMMITTED'.freeze,
:repeatable=>'REPEATABLE READ'.freeze,
:serializable=>'SERIALIZABLE'.freeze}
# The default transaction isolation level for this database,
# used for all future transactions. For MSSQL, this should be set
# to something if you ever plan to use the :isolation option to
# Database#transaction, as on MSSQL if affects all future transactions
# on the same connection.
attr_accessor :transaction_isolation_level
# Starts a database transaction. When a database transaction is used,
# either all statements are successful or none of the statements are
# successful. Note that MySQL MyISAM tables do not support transactions.
#
# The following general options are respected:
#
# :auto_savepoint :: Automatically use a savepoint for Database#transaction calls
# inside this transaction block.
# :isolation :: The transaction isolation level to use for this transaction,
# should be :uncommitted, :committed, :repeatable, or :serializable,
# used if given and the database/adapter supports customizable
# transaction isolation levels.
# :num_retries :: The number of times to retry if the :retry_on option is used.
# The default is 5 times. Can be set to nil to retry indefinitely,
# but that is not recommended.
# :prepare :: A string to use as the transaction identifier for a
# prepared transaction (two-phase commit), if the database/adapter
# supports prepared transactions.
# :retry_on :: An exception class or array of exception classes for which to
# automatically retry the transaction. Can only be set if not inside
# an existing transaction.
# Note that this should not be used unless the entire transaction
# block is idempotent, as otherwise it can cause non-idempotent
# behavior to execute multiple times.
# :rollback :: Can the set to :reraise to reraise any Sequel::Rollback exceptions
# raised, or :always to always rollback even if no exceptions occur
# (useful for testing).
# :server :: The server to use for the transaction.
# :savepoint :: Whether to create a new savepoint for this transaction,
# only respected if the database/adapter supports savepoints. By
# default Sequel will reuse an existing transaction, so if you want to
# use a savepoint you must use this option. If the surrounding transaction
# uses :auto_savepoint, you can set this to false to not use a savepoint.
#
# PostgreSQL specific options:
#
# :deferrable :: (9.1+) If present, set to DEFERRABLE if true or NOT DEFERRABLE if false.
# :read_only :: If present, set to READ ONLY if true or READ WRITE if false.
# :synchronous :: if non-nil, set synchronous_commit
# appropriately. Valid values true, :on, false, :off, :local (9.1+),
# and :remote_write (9.2+).
def transaction(opts=OPTS, &block)
if retry_on = opts[:retry_on]
num_retries = opts.fetch(:num_retries, 5)
begin
transaction(opts.merge(:retry_on=>nil, :retrying=>true), &block)
rescue *retry_on
if num_retries
num_retries -= 1
retry if num_retries >= 0
else
retry
end
raise
end
else
synchronize(opts[:server]) do |conn|
if already_in_transaction?(conn, opts)
if opts[:retrying]
raise Sequel::Error, "cannot set :retry_on options if you are already inside a transaction"
end
if opts[:savepoint] != false && (stack = _trans(conn)[:savepoints]) && stack.last
_transaction(conn, opts.merge(:savepoint=>true), &block)
else
return yield(conn)
end
else
_transaction(conn, opts, &block)
end
end
end
end
private
# Internal generic transaction method. Any exception raised by the given
# block will cause the transaction to be rolled back. If the exception is
# not a Sequel::Rollback, the error will be reraised. If no exception occurs
# inside the block, the transaction is commited.
def _transaction(conn, opts=OPTS)
rollback = opts[:rollback]
begin
add_transaction(conn, opts)
begin_transaction(conn, opts)
if rollback == :always
begin
yield(conn)
rescue Exception => e1
raise e1
ensure
raise ::Sequel::Rollback unless e1
end
else
yield(conn)
end
rescue Exception => e
begin
rollback_transaction(conn, opts)
rescue Exception
end
transaction_error(e, :conn=>conn, :rollback=>rollback)
ensure
begin
committed = commit_or_rollback_transaction(e, conn, opts)
rescue Exception => e2
begin
raise_error(e2, :classes=>database_error_classes, :conn=>conn)
rescue Sequel::DatabaseError => e4
begin
rollback_transaction(conn, opts)
ensure
raise e4
end
end
ensure
remove_transaction(conn, committed)
end
end
end
# Synchronize access to the current transactions, returning the hash
# of options for the current transaction (if any)
def _trans(conn)
Sequel.synchronize{@transactions[conn]}
end
# Add the current thread to the list of active transactions
def add_transaction(conn, opts)
hash = {}
if supports_savepoints?
if _trans(conn)
hash = nil
_trans(conn)[:savepoints].push(opts[:auto_savepoint])
else
hash[:savepoints] = [opts[:auto_savepoint]]
if (prep = opts[:prepare]) && supports_prepared_transactions?
hash[:prepare] = prep
end
end
elsif (prep = opts[:prepare]) && supports_prepared_transactions?
hash[:prepare] = prep
end
if hash
Sequel.synchronize{@transactions[conn] = hash}
end
end
# Call all stored after_commit blocks for the given transaction
def after_transaction_commit(conn)
if ary = _trans(conn)[:after_commit]
ary.each{|b| b.call}
end
end
# Call all stored after_rollback blocks for the given transaction
def after_transaction_rollback(conn)
if ary = _trans(conn)[:after_rollback]
ary.each{|b| b.call}
end
end
# Whether the current thread/connection is already inside a transaction
def already_in_transaction?(conn, opts)
_trans(conn) && (!supports_savepoints? || !opts[:savepoint])
end
# Issue query to begin a new savepoint.
def begin_savepoint(conn, opts)
log_connection_execute(conn, begin_savepoint_sql(savepoint_level(conn)-1))
end
# SQL to start a new savepoint
def begin_savepoint_sql(depth)
SQL_SAVEPOINT % depth
end
# Start a new database connection on the given connection
def begin_new_transaction(conn, opts)
log_connection_execute(conn, begin_transaction_sql)
set_transaction_isolation(conn, opts)
end
# Start a new database transaction or a new savepoint on the given connection.
def begin_transaction(conn, opts=OPTS)
if supports_savepoints?
if savepoint_level(conn) > 1
begin_savepoint(conn, opts)
else
begin_new_transaction(conn, opts)
end
else
begin_new_transaction(conn, opts)
end
end
# SQL to BEGIN a transaction.
def begin_transaction_sql
SQL_BEGIN
end
# Whether to commit the current transaction. Thread.current.status is
# checked because Thread#kill skips rescue blocks (so exception would be
# nil), but the transaction should still be rolled back. On Ruby 1.9 (but
# not 1.8 or 2.0), the thread status will still be "run", so Thread#kill
# will erroneously commit the transaction, and there isn't a workaround.
def commit_or_rollback_transaction(exception, conn, opts)
if exception
false
else
if Thread.current.status == 'aborting'
rollback_transaction(conn, opts)
false
else
commit_transaction(conn, opts)
true
end
end
end
# SQL to commit a savepoint
def commit_savepoint_sql(depth)
SQL_RELEASE_SAVEPOINT % depth
end
# Commit the active transaction on the connection
def commit_transaction(conn, opts=OPTS)
if supports_savepoints?
depth = savepoint_level(conn)
log_connection_execute(conn, depth > 1 ? commit_savepoint_sql(depth-1) : commit_transaction_sql)
else
log_connection_execute(conn, commit_transaction_sql)
end
end
# SQL to COMMIT a transaction.
def commit_transaction_sql
SQL_COMMIT
end
# Method called on the connection object to execute SQL on the database,
# used by the transaction code.
def connection_execute_method
:execute
end
# Remove the current thread from the list of active transactions
def remove_transaction(conn, committed)
if transaction_finished?(conn)
begin
if committed
after_transaction_commit(conn)
else
after_transaction_rollback(conn)
end
ensure
Sequel.synchronize{@transactions.delete(conn)}
end
end
end
# SQL to rollback to a savepoint
def rollback_savepoint_sql(depth)
SQL_ROLLBACK_TO_SAVEPOINT % depth
end
# Rollback the active transaction on the connection
def rollback_transaction(conn, opts=OPTS)
if supports_savepoints?
depth = savepoint_level(conn)
log_connection_execute(conn, depth > 1 ? rollback_savepoint_sql(depth-1) : rollback_transaction_sql)
else
log_connection_execute(conn, rollback_transaction_sql)
end
end
# SQL to ROLLBACK a transaction.
def rollback_transaction_sql
SQL_ROLLBACK
end
# Set the transaction isolation level on the given connection
def set_transaction_isolation(conn, opts)
if supports_transaction_isolation_levels? and level = opts.fetch(:isolation, transaction_isolation_level)
log_connection_execute(conn, set_transaction_isolation_sql(level))
end
end
# SQL to set the transaction isolation level
def set_transaction_isolation_sql(level)
"SET TRANSACTION ISOLATION LEVEL #{TRANSACTION_ISOLATION_LEVELS[level]}"
end
# Current savepoint level.
def savepoint_level(conn)
_trans(conn)[:savepoints].length
end
# Raise a database error unless the exception is an Rollback.
def transaction_error(e, opts=OPTS)
if e.is_a?(Rollback)
raise e if opts[:rollback] == :reraise
else
raise_error(e, opts.merge(:classes=>database_error_classes))
end
end
# Finish a subtransaction. If savepoints are supported, pops the current
# tansaction off the savepoint stack.
def transaction_finished?(conn)
if supports_savepoints?
stack = _trans(conn)[:savepoints]
stack.pop
stack.empty?
else
true
end
end
end
end
|