Module: ActiveRecord::ConnectionAdapters::DatabaseStatements

### Home Classes Methods

### In Files

- lib/active_record/connection_adapters/abstract/database_statements.rb

### Methods

- #add_limit_offset!
- #add_transaction_record
- #begin_db_transaction
- #case_sensitive_equality_operator
- #commit_db_transaction
- #commit_transaction_records
- #default_sequence_name
- #delete
- #delete_sql
- #empty_insert_statement_value
- #execute
- #insert
- #insert_fixture
- #insert_sql
- #limited_update_conditions
- #outside_transaction?
- #reset_sequence!
- #rollback_db_transaction
- #rollback_transaction_records
- #sanitize_limit
- #select
- #select_all
- #select_one
- #select_rows
- #select_value
- #select_values
- #transaction
- #update
- #update_sql

### Files

- README.rdoc

### Class/Module Index

Quicksearch

- ActiveRecord
- ActiveRecord::ActiveRecordError
- ActiveRecord::AdapterNotFound
- ActiveRecord::AdapterNotSpecified
- ActiveRecord::Aggregations
- ActiveRecord::Aggregations::ClassMethods
- ActiveRecord::AssociationPreload
- ActiveRecord::AssociationPreload::ClassMethods
- ActiveRecord::AssociationTypeMismatch
- ActiveRecord::Associations
- ActiveRecord::Associations::ClassMethods
- ActiveRecord::Associations::HasOneThroughAssociation
- ActiveRecord::Associations::ThroughAssociationScope
- ActiveRecord::AttributeAssignmentError
- ActiveRecord::AttributeMethods
- ActiveRecord::AttributeMethods::BeforeTypeCast
- ActiveRecord::AttributeMethods::ClassMethods
- ActiveRecord::AttributeMethods::Dirty
- ActiveRecord::AttributeMethods::PrimaryKey
- ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods
- ActiveRecord::AttributeMethods::Query
- ActiveRecord::AttributeMethods::Read
- ActiveRecord::AttributeMethods::Read::ClassMethods
- ActiveRecord::AttributeMethods::TimeZoneConversion
- ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods
- ActiveRecord::AttributeMethods::Write
- ActiveRecord::AttributeMethods::Write::ClassMethods
- ActiveRecord::AutosaveAssociation
- ActiveRecord::AutosaveAssociation::ClassMethods
- ActiveRecord::Base
- ActiveRecord::Calculations
- ActiveRecord::Callbacks
- ActiveRecord::Callbacks::ClassMethods
- ActiveRecord::ConfigurationError
- ActiveRecord::ConnectionAdapters
- ActiveRecord::ConnectionAdapters::AbstractAdapter
- ActiveRecord::ConnectionAdapters::Column
- ActiveRecord::ConnectionAdapters::Column::Format
- ActiveRecord::ConnectionAdapters::ConnectionHandler
- ActiveRecord::ConnectionAdapters::ConnectionManagement
- ActiveRecord::ConnectionAdapters::ConnectionPool
- ActiveRecord::ConnectionAdapters::DatabaseLimits
- ActiveRecord::ConnectionAdapters::DatabaseStatements
- ActiveRecord::ConnectionAdapters::MysqlAdapter
- ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
- ActiveRecord::ConnectionAdapters::PostgreSQLColumn
- ActiveRecord::ConnectionAdapters::QueryCache
- ActiveRecord::ConnectionAdapters::Quoting
- ActiveRecord::ConnectionAdapters::SQLiteAdapter
- ActiveRecord::ConnectionAdapters::SQLiteAdapter::Version
- ActiveRecord::ConnectionAdapters::SchemaStatements
- ActiveRecord::ConnectionAdapters::Table
- ActiveRecord::ConnectionAdapters::TableDefinition
- ActiveRecord::ConnectionNotEstablished
- ActiveRecord::ConnectionTimeoutError
- ActiveRecord::CounterCache
- ActiveRecord::DangerousAttributeError
- ActiveRecord::DynamicFinderMatch
- ActiveRecord::DynamicScopeMatch
- ActiveRecord::FinderMethods
- ActiveRecord::Generators
- ActiveRecord::Generators::Migration
- ActiveRecord::Generators::MigrationGenerator
- ActiveRecord::Generators::ModelGenerator
- ActiveRecord::Generators::ObserverGenerator
- ActiveRecord::Generators::SessionMigrationGenerator
- ActiveRecord::InvalidForeignKey
- ActiveRecord::IrreversibleMigration
- ActiveRecord::Locking
- ActiveRecord::Locking::Optimistic
- ActiveRecord::Locking::Optimistic::ClassMethods
- ActiveRecord::Locking::Pessimistic
- ActiveRecord::LogSubscriber
- ActiveRecord::Migration
- ActiveRecord::MigrationProxy
- ActiveRecord::MultiparameterAssignmentErrors
- ActiveRecord::NamedScope
- ActiveRecord::NamedScope::ClassMethods
- ActiveRecord::NestedAttributes
- ActiveRecord::NestedAttributes::ClassMethods
- ActiveRecord::NestedAttributes::TooManyRecords
- ActiveRecord::Observer
- ActiveRecord::Persistence
- ActiveRecord::PredicateBuilder
- ActiveRecord::PreparedStatementInvalid
- ActiveRecord::QueryCache
- ActiveRecord::QueryCache::ClassMethods
- ActiveRecord::QueryMethods
- ActiveRecord::Railtie
- ActiveRecord::Railties
- ActiveRecord::Railties::ControllerRuntime
- ActiveRecord::Railties::ControllerRuntime::ClassMethods
- ActiveRecord::ReadOnlyRecord
- ActiveRecord::RecordInvalid
- ActiveRecord::RecordNotFound
- ActiveRecord::RecordNotSaved
- ActiveRecord::RecordNotUnique
- ActiveRecord::Reflection
- ActiveRecord::Reflection::ClassMethods
- ActiveRecord::Reflection::MacroReflection
- ActiveRecord::Relation
- ActiveRecord::Rollback
- ActiveRecord::Schema
- ActiveRecord::Serialization
- ActiveRecord::SerializationTypeMismatch
- ActiveRecord::SessionStore
- ActiveRecord::SessionStore::Session
- ActiveRecord::SessionStore::SqlBypass
- ActiveRecord::SpawnMethods
- ActiveRecord::StaleObjectError
- ActiveRecord::StatementInvalid
- ActiveRecord::TestFixtures
- ActiveRecord::TestFixtures::ClassMethods
- ActiveRecord::ThrowResult
- ActiveRecord::Timestamp
- ActiveRecord::Transactions
- ActiveRecord::Transactions::ClassMethods
- ActiveRecord::UnknownAttributeError
- ActiveRecord::Validations
- ActiveRecord::Validations::AssociatedValidator
- ActiveRecord::Validations::ClassMethods
- ActiveRecord::Validations::UniquenessValidator
- ActiveRecord::WrappedDatabaseException
- <
- Fixtures
- FixturesFileNotFound

