activerecord 3.0.0 → 4.0.0

data/lib/active_record/connection_adapters/abstract/transaction.rb

@@ -0,0 +1,203 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class Transaction #:nodoc:
+      attr_reader :connection
+
+      def initialize(connection)
+        @connection = connection
+        @state = TransactionState.new
+      end
+
+      def state
+        @state
+      end
+    end
+
+    class TransactionState
+      attr_accessor :parent
+
+      VALID_STATES = Set.new([:committed, :rolledback, nil])
+
+      def initialize(state = nil)
+        @state = state
+        @parent = nil
+      end
+
+      def committed?
+        @state == :committed
+      end
+
+      def rolledback?
+        @state == :rolledback
+      end
+
+      def set_state(state)
+        if !VALID_STATES.include?(state)
+          raise ArgumentError, "Invalid transaction state: #{state}"
+        end
+        @state = state
+      end
+    end
+
+    class ClosedTransaction < Transaction #:nodoc:
+      def number
+        0
+      end
+
+      def begin(options = {})
+        RealTransaction.new(connection, self, options)
+      end
+
+      def closed?
+        true
+      end
+
+      def open?
+        false
+      end
+
+      def joinable?
+        false
+      end
+
+      # This is a noop when there are no open transactions
+      def add_record(record)
+      end
+    end
+
+    class OpenTransaction < Transaction #:nodoc:
+      attr_reader :parent, :records
+      attr_writer :joinable
+
+      def initialize(connection, parent, options = {})
+        super connection
+
+        @parent    = parent
+        @records   = []
+        @finishing = false
+        @joinable  = options.fetch(:joinable, true)
+      end
+
+      # This state is necessary so that we correctly handle stuff that might
+      # happen in a commit/rollback. But it's kinda distasteful. Maybe we can
+      # find a better way to structure it in the future.
+      def finishing?
+        @finishing
+      end
+
+      def joinable?
+        @joinable && !finishing?
+      end
+
+      def number
+        if finishing?
+          parent.number
+        else
+          parent.number + 1
+        end
+      end
+
+      def begin(options = {})
+        if finishing?
+          parent.begin
+        else
+          SavepointTransaction.new(connection, self, options)
+        end
+      end
+
+      def rollback
+        @finishing = true
+        perform_rollback
+        parent
+      end
+
+      def commit
+        @finishing = true
+        perform_commit
+        parent
+      end
+
+      def add_record(record)
+        if record.has_transactional_callbacks?
+          records << record
+        else
+          record.set_transaction_state(@state)
+        end
+      end
+
+      def rollback_records
+        @state.set_state(:rolledback)
+        records.uniq.each do |record|
+          begin
+            record.rolledback!(parent.closed?)
+          rescue => e
+            record.logger.error(e) if record.respond_to?(:logger) && record.logger
+          end
+        end
+      end
+
+      def commit_records
+        @state.set_state(:committed)
+        records.uniq.each do |record|
+          begin
+            record.committed!
+          rescue => e
+            record.logger.error(e) if record.respond_to?(:logger) && record.logger
+          end
+        end
+      end
+
+      def closed?
+        false
+      end
+
+      def open?
+        true
+      end
+    end
+
+    class RealTransaction < OpenTransaction #:nodoc:
+      def initialize(connection, parent, options = {})
+        super
+
+        if options[:isolation]
+          connection.begin_isolated_db_transaction(options[:isolation])
+        else
+          connection.begin_db_transaction
+        end
+      end
+
+      def perform_rollback
+        connection.rollback_db_transaction
+        rollback_records
+      end
+
+      def perform_commit
+        connection.commit_db_transaction
+        commit_records
+      end
+    end
+
+    class SavepointTransaction < OpenTransaction #:nodoc:
+      def initialize(connection, parent, options = {})
+        if options[:isolation]
+          raise ActiveRecord::TransactionIsolationError, "cannot set transaction isolation in a nested transaction"
+        end
+
+        super
+        connection.create_savepoint
+      end
+
+      def perform_rollback
+        connection.rollback_to_savepoint
+        rollback_records
+      end
+
+      def perform_commit
+        @state.set_state(:committed)
+        @state.parent = parent.state
+        connection.release_savepoint
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -2,19 +2,45 @@ require 'date'
 require 'bigdecimal'
 require 'bigdecimal/util'
 require 'active_support/core_ext/benchmark'
