activerecord 4.1.15 → 4.2.0.beta1

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

@@ -58,13 +58,11 @@ module ActiveRecord
     # * +checkout_timeout+: number of seconds to block and wait for a connection
     #   before giving up and raising a timeout error (default 5 seconds).
     # * +reaping_frequency+: frequency in seconds to periodically run the
-    #   Reaper, which attempts to find and close dead connections, which can
-    #   occur if a programmer forgets to close a connection at the end of a
-    #   thread or a thread dies unexpectedly. (Default nil, which means don't
-    #   run the Reaper).
-    # * +dead_connection_timeout+: number of seconds from last checkout
-    #   after which the Reaper will consider a connection reapable. (default
-    #   5 seconds).
+    #   Reaper, which attempts to find and recover connections from dead
+    #   threads, which can occur if a programmer forgets to close a
+    #   connection at the end of a thread or a thread dies unexpectedly.
+    #   Regardless of this setting, the Reaper will be invoked before every
+    #   blocking wait. (Default nil, which means don't schedule the Reaper).
     class ConnectionPool
       # Threadsafe, fair, FIFO queue.  Meant to be used by ConnectionPool
       # with which it shares a Monitor.  But could be a generic Queue.
@@ -222,7 +220,7 @@ module ActiveRecord
 
       include MonitorMixin
 
-      attr_accessor :automatic_reconnect, :checkout_timeout, :dead_connection_timeout
+      attr_accessor :automatic_reconnect, :checkout_timeout
       attr_reader :spec, :connections, :size, :reaper
 
       # Creates a new ConnectionPool object. +spec+ is a ConnectionSpecification
@@ -237,8 +235,7 @@ module ActiveRecord
         @spec = spec
 
         @checkout_timeout = (spec.config[:checkout_timeout] && spec.config[:checkout_timeout].to_f) || 5
-        @dead_connection_timeout = (spec.config[:dead_connection_timeout] && spec.config[:dead_connection_timeout].to_f) || 5
-        @reaper = Reaper.new(self, (spec.config[:reaping_frequency] && spec.config[:reaping_frequency].to_f))
+        @reaper  = Reaper.new self, spec.config[:reaping_frequency]
         @reaper.run
 
         # default max pool size to 5
@@ -361,11 +358,13 @@ module ActiveRecord
       # calling +checkout+ on this pool.
       def checkin(conn)
         synchronize do
+          owner = conn.owner
+
           conn.run_callbacks :checkin do
             conn.expire
           end
 
-          release conn
+          release owner
 
           @available.add conn
         end
@@ -378,22 +377,28 @@ module ActiveRecord
           @connections.delete conn
           @available.delete conn
 
-          # FIXME: we might want to store the key on the connection so that removing
-          # from the reserved hash will be a little easier.
-          release conn
+          release conn.owner
 
           @available.add checkout_new_connection if @available.any_waiting?
         end
       end
 
-      # Removes dead connections from the pool.  A dead connection can occur
-      # if a programmer forgets to close a connection at the end of a thread
+      # Recover lost connections for the pool.  A lost connection can occur if
+      # a programmer forgets to checkin a connection at the end of a thread
       # or a thread dies unexpectedly.
       def reap
-        synchronize do
-          stale = Time.now - @dead_connection_timeout
-          connections.dup.each do |conn|
-            if conn.in_use? && stale > conn.last_use && !conn.active_threadsafe?
+        stale_connections = synchronize do
+          @connections.select do |conn|
+            conn.in_use? && !conn.owner.alive?
+          end
+        end
+
+        stale_connections.each do |conn|
+          synchronize do
+            if conn.active?
+              conn.reset!
+              checkin conn
+            else
               remove conn
             end
           end
@@ -415,20 +420,15 @@ module ActiveRecord
         elsif @connections.size < @size
           checkout_new_connection
         else
+          reap
           @available.poll(@checkout_timeout)
         end
       end
 
-      def release(conn)
-        thread_id = if @reserved_connections[current_connection_id] == conn
-          current_connection_id
-        else
-          @reserved_connections.keys.find { |k|
-            @reserved_connections[k] == conn
-          }
-        end
+      def release(owner)
+        thread_id = owner.object_id
 
-        @reserved_connections.delete thread_id if thread_id
+        @reserved_connections.delete thread_id
       end
 
       def new_connection
@@ -462,23 +462,44 @@ module ActiveRecord
     #
     # For example, suppose that you have 5 models, with the following hierarchy:
     #