No matching classes.

# ActiveRecord::ConnectionAdapters::DatabaseStatements

### Public Instance Methods

add_limit_offset!(sql, options) click to toggle source

Appends `LIMIT` and `OFFSET` options to an SQL statement, or some SQL fragment that has the same semantics as LIMIT and OFFSET.

`options` must be a Hash which contains a `:limit` option and an `:offset` option.

This method modifies the `sql` parameter.

##### Examples

    add_limit_offset!('SELECT * FROM suppliers', {:limit => 10, :offset => 50})

generates

    SELECT * FROM suppliers LIMIT 10 OFFSET 50

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 217
    def add_limit_offset!(sql, options)
      if limit = options[:limit]
        sql << " LIMIT #{sanitize_limit(limit)}"
      end
      if offset = options[:offset]
        sql << " OFFSET #{offset.to_i}"
      end
      sql
    end

add_transaction_record(record) click to toggle source

Register a record with the current transaction so that its after_commit and after_rollback callbacks can be called.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 189
    def add_transaction_record(record)
      last_batch = @_current_transaction_records.last
      last_batch << record if last_batch
    end

begin_db_transaction() click to toggle source

Begins the transaction (and turns off auto-committing).

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 195
    def begin_db_transaction()    end

case_sensitive_equality_operator() click to toggle source

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 246
    def case_sensitive_equality_operator
      "="
    end

