activerecord 5.0.0.beta4 → 5.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7f29a643f71feaf240f7200a6e5c8dba8415d6e
-  data.tar.gz: 3b934f19c6464814f9a3c63db0684e4fcd25922c
+  metadata.gz: f1e6174798f04c800a0e52f66e75d449c8d4decb
+  data.tar.gz: 54ea6f16f127647134074c201ac4dfc42500c96d
 SHA512:
-  metadata.gz: d024e027426b52314572c887bfaca668b290c1a21b6217d9221a7c5bd3d5d1857ed9e435dc007b3ab39767889d29741ba1f48891177def1d865f41d63c95ae72
-  data.tar.gz: 9fbbe193fa6100f07a9a16e61b912291bc8e42d802fb53f7d63461ac34a697166cff13b01904dffe9dcbc448e8600fac934d7a1cc307db2144680f00b5085607
+  metadata.gz: b1957351dbfd43598306a1238fd38695d0f7d98247ea7e3ef7ffd34ad797c3623262f73c02076bf8b13f2992cf6dec5547c10f44621f74efeb6fbc9b6419f1a7
+  data.tar.gz: c9a45fadced0d55b6d3681222b08d8f8eb1ca844000d1f40f6f6dbd0c7480469a280ae3f7cc5b302e62c1615e3783a757adc5fed50236f00c7f88dd1cf6a1f26

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## Rails 5.0.0.rc1 (May 06, 2016) ##
+
+*   No changes.
+
+
 ## Rails 5.0.0.beta4 (April 27, 2016) ##
 
 *   PostgreSQL: Support Expression Indexes and Operator Classes.
@@ -119,12 +124,11 @@
 
     *Jeremy Daer*
 
-*   Delegate `empty?`, `none?` and `one?`. Now they can be invoked as model class methods.
+*   Delegate `none?` and `one?`. Now they can be invoked as model class methods.
 
     Example:
 
         # When no record is found on the table
-        Topic.empty? # => true
         Topic.none?  # => true
 
         # When only one record is found on the table

data/lib/active_record/associations/belongs_to_association.rb

@@ -61,6 +61,7 @@ module ActiveRecord
 
         def update_counters_on_replace(record)
           if require_counter_update? && different_target?(record)
+            owner.instance_variable_set :@_after_replace_counter_called, true
             record.increment!(reflection.counter_cache_column)
             decrement_counters
           end

data/lib/active_record/associations/builder/belongs_to.rb

@@ -33,6 +33,8 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
           if (@_after_create_counter_called ||= false)
             @_after_create_counter_called = false
+          elsif (@_after_replace_counter_called ||= false)
+            @_after_replace_counter_called = false
           elsif attribute_changed?(foreign_key) && !new_record?
             if reflection.polymorphic?
               model     = attribute(reflection.foreign_type).try(:constantize)

data/lib/active_record/attributes.rb

@@ -67,12 +67,14 @@ module ActiveRecord
       #
       # A default can also be provided.
       #
+      #   # db/schema.rb
       #   create_table :store_listings, force: true do |t|
       #     t.string :my_string, default: "original default"
       #   end
       #
       #   StoreListing.new.my_string # => "original default"
       #
+      #   # app/models/store_listing.rb
       #   class StoreListing < ActiveRecord::Base
       #     attribute :my_string, :string, default: "new default"
       #   end
@@ -89,6 +91,7 @@ module ActiveRecord
       #
       # \Attributes do not need to be backed by a database column.
       #
+      #   # app/models/my_model.rb
       #   class MyModel < ActiveRecord::Base
       #     attribute :my_string, :string
       #     attribute :my_int_array, :integer, array: true
@@ -131,7 +134,7 @@ module ActiveRecord
       #   # config/initializers/types.rb
       #   ActiveRecord::Type.register(:money, MoneyType)
       #
-      #   # /app/models/store_listing.rb
+      #   # app/models/store_listing.rb
       #   class StoreListing < ActiveRecord::Base
       #     attribute :price_in_cents, :money
       #   end
@@ -167,8 +170,10 @@ module ActiveRecord
       #     end
       #   end
       #
+      #   # config/initializers/types.rb
       #   ActiveRecord::Type.register(:money, MoneyType)
       #
