- A
- B
- C
- D
- E
- I
- L
- O
- R
- S
- T
- U
Register a record with the current transaction so that its after_commit and after_rollback callbacks can be called.
Begins the transaction (and turns off auto-committing).
Commits the transaction (and turns on auto-committing).
Executes the delete statement and returns the number of rows affected.
Executes delete sql statement in the context of this connection using binds as the bind substitutes. name is the logged along with the executed sql statement.
Executes insert sql statement in the context of this connection using binds as the bind substitutes. name is the logged along with the executed sql statement.
Executes sql statement in the context of this connection using binds as the bind substitutes. name is logged along with the executed sql statement.
Executes update sql statement in the context of this connection using binds as the bind substitutes. name is the logged along with the executed sql statement.
Executes the SQL statement in the context of this connection.
Returns the last auto-generated ID from the affected table.
id_value will be returned unless the value is nil, in which case the database will attempt to calculate the last inserted id and return that value.
If the next id was calculated in advance (as in Oracle), it should be passed in as id_value.
# File activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb, line 88 88: def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = []) 89: sql, binds = sql_for_insert(to_sql(arel, binds), pk, id_value, sequence_name, binds) 90: value = exec_insert(sql, name, binds) 91: id_value || last_inserted_id(value) 92: end
Inserts the given fixture into the table. Overridden in adapters that require something beyond a simple insert (eg. Oracle).
# File activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb, line 268 268: def insert_fixture(fixture, table_name) 269: columns = Hash[columns(table_name).map { |c| [c.name, c] }] 270: 271: key_list = [] 272: value_list = fixture.map do |name, value| 273: key_list << quote_column_name(name) 274: quote(value, columns[name]) 275: end 276: 277: execute "INSERT INTO #{quote_table_name(table_name)} (#{key_list.join(', ')}) VALUES (#{value_list.join(', ')})", 'Fixture Insert' 278: end
# File activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb, line 288 288: def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key) 289: "WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{quoted_table_name} #{where_sql})" 290: end
Checks whether there is currently no transaction active. This is done by querying the database driver, and does not use the transaction house-keeping information recorded by increment_open_transactions and friends.
Returns true if there is no transaction active, false if there is a transaction active, and nil if this information is unknown.
Not all adapters supports transaction state introspection. Currently, only the PostgreSQL adapter supports this.
Set the sequence to the max value of the table’s column.
Rolls back the transaction (and turns on auto-committing). Must be done if the transaction block raises an exception or returns false.
Sanitizes the given LIMIT parameter in order to prevent SQL injection.
The limit may be anything that can evaluate to a string via to_s. It should look like an integer, or a comma-delimited list of integers, or an Arel SQL literal.
Returns Integer and Arel::Nodes::SqlLiteral limits as is. Returns the sanitized limit parameter, either as an integer, or as a string which contains a comma-delimited list of integers.
# File activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb, line 301 301: def sanitize_limit(limit) 302: if limit.is_a?(Integer) || limit.is_a?(Arel::Nodes::SqlLiteral) 303: limit 304: elsif limit.to_s =~ /,/ 305: Arel.sql limit.to_s.split(',').map{ |i| Integer(i) }.join(',') 306: else 307: Integer(limit) 308: end 309: end
Returns an array of record hashes with the column names as keys and column values as values.
Returns a record hash with the column names as keys and column values as values.
Returns an array of arrays containing the field values. Order is the same as that returned by columns.
Returns a single value from a record
Returns an array of the values of the first column in a select:
select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
Returns true when the connection adapter supports prepared statement caching, otherwise returns false
Converts an arel AST to SQL
Runs the given block in a database transaction, and returns the result of the block.
Nested transactions support
Most databases don’t support true nested transactions. At the time of writing, the only database that supports true nested transactions that we’re aware of, is MS-SQL.
In order to get around this problem, transaction will emulate the effect of nested transactions, by using savepoints: dev.mysql.com/doc/refman/5.0/en/savepoint.html Savepoints are supported by MySQL and PostgreSQL, but not SQLite3.
It is safe to call this method if a database transaction is already open, i.e. if transaction is called within another transaction block. In case of a nested call, transaction will behave as follows:
- The block will be run without doing anything. All database statements that happen within the block are effectively appended to the already open database transaction.
- However, if :requires_new is set, the block will be wrapped in a database savepoint acting as a sub-transaction.
Caveats
MySQL doesn’t support DDL transactions. If you perform a DDL operation, then any created savepoints will be automatically released. For example, if you’ve created a savepoint, then you execute a CREATE TABLE statement, then the savepoint that was created will be automatically released.
This means that, on MySQL, you shouldn’t execute DDL operations inside a transaction call that you know might create a savepoint. Otherwise, transaction will raise exceptions when it tries to release the already-automatically-released savepoints:
Model.connection.transaction do # BEGIN
Model.connection.transaction(:requires_new => true) do # CREATE SAVEPOINT active_record_1
Model.connection.create_table(...)
# active_record_1 now automatically released
end # RELEASE SAVEPOINT active_record_1 <--- BOOM! database error!
end
# File activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb, line 166 166: def transaction(options = {}) 167: options.assert_valid_keys :requires_new, :joinable 168: 169: last_transaction_joinable = defined?(@transaction_joinable) ? @transaction_joinable : nil 170: if options.has_key?(:joinable) 171: @transaction_joinable = options[:joinable] 172: else 173: @transaction_joinable = true 174: end 175: requires_new = options[:requires_new] || !last_transaction_joinable 176: 177: transaction_open = false 178: @_current_transaction_records ||= [] 179: 180: begin 181: if block_given? 182: if requires_new || open_transactions == 0 183: if open_transactions == 0 184: begin_db_transaction 185: elsif requires_new 186: create_savepoint 187: end 188: increment_open_transactions 189: transaction_open = true 190: @_current_transaction_records.push([]) 191: end 192: yield 193: end 194: rescue Exception => database_transaction_rollback 195: if transaction_open && !outside_transaction? 196: transaction_open = false 197: decrement_open_transactions 198: if open_transactions == 0 199: rollback_db_transaction 200: rollback_transaction_records(true) 201: else 202: rollback_to_savepoint 203: rollback_transaction_records(false) 204: end 205: end 206: raise unless database_transaction_rollback.is_a?(ActiveRecord::Rollback) 207: end 208: ensure 209: @transaction_joinable = last_transaction_joinable 210: 211: if outside_transaction? 212: @open_transactions = 0 213: elsif transaction_open 214: decrement_open_transactions 215: begin 216: if open_transactions == 0 217: commit_db_transaction 218: commit_transaction_records 219: else 220: release_savepoint 221: save_point_records = @_current_transaction_records.pop 222: unless save_point_records.blank? 223: @_current_transaction_records.push([]) if @_current_transaction_records.empty? 224: @_current_transaction_records.last.concat(save_point_records) 225: end 226: end 227: rescue Exception => database_transaction_rollback 228: if open_transactions == 0 229: rollback_db_transaction 230: rollback_transaction_records(true) 231: else 232: rollback_to_savepoint 233: rollback_transaction_records(false) 234: end 235: raise 236: end 237: end 238: end
Executes the update statement and returns the number of rows affected.
Send a commit message to all records after they have been committed.
# File activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb, line 366 366: def commit_transaction_records 367: records = @_current_transaction_records.flatten 368: @_current_transaction_records.clear 369: unless records.blank? 370: records.uniq.each do |record| 371: begin 372: record.committed! 373: rescue Exception => e 374: record.logger.error(e) if record.respond_to?(:logger) && record.logger 375: end 376: end 377: end 378: end
Executes the delete statement and returns the number of rows affected.
Returns the last auto-generated ID from the affected table.
Send a rollback message to all records after they have been rolled back. If rollback is false, only rollback records since the last save point.
# File activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb, line 346 346: def rollback_transaction_records(rollback) 347: if rollback 348: records = @_current_transaction_records.flatten 349: @_current_transaction_records.clear 350: else 351: records = @_current_transaction_records.pop 352: end 353: 354: unless records.blank? 355: records.uniq.each do |record| 356: begin 357: record.rolledback!(rollback) 358: rescue Exception => e 359: record.logger.error(e) if record.respond_to?(:logger) && record.logger 360: end 361: end 362: end 363: end
Returns an array of record hashes with the column names as keys and column values as values.