-
-# TODO: Autoload these files
-require 'active_record/connection_adapters/abstract/schema_definitions'
-require 'active_record/connection_adapters/abstract/schema_statements'
-require 'active_record/connection_adapters/abstract/database_statements'
-require 'active_record/connection_adapters/abstract/quoting'
-require 'active_record/connection_adapters/abstract/connection_pool'
-require 'active_record/connection_adapters/abstract/connection_specification'
-require 'active_record/connection_adapters/abstract/query_cache'
-require 'active_record/connection_adapters/abstract/database_limits'
+require 'active_record/connection_adapters/schema_cache'
+require 'active_record/connection_adapters/abstract/schema_dumper'
+require 'monitor'
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
+    extend ActiveSupport::Autoload
+
+    autoload :Column
+    autoload :ConnectionSpecification
+
+    autoload_at 'active_record/connection_adapters/abstract/schema_definitions' do
+      autoload :IndexDefinition
+      autoload :ColumnDefinition
+      autoload :TableDefinition
+      autoload :Table
+      autoload :AlterTable
+    end
+
+    autoload_at 'active_record/connection_adapters/abstract/connection_pool' do
+      autoload :ConnectionHandler
+      autoload :ConnectionManagement
+    end
+
+    autoload_under 'abstract' do
+      autoload :SchemaStatements
+      autoload :DatabaseStatements
+      autoload :DatabaseLimits
+      autoload :Quoting
+      autoload :ConnectionPool
+      autoload :QueryCache
+    end
+
+    autoload_at 'active_record/connection_adapters/abstract/transaction' do
+      autoload :ClosedTransaction
+      autoload :RealTransaction
+      autoload :SavepointTransaction
+    end
+
     # Active Record supports multiple database systems. AbstractAdapter and
     # related classes form the abstraction layer which makes this possible.
     # An AbstractAdapter represents a connection to a database, and provides an
@@ -33,68 +59,245 @@ module ActiveRecord
       include DatabaseLimits
       include QueryCache
       include ActiveSupport::Callbacks
+      include MonitorMixin
+      include ColumnDumper
+
+      SIMPLE_INT = /\A\d+\z/
 
       define_callbacks :checkout, :checkin
 
-      def initialize(connection, logger = nil) #:nodoc:
-        @active = nil
-        @connection, @logger = connection, logger
+      attr_accessor :visitor, :pool
+      attr_reader :schema_cache, :last_use, :in_use, :logger
+      alias :in_use? :in_use
+
+      def self.type_cast_config_to_integer(config)
+        if config =~ SIMPLE_INT
+          config.to_i
+        else
+          config
+        end
+      end
+
+      def self.type_cast_config_to_boolean(config)
+        if config == "false"
+          false
+        else
+          config
+        end
+      end
+
+      def initialize(connection, logger = nil, pool = nil) #:nodoc:
+        super()
+
+        @connection          = connection
+        @in_use              = false
+        @instrumenter        = ActiveSupport::Notifications.instrumenter
+        @last_use            = false
+        @logger              = logger
+        @pool                = pool
+        @query_cache         = Hash.new { |h,sql| h[sql] = {} }
         @query_cache_enabled = false
-        @query_cache = {}
-        @instrumenter = ActiveSupport::Notifications.instrumenter
+        @schema_cache        = SchemaCache.new self
+        @visitor             = nil
+      end
+
+      def valid_type?(type)
+        true
+      end
+
+      class SchemaCreation
+        def initialize(conn)
+          @conn  = conn
+          @cache = {}
+        end
+
+        def accept(o)
+          m = @cache[o.class] ||= "visit_#{o.class.name.split('::').last}"
+          send m, o
+        end
+
+        private
+
+        def visit_AlterTable(o)
+          sql = "ALTER TABLE #{quote_table_name(o.name)} "
+          sql << o.adds.map { |col| visit_AddColumn col }.join(' ')
+        end
+
+        def visit_AddColumn(o)
+          sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
+          sql = "ADD #{quote_column_name(o.name)} #{sql_type}"
+          add_column_options!(sql, column_options(o))
+        end
+
+        def visit_ColumnDefinition(o)
+          sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
+          column_sql = "#{quote_column_name(o.name)} #{sql_type}"
+          add_column_options!(column_sql, column_options(o)) unless o.primary_key?
+          column_sql
+        end
+
+        def visit_TableDefinition(o)
+          create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE "
+          create_sql << "#{quote_table_name(o.name)} ("
+          create_sql << o.columns.map { |c| accept c }.join(', ')
+          create_sql << ") #{o.options}"
+          create_sql
+        end
+
+        def column_options(o)
+          column_options = {}
+          column_options[:null] = o.null unless o.null.nil?
+          column_options[:default] = o.default unless o.default.nil?
+          column_options[:column] = o
+          column_options
+        end
+
+        def quote_column_name(name)
+          @conn.quote_column_name name
+        end
+
+        def quote_table_name(name)
+          @conn.quote_table_name name
+        end
+
+        def type_to_sql(type, limit, precision, scale)
+          @conn.type_to_sql type.to_sym, limit, precision, scale
+        end
+
+        def add_column_options!(column_sql, column_options)
+          @conn.add_column_options! column_sql, column_options
+          column_sql
+        end
       end
 