-    #  |
-    #  +-- Book
-    #  |    |
-    #  |    +-- ScaryBook
-    #  |    +-- GoodBook
-    #  +-- Author
-    #  +-- BankAccount
+    #   class Author < ActiveRecord::Base
+    #   end
+    #
+    #   class BankAccount < ActiveRecord::Base
+    #   end
+    #
+    #   class Book < ActiveRecord::Base
+    #     establish_connection "library_db"
+    #   end
+    #
+    #   class ScaryBook < Book
+    #   end
+    #
+    #   class GoodBook < Book
+    #   end
+    #
+    # And a database.yml that looked like this:
+    #
+    #   development:
+    #     database: my_application
+    #     host: localhost
+    #
+    #   library_db:
+    #     database: library
+    #     host: some.library.org
+    #
+    # Your primary database in the development environment is "my_application"
+    # but the Book model connects to a separate database called "library_db"
+    # (this can even be a database on a different machine).
     #
-    # Suppose that Book is to connect to a separate database (i.e. one other
-    # than the default database). Then Book, ScaryBook and GoodBook will all use
-    # the same connection pool. Likewise, Author and BankAccount will use the
-    # same connection pool. However, the connection pool used by Author/BankAccount
-    # is not the same as the one used by Book/ScaryBook/GoodBook.
+    # Book, ScaryBook and GoodBook will all use the same connection pool to
+    # "library_db" while Author, BankAccount, and any other models you create
+    # will use the default connection pool to "my_application".
     #
-    # Normally there is only a single ConnectionHandler instance, accessible via
-    # ActiveRecord::Base.connection_handler. Active Record models use this to
-    # determine the connection pool that they should use.
+    # The various connection pools are managed by a single instance of
+    # ConnectionHandler accessible via ActiveRecord::Base.connection_handler.
+    # All Active Record models use this handler to determine the connection pool that they
+    # should use.
     class ConnectionHandler
       def initialize
         # These caches are keyed by klass.name, NOT klass. Keying them by klass
@@ -538,7 +559,10 @@ module ActiveRecord
       # for (not necessarily the current class).
       def retrieve_connection(klass) #:nodoc:
         pool = retrieve_connection_pool(klass)
-        (pool && pool.connection) or raise ConnectionNotEstablished
+        raise ConnectionNotEstablished, "No connection pool for #{klass}" unless pool
+        conn = pool.connection
+        raise ConnectionNotEstablished, "No connection for #{klass} in connection pool" unless conn
+        conn
       end
 
       # Returns true if a connection that's accessible to this class has

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

@@ -9,15 +9,23 @@ module ActiveRecord
       # Converts an arel AST to SQL
       def to_sql(arel, binds = [])
         if arel.respond_to?(:ast)
-          binds = binds.dup
-          visitor.accept(arel.ast) do
-            quote(*binds.shift.reverse)
-          end
+          collected = visitor.accept(arel.ast, collector)
+          collected.compile(binds.dup, self)
         else
           arel
         end
       end
 
+      # This is used in the StatementCache object. It returns an object that
+      # can be used to query the database repeatedly.
+      def cacheable_query(arel) # :nodoc:
+        if prepared_statements
+          ActiveRecord::StatementCache.query visitor, arel.ast
+        else
+          ActiveRecord::StatementCache.partial_query visitor, arel.ast, collector
+        end
+      end
+
       # Returns an ActiveRecord::Result instance.
       def select_all(arel, name = nil, binds = [])
         arel, binds = binds_from_relation arel, binds
@@ -185,7 +193,7 @@ module ActiveRecord
       # * You are creating a nested (savepoint) transaction
       #
       # The mysql, mysql2 and postgresql adapters support setting the transaction
-      # isolation level. However, support is disabled for mysql versions below 5,
+      # isolation level. However, support is disabled for MySQL versions below 5,
       # because they are affected by a bug[http://bugs.mysql.com/bug.php?id=39170]
       # which means the isolation level gets persisted outside the transaction.
       def transaction(options = {})
@@ -195,58 +203,30 @@ module ActiveRecord
           if options[:isolation]
             raise ActiveRecord::TransactionIsolationError, "cannot set isolation when joining a transaction"
           end
-
           yield
         else
-          within_new_transaction(options) { yield }
+          transaction_manager.within_new_transaction(options) { yield }
         end
       rescue ActiveRecord::Rollback
         # rollbacks are silently swallowed
       end
 
-      def within_new_transaction(options = {}) #:nodoc:
-        transaction = begin_transaction(options)
-        yield
-      rescue Exception => error
-        rollback_transaction if transaction
-        raise
-      ensure
-        begin
-          commit_transaction unless error
-        rescue Exception
-          rollback_transaction
-          raise
-        end
-      end
+      attr_reader :transaction_manager #:nodoc:
 
-      def current_transaction #:nodoc:
-        @transaction
-      end
+      delegate :within_new_transaction, :open_transactions, :current_transaction, :begin_transaction, :commit_transaction, :rollback_transaction, to: :transaction_manager
 
       def transaction_open?