+      #   # app/models/product.rb
       #   class Product < ActiveRecord::Base
       #     currency_converter = ConversionRatesFromTheInternet.new
       #     attribute :price_in_bitcoins, :money, currency_converter: currency_converter

data/lib/active_record/callbacks.rb

@@ -53,9 +53,9 @@ module ActiveRecord
   #   end
   #
   #   class Firm < ActiveRecord::Base
-  #     # Destroys the associated clients and people when the firm is destroyed
-  #     before_destroy { |record| Person.destroy_all "firm_id = #{record.id}"   }
-  #     before_destroy { |record| Client.destroy_all "client_of = #{record.id}" }
+  #     # Disables access to the system, for associated clients and people when the firm is destroyed
+  #     before_destroy { |record| Person.where(firm_id: record.id).update_all(access: 'disabled')   }
+  #     before_destroy { |record| Client.where(client_of: record.id).update_all(access: 'disabled') }
   #   end
   #
   # == Inheritable callback queues

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

@@ -778,8 +778,7 @@ module ActiveRecord
     end
 
     # ConnectionHandler is a collection of ConnectionPool objects. It is used
-    # for keeping separate connection pools for Active Record models that connect
-    # to different databases.
+    # for keeping separate connection pools that connect to different databases.
     #
     # For example, suppose that you have 5 models, with the following hierarchy:
     #
@@ -821,6 +820,10 @@ module ActiveRecord
     # ConnectionHandler accessible via ActiveRecord::Base.connection_handler.
     # All Active Record models use this handler to determine the connection pool that they
     # should use.
+    #
+    # The ConnectionHandler class is not coupled with the Active models, as it has no knowlodge
+    # about the model. The model, needs to pass a specification name to the handler,
+    # in order to lookup the correct connection pool.
     class ConnectionHandler
       def initialize
         # These caches are keyed by klass.name, NOT klass. Keying them by klass
@@ -829,9 +832,6 @@ module ActiveRecord
         @owner_to_pool = Concurrent::Map.new(:initial_capacity => 2) do |h,k|
           h[k] = Concurrent::Map.new(:initial_capacity => 2)
         end
-        @class_to_pool = Concurrent::Map.new(:initial_capacity => 2) do |h,k|
-          h[k] = Concurrent::Map.new
-        end
       end
 
       def connection_pool_list
@@ -839,10 +839,8 @@ module ActiveRecord
       end
       alias :connection_pools :connection_pool_list
 
-      def establish_connection(owner, spec)
-        @class_to_pool.clear
-        raise RuntimeError, "Anonymous class is not allowed." unless owner.name
-        owner_to_pool[owner.name] = ConnectionAdapters::ConnectionPool.new(spec)
+      def establish_connection(spec)
+        owner_to_pool[spec.name] = ConnectionAdapters::ConnectionPool.new(spec)
       end
 
       # Returns true if there are any active connections among the connection
@@ -873,18 +871,18 @@ module ActiveRecord
       # active or defined connection: if it is the latter, it will be
       # opened and set as the active connection for the class it was defined
       # for (not necessarily the current class).
-      def retrieve_connection(klass) #:nodoc:
-        pool = retrieve_connection_pool(klass)
-        raise ConnectionNotEstablished, "No connection pool for #{klass}" unless pool
+      def retrieve_connection(spec_name) #:nodoc:
+        pool = retrieve_connection_pool(spec_name)
+        raise ConnectionNotEstablished, "No connection pool with id #{spec_name} found." unless pool
         conn = pool.connection
-        raise ConnectionNotEstablished, "No connection for #{klass} in connection pool" unless conn
+        raise ConnectionNotEstablished, "No connection for #{spec_name} in connection pool" unless conn
         conn
       end
 
       # Returns true if a connection that's accessible to this class has
       # already been opened.
-      def connected?(klass)
-        conn = retrieve_connection_pool(klass)
+      def connected?(spec_name)
+        conn = retrieve_connection_pool(spec_name)
         conn && conn.connected?
       end
 
@@ -892,9 +890,8 @@ module ActiveRecord
       # connection and the defined connection (if they exist). The result
       # can be used as an argument for establish_connection, for easily
       # re-establishing the connection.
-      def remove_connection(owner)
-        if pool = owner_to_pool.delete(owner.name)
-          @class_to_pool.clear
+      def remove_connection(spec_name)
+        if pool = owner_to_pool.delete(spec_name)
           pool.automatic_reconnect = false
           pool.disconnect!
           pool.spec.config