commit_db_transaction() click to toggle source

Commits the transaction (and turns on auto-committing).

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 198
    def commit_db_transaction()   end

default_sequence_name(table, column) click to toggle source

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 227
    def default_sequence_name(table, column)
      nil
    end

delete(sql, name = nil) click to toggle source

Executes the delete statement and returns the number of rows affected.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 53
    def delete(sql, name = nil)
      delete_sql(sql, name)
    end

empty_insert_statement_value() click to toggle source

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 242
    def empty_insert_statement_value
      "VALUES(DEFAULT)"
    end

execute(sql, name = nil, skip_logging = false) click to toggle source

Executes the SQL statement in the context of this connection.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 38
    def execute(sql, name = nil, skip_logging = false)
    end

insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) click to toggle source

Returns the last auto-generated ID from the affected table.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 43
    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
      insert_sql(sql, name, pk, id_value, sequence_name)
    end

insert_fixture(fixture, table_name) click to toggle source

Inserts the given fixture into the table. Overridden in adapters that require something beyond a simple insert (eg. Oracle).

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 238
    def insert_fixture(fixture, table_name)
      execute "INSERT INTO #{quote_table_name(table_name)} (#{fixture.key_list}) VALUES (#{fixture.value_list})", 'Fixture Insert'
    end

limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key) click to toggle source

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 250
    def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
      "WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{quoted_table_name} #{where_sql})"
    end

outside_transaction?() click to toggle source

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.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 67
    def outside_transaction?
      nil
    end

reset_sequence!(table, column, sequence = nil) click to toggle source

Set the sequence to the max value of the table’s column.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 232
    def reset_sequence!(table, column, sequence = nil)
      # Do nothing by default.  Implement for PostgreSQL, Oracle, ...
    end

rollback_db_transaction() click to toggle source

Rolls back the transaction (and turns on auto-committing). Must be done if the transaction block raises an exception or returns false.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 202
    def rollback_db_transaction() end

sanitize_limit(limit) click to toggle source

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 lib/active_record/connection_adapters/abstract/database_statements.rb, line 263
    def sanitize_limit(limit)
      if limit.is_a?(Integer) || limit.is_a?(Arel::Nodes::SqlLiteral)
        limit
      elsif limit.to_s =~ /,/
        Arel.sql limit.to_s.split(',').map{ |i| Integer(i) }.join(',')
      else
        Integer(limit)
      end
    end

select_all(sql, name = nil) click to toggle source

Returns an array of record hashes with the column names as keys and column values as values.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 6
    def select_all(sql, name = nil)
      select(sql, name)
    end

select_one(sql, name = nil) click to toggle source

Returns a record hash with the column names as keys and column values as values.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 12
    def select_one(sql, name = nil)
      result = select_all(sql, name)
      result.first if result
    end

select_rows(sql, name = nil) click to toggle source

Returns an array of arrays containing the field values. Order is the same as that returned by `columns`.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 33
    def select_rows(sql, name = nil)
    end

select_value(sql, name = nil) click to toggle source

Returns a single value from a record

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 18
    def select_value(sql, name = nil)
      if result = select_one(sql, name)
        result.values.first
      end
    end

select_values(sql, name = nil) click to toggle source

Returns an array of the values of the first column in a select:

    select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 26
    def select_values(sql, name = nil)
      result = select_rows(sql, name)
      result.map { |v| v[0] }
    end