-        @transaction.open?
-      end
-
-      def begin_transaction(options = {}) #:nodoc:
-        @transaction = @transaction.begin(options)
-      end
-
-      def commit_transaction #:nodoc:
-        @transaction = @transaction.commit
-      end
-
-      def rollback_transaction #:nodoc:
-        @transaction = @transaction.rollback
+        current_transaction.open?
       end
 
       def reset_transaction #:nodoc:
-        @transaction = ClosedTransaction.new(self)
+        @transaction_manager = TransactionManager.new(self)
       end
 
       # Register a record with the current transaction so that its after_commit and after_rollback callbacks
       # can be called.
       def add_transaction_record(record)
-        @transaction.add_record(record)
+        current_transaction.add_record(record)
       end
 
       # Begins the transaction (and turns off auto-committing).
@@ -326,8 +306,8 @@ module ActiveRecord
       end
 
       # The default strategy for an UPDATE with joins is to use a subquery. This doesn't work
-      # on mysql (even when aliasing the tables), but mysql allows using JOIN directly in
-      # an UPDATE statement, so in the mysql adapters we redefine this to do that.
+      # on MySQL (even when aliasing the tables), but MySQL allows using JOIN directly in
+      # an UPDATE statement, so in the MySQL adapters we redefine this to do that.
       def join_to_update(update, select) #:nodoc:
         key = update.key
         subselect = subquery_for(key, select)
@@ -381,7 +361,7 @@ module ActiveRecord
         end
 
         def binds_from_relation(relation, binds)
-          if relation.is_a?(Relation) && binds.blank?
+          if relation.is_a?(Relation) && binds.empty?
             relation, binds = relation.arel, relation.bind_values
           end
           [relation, binds]

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

@@ -9,39 +9,11 @@ module ActiveRecord
         # records are quoted as their primary key
         return value.quoted_id if value.respond_to?(:quoted_id)
 
-        case value
-        when String, ActiveSupport::Multibyte::Chars
-          value = value.to_s
-          return "'#{quote_string(value)}'" unless column
-
-          case column.type
-          when :integer then value.to_i.to_s
-          when :float then value.to_f.to_s
-          else
-            "'#{quote_string(value)}'"
-          end
-
-        when true, false
-          if column && column.type == :integer
-            value ? '1' : '0'
-          else
-            value ? quoted_true : quoted_false
-          end
-          # BigDecimals need to be put in a non-normalized form and quoted.
-        when nil        then "NULL"
-        when BigDecimal then value.to_s('F')
-        when Numeric, ActiveSupport::Duration
-          if column.try(:type) == :string
-            quote(value.to_s, column)
-          else
-            value.to_s
-          end
-        when Date, Time then "'#{quoted_date(value)}'"
-        when Symbol     then "'#{quote_string(value.to_s)}'"
-        when Class      then "'#{value.to_s}'"
-        else
-          "'#{quote_string(YAML.dump(value))}'"
+        if column
+          value = column.cast_type.type_cast_for_database(value)
         end
+
+        _quote(value)
       end
 
       # Cast a +value+ to a type that the database understands. For example,
@@ -52,34 +24,14 @@ module ActiveRecord
           return value.id
         end
 
-        case value
-        when String, ActiveSupport::Multibyte::Chars
-          value = value.to_s
-          return value unless column
-
-          case column.type
-          when :integer then value.to_i
-          when :float then value.to_f
-          else
-            value
-          end
-
-        when true, false
-          if column && column.type == :integer
-            value ? 1 : 0
-          else
-            value ? 't' : 'f'
-          end
-          # BigDecimals need to be put in a non-normalized form and quoted.
-        when nil        then nil
-        when BigDecimal then value.to_s('F')
-        when Numeric    then value
-        when Date, Time then quoted_date(value)
-        when Symbol     then value.to_s
-        else
-          to_type = column ? " to #{column.type}" : ""
-          raise TypeError, "can't cast #{value.class}#{to_type}"
+        if column
+          value = column.cast_type.type_cast_for_database(value)
         end
+
+        _type_cast(value)
+      rescue TypeError
+        to_type = column ? " to #{column.type}" : ""
+        raise TypeError, "can't cast #{value.class}#{to_type}"
       end
 
       # Quotes a string, escaping any ' (single quote) and \ (backslash)
@@ -104,7 +56,7 @@ module ActiveRecord
       # This works for mysql and mysql2 where table.column can be used to
       # resolve ambiguity.
       #