@@ -910,14 +907,18 @@ module ActiveRecord
       # #fetch is significantly slower than #[]. So in the nil case, no caching will
       # take place, but that's ok since the nil case is not the common one that we wish
       # to optimise for.
-      def retrieve_connection_pool(klass)
-        class_to_pool[klass.name] ||= begin
-          until pool = pool_for(klass)
-            klass = klass.superclass
-            break unless klass <= Base
+      def retrieve_connection_pool(spec_name)
+        owner_to_pool.fetch(spec_name) do
+          if ancestor_pool = pool_from_any_process_for(spec_name)
+            # A connection was established in an ancestor process that must have
+            # subsequently forked. We can't reuse the connection, but we can copy
+            # the specification and establish a new connection with it.
+            establish_connection(ancestor_pool.spec).tap do |pool|
+              pool.schema_cache = ancestor_pool.schema_cache if ancestor_pool.schema_cache
+            end
+          else
+            owner_to_pool[spec_name] = nil
           end
-
-          class_to_pool[klass.name] = pool
         end
       end
 
@@ -927,28 +928,9 @@ module ActiveRecord
         @owner_to_pool[Process.pid]
       end
 
-      def class_to_pool
-        @class_to_pool[Process.pid]
-      end
-
-      def pool_for(owner)
-        owner_to_pool.fetch(owner.name) {
-          if ancestor_pool = pool_from_any_process_for(owner)
-            # A connection was established in an ancestor process that must have
-            # subsequently forked. We can't reuse the connection, but we can copy
-            # the specification and establish a new connection with it.
-            establish_connection(owner, ancestor_pool.spec).tap do |pool|
-              pool.schema_cache = ancestor_pool.schema_cache if ancestor_pool.schema_cache
-            end
-          else
-            owner_to_pool[owner.name] = nil
-          end
-        }
-      end
-
-      def pool_from_any_process_for(owner)
-        owner_to_pool = @owner_to_pool.values.find { |v| v[owner.name] }
-        owner_to_pool && owner_to_pool[owner.name]
+      def pool_from_any_process_for(spec_name)
+        owner_to_pool = @owner_to_pool.values.find { |v| v[spec_name] }
+        owner_to_pool && owner_to_pool[spec_name]
       end
     end
   end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -454,6 +454,24 @@ module ActiveRecord
         visitor.accept(node, collector).value
       end
 
+      def combine_bind_parameters(
+        from_clause: [],
+        join_clause: [],
+        where_clause: [],
+        having_clause: [],
+        limit: nil,
+        offset: nil
+      ) # :nodoc:
+        result = from_clause + join_clause + where_clause + having_clause
+        if limit
+          result << limit
+        end
+        if offset
+          result << offset
+        end
+        result
+      end
+
       protected
 
       def initialize_type_map(m) # :nodoc:

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -20,7 +20,7 @@ module ActiveRecord
         MySQL::Table.new(table_name, base)
       end
 
-      def schema_creation
+      def schema_creation # :nodoc:
         MySQL::SchemaCreation.new(self)
       end
 
@@ -502,8 +502,12 @@ module ActiveRecord
       def add_index(table_name, column_name, options = {}) #:nodoc:
         index_name, index_type, index_columns, _, index_algorithm, index_using, comment = add_index_options(table_name, column_name, options)
         sql = "CREATE #{index_type} INDEX #{quote_column_name(index_name)} #{index_using} ON #{quote_table_name(table_name)} (#{index_columns}) #{index_algorithm}"
+        execute add_sql_comment!(sql, comment)
+      end
+
+      def add_sql_comment!(sql, comment) # :nodoc:
         sql << " COMMENT #{quote(comment)}" if comment
-        execute sql
+        sql
       end
 
       def foreign_keys(table_name)

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -3,10 +3,10 @@ require 'uri'
 module ActiveRecord
   module ConnectionAdapters
     class ConnectionSpecification #:nodoc:
-      attr_reader :config, :adapter_method
+      attr_reader :name, :config, :adapter_method
 
-      def initialize(config, adapter_method)
-        @config, @adapter_method = config, adapter_method
+      def initialize(name, config, adapter_method)
+        @name, @config, @adapter_method = name, config, adapter_method
       end
 
       def initialize_dup(original)