-      # Returns the human-readable name of the adapter.  Use mixed case - one
+      def schema_creation
+        SchemaCreation.new self
+      end
+
+      def lease
+        synchronize do
+          unless in_use
+            @in_use   = true
+            @last_use = Time.now
+          end
+        end
+      end
+
+      def schema_cache=(cache)
+        cache.connection = self
+        @schema_cache = cache
+      end
+
+      def expire
+        @in_use = false
+      end
+
+      def unprepared_visitor
+        self.class::BindSubstitution.new self
+      end
+
+      def unprepared_statement
+        old, @visitor = @visitor, unprepared_visitor
+        yield
+      ensure
+        @visitor = old
+      end
+
+      # Returns the human-readable name of the adapter. Use mixed case - one
       # can always use downcase if needed.
       def adapter_name
         'Abstract'
       end
 
-      # Does this adapter support migrations?  Backend specific, as the
+      # Does this adapter support migrations? Backend specific, as the
       # abstract adapter always returns +false+.
       def supports_migrations?
         false
       end
 
       # Can this adapter determine the primary key for tables not attached
-      # to an Active Record class, such as join tables?  Backend specific, as
+      # to an Active Record class, such as join tables? Backend specific, as
       # the abstract adapter always returns +false+.
       def supports_primary_key?
         false
       end
 
-      # Does this adapter support using DISTINCT within COUNT?  This is +true+
+      # Does this adapter support using DISTINCT within COUNT? This is +true+
       # for all adapters except sqlite.
       def supports_count_distinct?
         true
       end
 
-      # Does this adapter support DDL rollbacks in transactions?  That is, would
-      # CREATE TABLE or ALTER TABLE get rolled back by a transaction?  PostgreSQL,
-      # SQL Server, and others support this.  MySQL and others do not.
+      # Does this adapter support DDL rollbacks in transactions? That is, would
+      # CREATE TABLE or ALTER TABLE get rolled back by a transaction? PostgreSQL,
+      # SQL Server, and others support this. MySQL and others do not.
       def supports_ddl_transactions?
         false
       end
 
-      # Does this adapter support savepoints? PostgreSQL and MySQL do, SQLite
-      # does not.
+      def supports_bulk_alter?
+        false
+      end
+
+      # Does this adapter support savepoints? PostgreSQL and MySQL do,
+      # SQLite < 3.6.8 does not.
       def supports_savepoints?
         false
       end
 
       # Should primary key values be selected from their corresponding
-      # sequence before the insert statement?  If true, next_sequence_value
+      # sequence before the insert statement? If true, next_sequence_value
       # is called before each insert to set the record's primary key.
       # This is false for all adapters but Firebird.
       def prefetch_primary_key?(table_name = nil)
         false
       end
 
+      # Does this adapter support index sort order?
+      def supports_index_sort_order?
+        false
+      end
+
+      # Does this adapter support partial indices?
+      def supports_partial_index?
+        false
+      end
+
+      # Does this adapter support explain? As of this writing sqlite3,
+      # mysql2, and postgresql are the only ones that do.
+      def supports_explain?
+        false
+      end
+
+      # Does this adapter support setting the isolation level for a transaction?
+      def supports_transaction_isolation?
+        false
+      end
+
+      # Does this adapter support database extensions? As of this writing only
+      # postgresql does.
+      def supports_extensions?
+        false
+      end
+
+      # A list of extensions, to be filled in by adapters that support them. At
+      # the moment only postgresql does.
+      def extensions
+        []
+      end
+
+      # A list of index algorithms, to be filled by adapters that support them.
+      # MySQL and PostgreSQL have support for them right now.
+      def index_algorithms
+        {}
+      end
+
       # QUOTING ==================================================
 