-      # We override this in the sqlite and postgresql adapters to use only
+      # We override this in the sqlite3 and postgresql adapters to use only
       # the column name (as per syntax requirements).
       def quote_table_name_for_assignment(table, attr)
         quote_table_name("#{table}.#{attr}")
@@ -114,10 +66,18 @@ module ActiveRecord
         "'t'"
       end
 
+      def unquoted_true
+        't'
+      end
+
       def quoted_false
         "'f'"
       end
 
+      def unquoted_false
+        'f'
+      end
+
       def quoted_date(value)
         if value.acts_like?(:time)
           zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
@@ -129,6 +89,45 @@ module ActiveRecord
 
         value.to_s(:db)
       end
+
+      private
+
+      def types_which_need_no_typecasting
+        [nil, Numeric, String]
+      end
+
+      def _quote(value)
+        case value
+        when String, ActiveSupport::Multibyte::Chars, Type::Binary::Data
+          "'#{quote_string(value.to_s)}'"
+        when true       then quoted_true
+        when false      then quoted_false
+        when nil        then "NULL"
+        # BigDecimals need to be put in a non-normalized form and quoted.
+        when BigDecimal then value.to_s('F')
+        when Numeric, ActiveSupport::Duration then value.to_s
+        when Date, Time then "'#{quoted_date(value)}'"
+        when Symbol     then "'#{quote_string(value.to_s)}'"
+        when Class      then "'#{value.to_s}'"
+        else
+          "'#{quote_string(YAML.dump(value))}'"
+        end
+      end
+
+      def _type_cast(value)
+        case value
+        when Symbol, ActiveSupport::Multibyte::Chars, Type::Binary::Data
+          value.to_s
+        when true       then unquoted_true
+        when false      then unquoted_false
+        # BigDecimals need to be put in a non-normalized form and quoted.
+        when BigDecimal then value.to_s('F')
+        when Date, Time then quoted_date(value)
+        when *types_which_need_no_typecasting
+          value
+        else raise TypeError
+        end
+      end
     end
   end
 end

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

@@ -13,7 +13,7 @@ module ActiveRecord
         end
 
         def visit_AddColumn(o)
-          sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
+          sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale)
           sql = "ADD #{quote_column_name(o.name)} #{sql_type}"
           add_column_options!(sql, column_options(o))
         end
@@ -23,10 +23,12 @@ module ActiveRecord
           def visit_AlterTable(o)
             sql = "ALTER TABLE #{quote_table_name(o.name)} "
             sql << o.adds.map { |col| visit_AddColumn col }.join(' ')
+            sql << o.foreign_key_adds.map { |fk| visit_AddForeignKey fk }.join(' ')
+            sql << o.foreign_key_drops.map { |fk| visit_DropForeignKey fk }.join(' ')
           end
 
           def visit_ColumnDefinition(o)
-            sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
+            sql_type = type_to_sql(o.type, 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
@@ -41,6 +43,21 @@ module ActiveRecord
             create_sql
           end
 
+          def visit_AddForeignKey(o)
+            sql = <<-SQL.strip_heredoc
+              ADD CONSTRAINT #{quote_column_name(o.name)}
+              FOREIGN KEY (#{quote_column_name(o.column)})
+                REFERENCES #{quote_table_name(o.to_table)} (#{quote_column_name(o.primary_key)})
+            SQL
+            sql << " #{action_sql('DELETE', o.on_delete)}" if o.on_delete
+            sql << " #{action_sql('UPDATE', o.on_update)}" if o.on_update
+            sql
+          end
+
+          def visit_DropForeignKey(name)
+            "DROP CONSTRAINT #{quote_column_name(name)}"
+          end
+
           def column_options(o)
             column_options = {}
             column_options[:null] = o.null unless o.null.nil?
@@ -77,6 +94,7 @@ module ActiveRecord
 
           def quote_value(value, column)
             column.sql_type ||= type_to_sql(column.type, column.limit, column.precision, column.scale)
+            column.cast_type ||= type_for_column(column)
 
             @conn.quote(value, column)
           end
@@ -84,6 +102,23 @@ module ActiveRecord
           def options_include_default?(options)
             options.include?(:default) && !(options[:null] == false && options[:default].nil?)
           end
+
+          def action_sql(action, dependency)
+            case dependency
+            when :nullify then "ON #{action} SET NULL"
+            when :cascade  then "ON #{action} CASCADE"
+            when :restrict then "ON #{action} RESTRICT"
+            else
+              raise ArgumentError, <<-MSG.strip_heredoc
+                '#{dependency}' is not supported for :on_update or :on_delete.
+                Supported values are: :nullify, :cascade, :restrict
+              MSG
+            end
+          end
+
+          def type_for_column(column)
+            @conn.lookup_cast_type(column.sql_type)
+          end
       end
     end
   end