@@ -164,7 +164,7 @@ module ActiveRecord
         #   spec.config
         #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" }
         #
-        def spec(config)
+        def spec(config, name = nil)
           spec = resolve(config).symbolize_keys
 
           raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
@@ -179,7 +179,14 @@ module ActiveRecord
           end
 
           adapter_method = "#{spec[:adapter]}_connection"
-          ConnectionSpecification.new(spec, adapter_method)
+
+          name ||=
+            if config.is_a?(Symbol)
+              config.to_s
+            else
+              "primary"
+            end
+          ConnectionSpecification.new(name, spec, adapter_method)
         end
 
         private

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

@@ -2,8 +2,8 @@ module ActiveRecord
   module ConnectionAdapters
     module MySQL
       class SchemaCreation < AbstractAdapter::SchemaCreation
-        delegate :quote, to: :@conn
-        private :quote
+        delegate :add_sql_comment!, to: :@conn
+        private :add_sql_comment!
 
         private
 
@@ -26,11 +26,7 @@ module ActiveRecord
         end
 
         def add_table_options!(create_sql, options)
-          super
-
-          if comment = options[:comment]
-            create_sql << " COMMENT #{quote(comment)}"
-          end
+          add_sql_comment!(super, options[:comment])
         end
 
         def column_options(o)
@@ -48,13 +44,7 @@ module ActiveRecord
             sql << " COLLATE #{collation}"
           end
 
-          super
-
-          if comment = options[:comment]
-            sql << " COMMENT #{quote(comment)}"
-          end
-
-          sql
+          add_sql_comment!(super, options[:comment])
         end
 
         def add_column_position!(sql, options)
@@ -69,8 +59,7 @@ module ActiveRecord
 
         def index_in_create(table_name, column_name, options)
           index_name, index_type, index_columns, _, _, index_using, comment = @conn.add_index_options(table_name, column_name, options)
-          index_option = " COMMENT #{quote(comment)}" if comment
-          "#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})#{index_option} "
+          add_sql_comment!("#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})", comment)
         end
       end
     end

data/lib/active_record/connection_adapters/postgresql/schema_statements.rb

@@ -217,7 +217,7 @@ module ActiveRecord
               ]
             end
 
-            IndexDefinition.new(table_name, index_name, unique, columns, [], orders, where, nil, using.to_sym, comment)
+            IndexDefinition.new(table_name, index_name, unique, columns, [], orders, where, nil, using.to_sym, comment.presence)
           end.compact
         end
 

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -168,10 +168,6 @@ module ActiveRecord
         true
       end
 
-      def supports_comments_in_create?
-        false
-      end
-
       def supports_savepoints?
         true
       end

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -541,7 +541,7 @@ module ActiveRecord
           result = exec_query(sql, 'SCHEMA').first
 
           if result
-            # Splitting with left parantheses and picking up last will return all
+            # Splitting with left parentheses and picking up last will return all
             # columns separated with comma(,).
             columns_string = result["sql"].split('(').last
 

data/lib/active_record/connection_handling.rb

@@ -45,16 +45,20 @@ module ActiveRecord
     # The exceptions AdapterNotSpecified, AdapterNotFound and +ArgumentError+
     # may be returned on an error.
     def establish_connection(spec = nil)
+      raise RuntimeError, "Anonymous class is not allowed." unless name
+
       spec     ||= DEFAULT_ENV.call.to_sym
       resolver =   ConnectionAdapters::ConnectionSpecification::Resolver.new configurations
-      spec     =   resolver.spec(spec)
+      # TODO: uses name on establish_connection, for backwards compatibility
+      spec     =   resolver.spec(spec, self == Base ? "primary" : name)
+      self.connection_specification_name = spec.name
 
       unless respond_to?(spec.adapter_method)
         raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
       end
 
       remove_connection
-      connection_handler.establish_connection self, spec
+      connection_handler.establish_connection spec
     end
 
     class MergeAndResolveDefaultUrlConfig # :nodoc:
@@ -87,6 +91,17 @@ module ActiveRecord
       retrieve_connection
     end
 