-      # Override to return the quoted table name. Defaults to column quoting.
-      def quote_table_name(name)
-        quote_column_name(name)
+      # Returns a bind substitution value given a +column+ and list of current
+      # +binds+.
+      def substitute_at(column, index)
+        Arel::Nodes::BindParam.new '?'
       end
 
       # REFERENTIAL INTEGRITY ====================================
@@ -110,19 +313,21 @@ module ActiveRecord
       # checking whether the database is actually capable of responding, i.e. whether
       # the connection isn't stale.
       def active?
-        @active != false
       end
 
       # Disconnects from the database if already connected, and establishes a
-      # new connection with the database.
+      # new connection with the database. Implementors should call super if they
+      # override the default implementation.
       def reconnect!
-        @active = true
+        clear_cache!
+        reset_transaction
       end
 
       # Disconnects from the database if already connected. Otherwise, this
       # method does nothing.
       def disconnect!
-        @active = false
+        clear_cache!
+        reset_transaction
       end
 
       # Reset the state of this connection, directing the DBMS to clear
@@ -135,6 +340,13 @@ module ActiveRecord
         # this should be overridden by concrete adapters
       end
 
+      ###
+      # Clear any caching the database adapter may be doing, for example
+      # clearing the prepared statement cache. This is database specific.
+      def clear_cache!
+        # this should be overridden by concrete adapters
+      end
+
       # Returns true if its required to reload the connection between requests for development mode.
       # This is not the case for Ruby/MySQL and it's not necessary for any adapters except SQLite.
       def requires_reloading?
@@ -159,20 +371,21 @@ module ActiveRecord
       end
 
       def open_transactions
-        @open_transactions ||= 0
+        @transaction.number
       end
 
       def increment_open_transactions
-        @open_transactions ||= 0
-        @open_transactions += 1
+        ActiveSupport::Deprecation.warn "#increment_open_transactions is deprecated and has no effect"
       end
 
       def decrement_open_transactions
-        @open_transactions -= 1
+        ActiveSupport::Deprecation.warn "#decrement_open_transactions is deprecated and has no effect"
       end
 
       def transaction_joinable=(joinable)
-        @transaction_joinable = joinable
+        message = "#transaction_joinable= is deprecated. Please pass the :joinable option to #begin_transaction instead."
+        ActiveSupport::Deprecation.warn message
+        @transaction.joinable = joinable
       end
 
       def create_savepoint
@@ -184,29 +397,44 @@ module ActiveRecord
       def release_savepoint
       end
 
+      def case_sensitive_modifier(node)
+        node
+      end
+
+      def case_insensitive_comparison(table, attribute, column, value)
+        table[attribute].lower.eq(table.lower(value))
+      end
+
       def current_savepoint_name
         "active_record_#{open_transactions}"
       end
 
-      protected
+      # Check the connection back in to the connection pool
+      def close
+        pool.checkin self
+      end
 
-        def log(sql, name)
-          name ||= "SQL"
-          @instrumenter.instrument("sql.active_record",
-            :sql => sql, :name => name, :connection_id => object_id) do
-            yield
-          end
-        rescue Exception => e
-          message = "#{e.class.name}: #{e.message}: #{sql}"
-          @logger.debug message if @logger
-          raise translate_exception(e, message)
-        end
+      protected
 
-        def translate_exception(e, message)
-          # override in derived class
-          ActiveRecord::StatementInvalid.new(message)
-        end
+      def log(sql, name = "SQL", binds = [])
+        @instrumenter.instrument(
+          "sql.active_record",
+          :sql           => sql,
+          :name          => name,
+          :connection_id => object_id,
+          :binds         => binds) { yield }
+      rescue => e
+        message = "#{e.class.name}: #{e.message}: #{sql}"
+        @logger.error message if @logger
+        exception = translate_exception(e, message)
+        exception.set_backtrace e.backtrace
+        raise exception
+      end
 
+      def translate_exception(exception, message)
+        # override in derived class
+        ActiveRecord::StatementInvalid.new(message, exception)
+      end
     end
   end
 end