activerecord 4.1.0 → 4.2.0

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

@@ -2,6 +2,7 @@ require 'thread'
 require 'thread_safe'
 require 'monitor'
 require 'set'
+require 'active_support/core_ext/string/filters'
 
 module ActiveRecord
   # Raised when a connection could not be obtained within the connection
@@ -58,13 +59,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 +221,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
@@ -236,8 +235,7 @@ module ActiveRecord
 
         @spec = spec
 
-        @checkout_timeout = spec.config[:checkout_timeout] || 5
-        @dead_connection_timeout = spec.config[:dead_connection_timeout] || 5
+        @checkout_timeout = (spec.config[:checkout_timeout] && spec.config[:checkout_timeout].to_f) || 5
         @reaper  = Reaper.new self, spec.config[:reaping_frequency]
         @reaper.run
 
@@ -361,11 +359,13 @@ module ActiveRecord
       # calling +checkout+ on this pool.
       def checkin(conn)
         synchronize do
-          conn.run_callbacks :checkin do
+          owner = conn.owner
+
+          conn._run_checkin_callbacks do
             conn.expire
           end
 
-          release conn
+          release owner
 
           @available.add conn
         end
@@ -378,22 +378,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 +421,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
@@ -449,7 +450,7 @@ module ActiveRecord
       end
 
       def checkout_and_verify(c)
-        c.run_callbacks :checkout do
+        c._run_checkout_callbacks do
           c.verify!
         end
         c
@@ -462,23 +463,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
     #
-    # 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.
+    #   class BankAccount < ActiveRecord::Base
+    #   end
     #
-    # 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.
+    #   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).
+    #
+    # 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".
+    #
+    # 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
@@ -497,10 +519,11 @@ module ActiveRecord
       end
 
       def connection_pools
-        ActiveSupport::Deprecation.warn(
-          "In the next release, this will return the same as #connection_pool_list. " \
-          "(An array of pools, rather than a hash mapping specs to pools.)"
-        )
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          In the next release, this will return the same as `#connection_pool_list`.
+          (An array of pools, rather than a hash mapping specs to pools.)
+        MSG
+
         Hash[connection_pool_list.map { |pool| [pool.spec, pool] }]
       end
 
@@ -538,7 +561,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
@@ -616,7 +642,7 @@ module ActiveRecord
       end
 
       def call(env)
-        testing = env.key?('rack.test')
+        testing = env['rack.test']
 
         response = @app.call(env)
         response[2] = ::Rack::BodyProxy.new(response[2]) do

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

@@ -9,25 +9,26 @@ 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
 
-      # Returns an ActiveRecord::Result instance.
-      def select_all(arel, name = nil, binds = [])
-        if arel.is_a?(Relation)
-          relation = arel
-          arel = relation.arel
-          if !binds || binds.empty?
-            binds = relation.bind_values
-          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
         select(to_sql(arel, binds), name, binds)
       end
 
@@ -47,10 +48,7 @@ module ActiveRecord
       # Returns an array of the values of the first column in a select:
       #   select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
       def select_values(arel, name = nil)
-        binds = []
-        if arel.is_a?(Relation)
-          arel, binds = arel.arel, arel.bind_values
-        end
+        arel, binds = binds_from_relation arel, []
         select_rows(to_sql(arel, binds), name, binds).map(&:first)
       end
 
@@ -85,6 +83,11 @@ module ActiveRecord
         exec_query(sql, name, binds)
       end
 
+      # Executes the truncate statement.
+      def truncate(table_name, name = nil)
+        raise NotImplementedError
+      end
+
       # Executes update +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
@@ -195,7 +198,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 = {})
@@ -205,58 +208,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).
@@ -312,10 +287,6 @@ module ActiveRecord
         "DEFAULT VALUES"
       end
 
-      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
-
       # 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
@@ -328,7 +299,7 @@ module ActiveRecord
       def sanitize_limit(limit)
         if limit.is_a?(Integer) || limit.is_a?(Arel::Nodes::SqlLiteral)
           limit
-        elsif limit.to_s =~ /,/
+        elsif limit.to_s.include?(',')
           Arel.sql limit.to_s.split(',').map{ |i| Integer(i) }.join(',')
         else
           Integer(limit)
@@ -336,8 +307,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)
@@ -362,8 +333,9 @@ module ActiveRecord
 
         # Returns an ActiveRecord::Result instance.
         def select(sql, name = nil, binds = [])
+          exec_query(sql, name, binds)
         end
-        undef_method :select
+
 
         # Returns the last auto-generated ID from the affected table.
         def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
@@ -389,6 +361,13 @@ module ActiveRecord
           row = result.rows.first
           row && row.first
         end
+
+        def binds_from_relation(relation, binds)
+          if relation.is_a?(Relation) && binds.empty?
+            relation, binds = relation.arel, relation.bind_values
+          end
+          [relation, binds]
+        end
     end
   end
 end

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

@@ -63,6 +63,7 @@ module ActiveRecord
 
       def select_all(arel, name = nil, binds = [])
         if @query_cache_enabled && !locked?(arel)
+          arel, binds = binds_from_relation arel, binds
           sql = to_sql(arel, binds)
           cache_sql(sql, binds) { super(sql, name, binds) }
         else

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

@@ -9,34 +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 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))}'"
+        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,
@@ -47,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)
@@ -99,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}")
@@ -109,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
@@ -124,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}'"
+        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

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/string/strip'
+
 module ActiveRecord
   module ConnectionAdapters
     class AbstractAdapter
@@ -13,9 +15,7 @@ module ActiveRecord
         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))
+          "ADD #{accept(o)}"
         end
 
         private
@@ -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?
@@ -64,7 +81,7 @@ module ActiveRecord
           end
 
           def add_column_options!(sql, options)
-            sql << " DEFAULT #{@conn.quote(options[:default], options[:column])}" if options_include_default?(options)
+            sql << " DEFAULT #{quote_value(options[:default], options[:column])}" if options_include_default?(options)
             # must explicitly check for :null to allow change_column to work on migrations
             if options[:null] == false
               sql << " NOT NULL"
@@ -75,9 +92,33 @@ module ActiveRecord
             sql
           end
 
+          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
+
           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