transaction(options = {}) click to toggle source

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/savepoints.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 lib/active_record/connection_adapters/abstract/database_statements.rb, line 113
    def transaction(options = {})
      options.assert_valid_keys :requires_new, :joinable

      last_transaction_joinable = defined?(@transaction_joinable) ? @transaction_joinable : nil
      if options.has_key?(:joinable)
        @transaction_joinable = options[:joinable]
      else
        @transaction_joinable = true
      end
      requires_new = options[:requires_new] || !last_transaction_joinable

      transaction_open = false
      @_current_transaction_records ||= []

      begin
        if block_given?
          if requires_new || open_transactions == 0
            if open_transactions == 0
              begin_db_transaction
            elsif requires_new
              create_savepoint
            end
            increment_open_transactions
            transaction_open = true
            @_current_transaction_records.push([])
          end
          yield
        end
      rescue Exception => database_transaction_rollback
        if transaction_open && !outside_transaction?
          transaction_open = false
          decrement_open_transactions
          if open_transactions == 0
            rollback_db_transaction
            rollback_transaction_records(true)
          else
            rollback_to_savepoint
            rollback_transaction_records(false)
          end
        end
        raise unless database_transaction_rollback.is_a?(ActiveRecord::Rollback)
      end
    ensure
      @transaction_joinable = last_transaction_joinable

      if outside_transaction?
        @open_transactions = 0
      elsif transaction_open
        decrement_open_transactions
        begin
          if open_transactions == 0
            commit_db_transaction
            commit_transaction_records
          else
            release_savepoint
            save_point_records = @_current_transaction_records.pop
            unless save_point_records.blank?
              @_current_transaction_records.push([]) if @_current_transaction_records.empty?
              @_current_transaction_records.last.concat(save_point_records)
            end
          end
        rescue Exception => database_transaction_rollback
          if open_transactions == 0
            rollback_db_transaction
            rollback_transaction_records(true)
          else
            rollback_to_savepoint
            rollback_transaction_records(false)
          end
          raise
        end
      end
    end

update(sql, name = nil) click to toggle source

Executes the update statement and returns the number of rows affected.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 48
    def update(sql, name = nil)
      update_sql(sql, name)
    end

### Protected Instance Methods

commit_transaction_records() click to toggle source

Send a commit message to all records after they have been committed.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 318
    def commit_transaction_records #:nodoc
      records = @_current_transaction_records.flatten
      @_current_transaction_records.clear
      unless records.blank?
        records.uniq.each do |record|
          begin
            record.committed!
          rescue Exception => e
            record.logger.error(e) if record.respond_to?(:logger) && record.logger
          end
        end
      end
    end

delete_sql(sql, name = nil) click to toggle source

Executes the delete statement and returns the number of rows affected.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 292
    def delete_sql(sql, name = nil)
      update_sql(sql, name)
    end

insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) click to toggle source

Returns the last auto-generated ID from the affected table.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 281
    def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
      execute(sql, name)
      id_value
    end

rollback_transaction_records(rollback) click to toggle source

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 lib/active_record/connection_adapters/abstract/database_statements.rb, line 298
    def rollback_transaction_records(rollback) #:nodoc
      if rollback
        records = @_current_transaction_records.flatten
        @_current_transaction_records.clear
      else
        records = @_current_transaction_records.pop
      end

      unless records.blank?
        records.uniq.each do |record|
          begin
            record.rolledback!(rollback)
          rescue Exception => e
            record.logger.error(e) if record.respond_to?(:logger) && record.logger
          end
        end
      end
    end

select(sql, name = nil) click to toggle source

Returns an array of record hashes with the column names as keys and column values as values.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 276
    def select(sql, name = nil)
    end

update_sql(sql, name = nil) click to toggle source

Executes the update statement and returns the number of rows affected.

    # File lib/active_record/connection_adapters/abstract/database_statements.rb, line 287
    def update_sql(sql, name = nil)
      execute(sql, name)
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.