+    attr_writer :connection_specification_name
+
+    # Return the specification id from this class otherwise look it up
+    # in the parent.
+    def connection_specification_name
+      unless defined?(@connection_specification_name)
+        @connection_specification_name = self == Base ? "primary" : superclass.connection_specification_name
+      end
+      @connection_specification_name
+    end
+
     def connection_id
       ActiveRecord::RuntimeRegistry.connection_id ||= Thread.current.object_id
     end
@@ -106,20 +121,20 @@ module ActiveRecord
     end
 
     def connection_pool
-      connection_handler.retrieve_connection_pool(self) or raise ConnectionNotEstablished
+      connection_handler.retrieve_connection_pool(connection_specification_name) or raise ConnectionNotEstablished
     end
 
     def retrieve_connection
-      connection_handler.retrieve_connection(self)
+      connection_handler.retrieve_connection(connection_specification_name)
     end
 
     # Returns +true+ if Active Record is connected.
     def connected?
-      connection_handler.connected?(self)
+      connection_handler.connected?(connection_specification_name)
     end
 
-    def remove_connection(klass = self)
-      connection_handler.remove_connection(klass)
+    def remove_connection(name = connection_specification_name)
+      connection_handler.remove_connection(name)
     end
 
     def clear_cache! # :nodoc:

data/lib/active_record/core.rb

@@ -257,7 +257,7 @@ module ActiveRecord
       # Returns the Arel engine.
       def arel_engine # :nodoc:
         @arel_engine ||=
-          if Base == self || connection_handler.retrieve_connection_pool(self)
+          if Base == self || connection_handler.retrieve_connection_pool(connection_specification_name)
             self
           else
             superclass.arel_engine

data/lib/active_record/gem_version.rb

@@ -8,7 +8,7 @@ module ActiveRecord
     MAJOR = 5
     MINOR = 0
     TINY  = 0
-    PRE   = "beta4"
+    PRE   = "rc1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/locking/optimistic.rb

@@ -150,7 +150,7 @@ module ActiveRecord
 
         # The version column used for optimistic locking. Defaults to +lock_version+.
         def locking_column
-          reset_locking_column unless defined?(@locking_column)
+          @locking_column = DEFAULT_LOCKING_COLUMN unless defined?(@locking_column)
           @locking_column
         end
 

data/lib/active_record/migration.rb

@@ -277,7 +277,7 @@ module ActiveRecord
   # * <tt>change_column(table_name, column_name, type, options)</tt>:  Changes
   #   the column to a different type using the same parameters as add_column.
   # * <tt>change_column_default(table_name, column_name, default)</tt>: Sets a
-  #   default value for +column_name+ definded by +default+ on +table_name+.
+  #   default value for +column_name+ defined by +default+ on +table_name+.
   # * <tt>change_column_null(table_name, column_name, null, default = nil)</tt>:
   #   Sets or removes a +NOT NULL+ constraint on +column_name+. The +null+ flag
   #   indicates whether the value can be +NULL+. See
@@ -524,17 +524,11 @@ module ActiveRecord
     end
 
     def self.[](version)
-      version = version.to_s
-      name = "V#{version.tr('.', '_')}"
-      unless Compatibility.const_defined?(name)
-        versions = Compatibility.constants.grep(/\AV[0-9_]+\z/).map { |s| s.to_s.delete('V').tr('_', '.').inspect }
-        raise ArgumentError, "Unknown migration version #{version.inspect}; expected one of #{versions.sort.join(', ')}"
-      end
-      Compatibility.const_get(name)
+      Compatibility.find(version)
     end
 
     def self.current_version
-      Rails.version.to_f
+      ActiveRecord::VERSION::STRING.to_f
     end
 
     MigrationFilenameRegexp = /\A([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/ # :nodoc:

data/lib/active_record/migration/compatibility.rb

@@ -1,6 +1,16 @@
 module ActiveRecord
   class Migration
     module Compatibility # :nodoc: all
+      def self.find(version)
+        version = version.to_s
+        name = "V#{version.tr('.', '_')}"
+        unless const_defined?(name)
+          versions = constants.grep(/\AV[0-9_]+\z/).map { |s| s.to_s.delete('V').tr('_', '.').inspect }
+          raise ArgumentError, "Unknown migration version #{version.inspect}; expected one of #{versions.sort.join(', ')}"
+        end
+        const_get(name)
+      end
+
       V5_0 = Current
 
       module FourTwoShared

data/lib/active_record/model_schema.rb

@@ -238,7 +238,7 @@ module ActiveRecord
       end
 
       # Returns the next value that will be used as the primary key on
-      # an insert statment.
+      # an insert statement.
       def next_sequence_value
         connection.next_sequence_value(sequence_name)
       end

data/lib/active_record/querying.rb

@@ -1,6 +1,6 @@
 module ActiveRecord
   module Querying
-    delegate :find, :take, :take!, :first, :first!, :last, :last!, :exists?, :any?, :many?, :empty?, :none?, :one?, to: :all
+    delegate :find, :take, :take!, :first, :first!, :last, :last!, :exists?, :any?, :many?, :none?, :one?, to: :all
     delegate :second, :second!, :third, :third!, :fourth, :fourth!, :fifth, :fifth!, :forty_two, :forty_two!, :third_to_last, :third_to_last!, :second_to_last, :second_to_last!, to: :all
     delegate :first_or_create, :first_or_create!, :first_or_initialize, to: :all
     delegate :find_or_create_by, :find_or_create_by!, :find_or_initialize_by, to: :all

data/lib/active_record/relation/batches/batch_enumerator.rb

@@ -42,7 +42,7 @@ module ActiveRecord
       # Delegates #delete_all, #update_all, #destroy_all methods to each batch.
       #
       #   People.in_batches.delete_all
-      #   People.in_batches.destroy_all('age < 10')
+      #   People.where('age < 10').in_batches.destroy_all
       #   People.in_batches.update_all('age = age + 1')
       [:delete_all, :update_all, :destroy_all].each do |method|
         define_method(method) do |*args, &block|

data/lib/active_record/relation/delegation.rb

@@ -35,7 +35,7 @@ module ActiveRecord
     # may vary depending on the klass of a relation, so we create a subclass of Relation
     # for each different klass, and the delegations are compiled into that subclass only.
 
-    delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to_ary, :join,
+    delegate :to_xml, :encode_with, :length, :collect, :map, :each, :all?, :include?, :to_ary, :join,
              :[], :&, :|, :+, :-, :sample, :reverse, :compact, :in_groups, :in_groups_of,
              :shuffle, :split, to: :records
 

data/lib/active_record/relation/query_methods.rb

@@ -99,22 +99,28 @@ module ActiveRecord
     end
 
     def bound_attributes
-      result = from_clause.binds + arel.bind_values + where_clause.binds + having_clause.binds
       if limit_value && !string_containing_comma?(limit_value)
-        result << Attribute.with_cast_value(
+        limit_bind = Attribute.with_cast_value(
           "LIMIT".freeze,
           connection.sanitize_limit(limit_value),
           Type::Value.new,
         )
       end
       if offset_value
-        result << Attribute.with_cast_value(
+        offset_bind = Attribute.with_cast_value(
           "OFFSET".freeze,
           offset_value.to_i,
           Type::Value.new,
         )
       end
-      result
+      connection.combine_bind_parameters(
+        from_clause: from_clause.binds,
+        join_clause: arel.bind_values,
+        where_clause: where_clause.binds,
+        having_clause: having_clause.binds,
+        limit: limit_bind,
+        offset: offset_bind,
+      )
     end
 
     FROZEN_EMPTY_HASH = {}.freeze

data/lib/active_record/tasks/database_tasks.rb

@@ -117,10 +117,10 @@ module ActiveRecord
       end
 
       def create_all
-        old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base)
+        old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base.connection_specification_name)
         each_local_configuration { |configuration| create configuration }
         if old_pool
-          ActiveRecord::Base.connection_handler.establish_connection(ActiveRecord::Base, old_pool.spec)
+          ActiveRecord::Base.connection_handler.establish_connection(old_pool.spec)
         end
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord
 version: !ruby/object:Gem::Version
-  version: 5.0.0.beta4
+  version: 5.0.0.rc1
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-27 00:00:00.000000000 Z
+date: 2016-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.0.0.beta4
+        version: 5.0.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.0.0.beta4
+        version: 5.0.0.rc1
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.0.0.beta4
+        version: 5.0.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.0.0.beta4
+        version: 5.0.0.rc1
 - !ruby/object:Gem::Dependency
   name: arel
   requirement: !ruby/object:Gem::Requirement
@@ -328,7 +328,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.4
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Object-relational mapper framework (part of Rails).