activerecord 5.0.2 → 5.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 68957771d5c52daac160a296c5168838ba53d9ce
-  data.tar.gz: b61fc1a80cb8169883f3d727481ec38111702484
+  metadata.gz: c2aa37fd1fc57e36d5f14ee9009cf6ba7ec6b601
+  data.tar.gz: c974b336ea71a782c1381d480c0ef2687dfc32c3
 SHA512:
-  metadata.gz: b05a93e230415562344d28db45ca476edbcf15bdb02a6dafcaab46951850b28359ff37d647b57530e79d5a66aa7be5b46d8c0bb217ceed69ff73a087e9f64bae
-  data.tar.gz: 3c3fae72c7e4eeae41528004831b6ded872bec022fee1123f0ed7d0375dcd3b77292709dea36ca5a0bda321de3081614e3464b591314a744c864d6ea554ec348
+  metadata.gz: f27b1ef2da04f68ac793b7039dc8ff8e0c78d8cf8db60d0b554f00174882b025d41dde0a4ad1a86ad5dad95c9facd826852b398c666968965cb54154d7f27cc6
+  data.tar.gz: e792934d6d1a39b07fef4cbff53969729f292edab3e23ea33231ba087b23d7e8a3eed648135fa45fc4e023dc8c217e7260753f3d69defeca3ecf0e21cabe804c

data/CHANGELOG.md

@@ -1,3 +1,42 @@
+*   Check whether `Rails.application` defined before calling it
+
+    In #27674 we changed the migration generator to generate migrations at the
+    path defined in `Rails.application.config.paths` however the code checked
+    for the presence of the `Rails` constant but not the `Rails.application`
+    method which caused problems when using Active Record and generators outside
+    of the context of a Rails application.
+
+    Fixes #28325.
+
+*   Fix `deserialize` with JSON array.
+
+    Fixes #28285.
+
+    *Ryuta Kamizono*
+
+*   Fix `rake db:schema:load` with subdirectories.
+
+    *Ryuta Kamizono*
+
+*   Fix `rake db:migrate:status` with subdirectories.
+
+    *Ryuta Kamizono*
+
+*   Don't share options between reference id and type columns
+
+    When using a polymorphic reference column in a migration, sharing options
+    between the two columns doesn't make sense since they are different types.
+    The `reference_id` column is usually an integer and the `reference_type`
+    column a string so options like `unsigned: true` will result in an invalid
+    table definition.
+
+    *Ryuta Kamizono*
+
+*   Fix regression of #1969 with SELECT aliases in HAVING clause.
+
+    *Eugene Kenny*
+
+
 ## Rails 5.0.2 (March 01, 2017) ##
 
 *   Fix `wait_timeout` to configurable for mysql2 adapter.

data/lib/active_record/associations/association.rb

@@ -83,7 +83,7 @@ module ActiveRecord
       end
 
       def scope
-        target_scope.merge(association_scope)
+        target_scope.merge!(association_scope)
       end
 
       # The scope for this association.

data/lib/active_record/associations/collection_association.rb

@@ -39,13 +39,7 @@ module ActiveRecord
           reload
         end
 
-        if null_scope?
-          # Cache the proxy separately before the owner has an id
-          # or else a post-save proxy will still lack the id
-          @null_proxy ||= CollectionProxy.create(klass, self)
-        else
-          @proxy ||= CollectionProxy.create(klass, self)
-        end
+        CollectionProxy.create(klass, self)
       end
 
       # Implements the writer method, e.g. foo.items= for Foo.has_many :items
@@ -427,37 +421,9 @@ module ActiveRecord
         replace_on_target(record, index, skip_callbacks, &block)
       end
 
-      def replace_on_target(record, index, skip_callbacks)
-        callback(:before_add, record) unless skip_callbacks
-
-        begin
-          if index
-            record_was = target[index]
-            target[index] = record
-          else
-            target << record
-          end
-
-          yield(record) if block_given?
-        rescue
-          if index
-            target[index] = record_was
-          else
-            target.delete(record)
-          end
-
-          raise
-        end
-
-        callback(:after_add, record) unless skip_callbacks
-        set_inverse_instance(record)
-
-        record
-      end
-
-      def scope(opts = {})
-        scope = super()
-        scope.none! if opts.fetch(:nullify, true) && null_scope?
+      def scope
+        scope = super
+        scope.none! if null_scope?
         scope
       end
 
@@ -528,15 +494,19 @@ module ActiveRecord
             transaction do
               add_to_target(build_record(attributes)) do |record|
                 yield(record) if block_given?
-                insert_record(record, true, raise)
+                insert_record(record, true, raise) { @_was_loaded = loaded? }
               end
             end
           end
         end
 
         # Do the relevant stuff to insert the given record into the association collection.
-        def insert_record(record, validate = true, raise = false)
-          raise NotImplementedError
+        def insert_record(record, validate = true, raise = false, &block)
+          if raise
+            record.save!(validate: validate, &block)
+          else
+            record.save(validate: validate, &block)
+          end
         end
 
         def create_scope
@@ -590,19 +560,41 @@ module ActiveRecord
           end
         end
 
-        def concat_records(records, should_raise = false)
+        def concat_records(records, raise = false)
           result = true
 
           records.each do |record|
             raise_on_type_mismatch!(record)
-            add_to_target(record) do |rec|
-              result &&= insert_record(rec, true, should_raise) unless owner.new_record?
+            add_to_target(record) do
+              result &&= insert_record(record, true, raise) { @_was_loaded = loaded? } unless owner.new_record?
             end
           end
 
           result && records
         end
 
+        def replace_on_target(record, index, skip_callbacks)
+          callback(:before_add, record) unless skip_callbacks
+
+          set_inverse_instance(record)
+
+          @_was_loaded = true
+
+          yield(record) if block_given?
+
+          if index
+            target[index] = record
+          elsif @_was_loaded || !loaded?
+            target << record
+          end
+
+          callback(:after_add, record) unless skip_callbacks
+
+          record
+        ensure
+          @_was_loaded = nil
+        end
+
         def callback(method, record)
           callbacks_for(method).each do |callback|
             callback.call(method, owner, record)

data/lib/active_record/associations/collection_proxy.rb

@@ -28,12 +28,9 @@ module ActiveRecord
     # is computed directly through SQL and does not trigger by itself the
     # instantiation of the actual post records.
     class CollectionProxy < Relation
-      delegate :exists?, :update_all, :arel, to: :scope
-
       def initialize(klass, association) #:nodoc:
         @association = association
         super klass, klass.arel_table, klass.predicate_builder
-        merge! association.scope(nullify: false)
       end
 
       def target
@@ -902,19 +899,10 @@ module ActiveRecord
         @association
       end
 
-      # We don't want this object to be put on the scoping stack, because
-      # that could create an infinite loop where we call an @association
-      # method, which gets the current scope, which is this object, which
-      # delegates to @association, and so on.
-      def scoping
-        @association.scope.scoping { yield }
-      end
-
       # Returns a <tt>Relation</tt> object for the records in this association
       def scope
-        @association.scope
+        @scope ||= @association.scope
       end
-      alias spawn scope
 
       # Equivalent to <tt>Array#==</tt>. Returns +true+ if the two arrays
       # contain the same number of elements and if each element is equal
@@ -1046,6 +1034,7 @@ module ActiveRecord
       #   person.pets(true)  # fetches pets from the database
       #   # => [#<Pet id: 1, name: "Snoop", group: "dogs", person_id: 1>]
       def reload
+        @scope = nil
         proxy_association.reload
         self
       end
@@ -1067,20 +1056,51 @@ module ActiveRecord
       #   person.pets  # fetches pets from the database
       #   # => [#<Pet id: 1, name: "Snoop", group: "dogs", person_id: 1>]
       def reset
+        @scope = nil
         proxy_association.reset
         proxy_association.reset_scope
         self
       end
 
+      delegate_methods = [
+        QueryMethods,
+        SpawnMethods,
+      ].flat_map { |klass|
+        klass.public_instance_methods(false)
+      } - self.public_instance_methods(false) + [:scoping]
+
+      delegate(*delegate_methods, to: :scope)
+
+      module DelegateExtending # :nodoc:
+        private
+          def method_missing(method, *args, &block)
+            extending_values = association_scope.extending_values
+            if extending_values.any? && (extending_values - self.class.included_modules).any?
+              self.class.include(*extending_values)
+              public_send(method, *args, &block)
+            else
+              super
+            end
+          end
+      end
+
       private
 
         def null_scope?
           @association.null_scope?
         end
 
+        def association_scope
+          @association.association_scope
+        end
+
         def exec_queries
           load_target
         end
+
+        def respond_to_missing?(method, _)
+          association_scope.respond_to?(method) || super
+        end
     end
   end
 end

data/lib/active_record/associations/has_many_association.rb

@@ -40,13 +40,7 @@ module ActiveRecord
 
       def insert_record(record, validate = true, raise = false)
         set_owner_attributes(record)
-        set_inverse_instance(record)
-
-        if raise
-          record.save!(:validate => validate)
-        else
-          record.save(:validate => validate)
-        end
+        super
       end
 
       def empty?

data/lib/active_record/associations/has_many_through_association.rb

@@ -39,11 +39,7 @@ module ActiveRecord
         ensure_not_nested
 
         if record.new_record? || record.changed?
-          if raise
-            record.save!(validate: validate)
-          else
-            return unless record.save(validate: validate)
-          end
+          return unless super
         end
 
         save_through_record(record)

data/lib/active_record/collection_cache_key.rb

@@ -8,17 +8,27 @@ module ActiveRecord
       if collection.loaded?
         size = collection.size
         if size > 0
-          timestamp = collection.max_by(&timestamp_column).public_send(timestamp_column)
+          timestamp = collection.max_by(&timestamp_column)._read_attribute(timestamp_column)
         end
       else
         column_type = type_for_attribute(timestamp_column.to_s)
         column = "#{connection.quote_table_name(collection.table_name)}.#{connection.quote_column_name(timestamp_column)}"
+        select_values = "COUNT(*) AS #{connection.quote_column_name("size")}, MAX(%s) AS timestamp"
 
-        query = collection
-          .unscope(:select)
-          .select("COUNT(*) AS #{connection.quote_column_name("size")}", "MAX(#{column}) AS timestamp")
-          .unscope(:order)
-        result = connection.select_one(query)
+        if collection.limit_value || collection.offset_value
+          query = collection.spawn
+          query.select_values = [column]
+          subquery_alias = "subquery_for_cache_key"
+          subquery_column = "#{subquery_alias}.#{timestamp_column}"
+          subquery = query.arel.as(subquery_alias)
+          arel = Arel::SelectManager.new(query.engine).project(select_values % subquery_column).from(subquery)
+        else
+          query = collection.unscope(:order)
+          query.select_values = [select_values % column]
+          arel = query.arel
+        end
+
+        result = connection.select_one(arel, nil, query.bound_attributes)
 
         if result.blank?
           size = 0

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

@@ -155,6 +155,14 @@ module ActiveRecord
         binds.map(&:value_for_database)
       end
 
+      def type_casted_binds(binds) # :nodoc:
+        if binds.first.is_a?(Array)
+          binds.map { |column, value| type_cast(value, column) }
+        else
+          binds.map { |attr| type_cast(attr.value_for_database) }
+        end
+      end
+
       private
 
       def types_which_need_no_typecasting

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

@@ -107,16 +107,12 @@ module ActiveRecord
 
       private
 
-      def as_options(value, default = {})
-        if value.is_a?(Hash)
-          value
-        else
-          default
-        end
+      def as_options(value)
+        value.is_a?(Hash) ? value : {}
       end
 
       def polymorphic_options
-        as_options(polymorphic, options)
+        as_options(polymorphic)
       end
 
       def index_options

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

@@ -1022,9 +1022,8 @@ module ActiveRecord
         sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name)
 
         migrated = select_values("SELECT version FROM #{sm_table}").map(&:to_i)
-        paths = migrations_paths.map {|p| "#{p}/[0-9]*_*.rb" }
-        versions = Dir[*paths].map do |filename|
-          filename.split('/').last.split('_').first.to_i
+        versions = ActiveRecord::Migrator.migration_files(migrations_paths).map do |file|
+          ActiveRecord::Migrator.parse_migration_filename(file).first.to_i
         end
 
         unless migrated.include?(version)

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -425,7 +425,7 @@ module ActiveRecord
 
       # Provides access to the underlying database driver for this adapter. For
       # example, this method returns a Mysql2::Client object in case of Mysql2Adapter,
-      # and a PGconn object in case of PostgreSQLAdapter.
+      # and a PG::Connection object in case of PostgreSQLAdapter.
       #
       # This is useful for when you need to call a proprietary method such as
       # PostgreSQL's lo_* methods.
@@ -579,14 +579,15 @@ module ActiveRecord
         exception
       end
 
-      def log(sql, name = "SQL", binds = [], statement_name = nil)
+      def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
         @instrumenter.instrument(
           "sql.active_record",
-          :sql            => sql,
-          :name           => name,
-          :connection_id  => object_id,
-          :statement_name => statement_name,
-          :binds          => binds) { yield }
+          sql:               sql,
+          name:              name,
+          binds:             binds,
+          type_casted_binds: type_casted_binds,
+          statement_name:    statement_name,
+          connection_id:     object_id) { yield }
       rescue => e
         raise translate_exception_class(e, sql)
       end

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -324,7 +324,7 @@ module ActiveRecord
 
       def data_sources
         sql = "SELECT table_name FROM information_schema.tables "
-        sql << "WHERE table_schema = #{quote(@config[:database])}"
+        sql << "WHERE table_schema = DATABASE()"
 
         select_values(sql, 'SCHEMA')
       end
@@ -350,7 +350,7 @@ module ActiveRecord
         schema, name = extract_schema_qualified_name(table_name)
 
         sql = "SELECT table_name FROM information_schema.tables "
-        sql << "WHERE table_schema = #{quote(schema)} AND table_name = #{quote(name)}"
+        sql << "WHERE table_schema = #{schema} AND table_name = #{name}"
 
         select_values(sql, 'SCHEMA').any?
       end
@@ -365,7 +365,7 @@ module ActiveRecord
         schema, name = extract_schema_qualified_name(view_name)
 
         sql = "SELECT table_name FROM information_schema.tables WHERE table_type = 'VIEW'"
-        sql << " AND table_schema = #{quote(schema)} AND table_name = #{quote(name)}"
+        sql << " AND table_schema = #{schema} AND table_name = #{name}"
 
         select_values(sql, 'SCHEMA').any?
       end
@@ -414,8 +414,8 @@ module ActiveRecord
         select_value(<<-SQL.strip_heredoc, 'SCHEMA')
           SELECT table_comment
           FROM information_schema.tables
-          WHERE table_schema = #{quote(schema)}
-            AND table_name = #{quote(name)}
+          WHERE table_schema = #{schema}
+            AND table_name = #{name}
         SQL
       end
 
@@ -528,9 +528,9 @@ module ActiveRecord
           JOIN information_schema.referential_constraints rc
           USING (constraint_schema, constraint_name)
           WHERE fk.referenced_column_name IS NOT NULL
-            AND fk.table_schema = #{quote(schema)}
-            AND fk.table_name = #{quote(name)}
-            AND rc.table_name = #{quote(name)}
+            AND fk.table_schema = #{schema}
+            AND fk.table_name = #{name}
+            AND rc.table_name = #{name}
         SQL
 
         fk_info.map do |row|
@@ -607,8 +607,8 @@ module ActiveRecord
           SELECT column_name
           FROM information_schema.key_column_usage
           WHERE constraint_name = 'PRIMARY'
-            AND table_schema = #{quote(schema)}
-            AND table_name = #{quote(name)}
+            AND table_schema = #{schema}
+            AND table_name = #{name}
           ORDER BY ordinal_position
         SQL
       end
@@ -904,8 +904,8 @@ module ActiveRecord
       end
 
       def extract_schema_qualified_name(string) # :nodoc:
-        schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/)
-        schema, name = @config[:database], schema unless name
+        schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/).map { |s| quote(s) }
+        schema, name = "DATABASE()", schema unless name
         [schema, name]
       end
 

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

@@ -73,9 +73,9 @@ module ActiveRecord
           # made since we established the connection
           @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
 
-          type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
+          type_casted_binds = type_casted_binds(binds)
 
-          log(sql, name, binds) do
+          log(sql, name, binds, type_casted_binds) do
             if cache_stmt
               cache = @statements[sql] ||= {
                 stmt: @connection.prepare(sql)

data/lib/active_record/connection_adapters/postgresql/oid/array.rb

@@ -23,7 +23,7 @@ module ActiveRecord
             when ::String
               type_cast_array(@pg_decoder.decode(value), :deserialize)
             when Data
-              deserialize(value.values)
+              type_cast_array(value.values, :deserialize)
             else
               super
             end

data/lib/active_record/connection_adapters/postgresql/oid/bytea.rb

@@ -6,7 +6,7 @@ module ActiveRecord
           def deserialize(value)
             return if value.nil?
             return value.to_s if value.is_a?(Type::Binary::Data)
-            PGconn.unescape_bytea(super)
+            PG::Connection.unescape_bytea(super)
           end
         end
       end

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

@@ -33,7 +33,7 @@ module ActiveRecord
 
         # Quotes schema names for use in SQL queries.
         def quote_schema_name(name)
-          PGconn.quote_ident(name)
+          PG::Connection.quote_ident(name)
         end
 
         def quote_table_name_for_assignment(table, attr)
@@ -42,7 +42,7 @@ module ActiveRecord
 
         # Quotes column names for use in SQL queries.
         def quote_column_name(name) # :nodoc:
-          @quoted_column_names[name] ||= PGconn.quote_ident(super)
+          @quoted_column_names[name] ||= PG::Connection.quote_ident(super)
         end
 
         # Quote date/time values for use in SQL input.
@@ -103,7 +103,7 @@ module ActiveRecord
           case value
           when Type::Binary::Data
             # Return a bind param hash with format as binary.
-            # See http://deveiate.org/code/pg/PGconn.html#method-i-exec_prepared-doc
+            # See https://deveiate.org/code/pg/PG/Connection.html#method-i-exec_prepared-doc
             # for more information
             { value: value.to_s, format: 1 }
           when OID::Xml::Data, OID::Bit::Data

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

@@ -19,9 +19,9 @@ module ActiveRecord
 
         def quoted
           if schema
-            PGconn.quote_ident(schema) << SEPARATOR << PGconn.quote_ident(identifier)
+            PG::Connection.quote_ident(schema) << SEPARATOR << PG::Connection.quote_ident(identifier)
           else
-            PGconn.quote_ident(identifier)
+            PG::Connection.quote_ident(identifier)
           end
         end
 

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -28,11 +28,11 @@ module ActiveRecord
       conn_params[:user] = conn_params.delete(:username) if conn_params[:username]
       conn_params[:dbname] = conn_params.delete(:database) if conn_params[:database]
 
-      # Forward only valid config params to PGconn.connect.
-      valid_conn_param_keys = PGconn.conndefaults_hash.keys + [:requiressl]
+      # Forward only valid config params to PG::Connection.connect.
+      valid_conn_param_keys = PG::Connection.conndefaults_hash.keys + [:requiressl]
       conn_params.slice!(*valid_conn_param_keys)
 
-      # The postgres drivers don't allow the creation of an unconnected PGconn object,
+      # The postgres drivers don't allow the creation of an unconnected PG::Connection object,
       # so just pass a nil connection object for the time being.
       ConnectionAdapters::PostgreSQLAdapter.new(nil, logger, conn_params, config)
     end
@@ -198,8 +198,8 @@ module ActiveRecord
           end
 
           def connection_active?
-            @connection.status == PGconn::CONNECTION_OK
-          rescue PGError
+            @connection.status == PG::CONNECTION_OK
+          rescue PG::Error
             false
           end
       end
@@ -244,7 +244,7 @@ module ActiveRecord
       def active?
         @connection.query 'SELECT 1'
         true
-      rescue PGError
+      rescue PG::Error
         false
       end
 
@@ -410,7 +410,7 @@ module ActiveRecord
         def translate_exception(exception, message)
           return exception unless exception.respond_to?(:result)
 
-          case exception.result.try(:error_field, PGresult::PG_DIAG_SQLSTATE)
+          case exception.result.try(:error_field, PG::PG_DIAG_SQLSTATE)
           when UNIQUE_VIOLATION
             RecordNotUnique.new(message)
           when FOREIGN_KEY_VIOLATION
@@ -594,15 +594,15 @@ module ActiveRecord
         end
 
         def exec_no_cache(sql, name, binds)
-          type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
-          log(sql, name, binds) { @connection.async_exec(sql, type_casted_binds) }
+          type_casted_binds = type_casted_binds(binds)
+          log(sql, name, binds, type_casted_binds) { @connection.async_exec(sql, type_casted_binds) }
         end
 
         def exec_cache(sql, name, binds)
           stmt_key = prepare_statement(sql)
-          type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
+          type_casted_binds = type_casted_binds(binds)
 
-          log(sql, name, binds, stmt_key) do
+          log(sql, name, binds, type_casted_binds, stmt_key) do
             @connection.exec_prepared(stmt_key, type_casted_binds)
           end
         rescue ActiveRecord::StatementInvalid => e
@@ -631,7 +631,7 @@ module ActiveRecord
         CACHED_PLAN_HEURISTIC = 'cached plan must not change result type'.freeze
         def is_cached_plan_failure?(e)
           pgerror = e.cause
-          code = pgerror.result.result_error_field(PGresult::PG_DIAG_SQLSTATE)
+          code = pgerror.result.result_error_field(PG::PG_DIAG_SQLSTATE)
           code == FEATURE_NOT_SUPPORTED && pgerror.message.include?(CACHED_PLAN_HEURISTIC)
         rescue
           false
@@ -668,7 +668,7 @@ module ActiveRecord
         # Connects to a PostgreSQL server and sets up the adapter depending on the
         # connected server's characteristics.
         def connect
-          @connection = PGconn.connect(@connection_parameters)
+          @connection = PG.connect(@connection_parameters)
           configure_connection
         rescue ::PG::Error => error
           if error.message.include?("does not exist")

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -188,9 +188,9 @@ module ActiveRecord
       end
 
       def exec_query(sql, name = nil, binds = [], prepare: false)
-        type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
+        type_casted_binds = type_casted_binds(binds)
 
-        log(sql, name, binds) do
+        log(sql, name, binds, type_casted_binds) do
           # Don't cache statements if they are not prepared
           unless prepare
             stmt    = @connection.prepare(sql)
@@ -203,7 +203,6 @@ module ActiveRecord
             ensure
               stmt.close
             end
-            stmt = records
           else
             cache = @statements[sql] ||= {
               :stmt => @connection.prepare(sql)
@@ -212,9 +211,10 @@ module ActiveRecord
             cols = cache[:cols] ||= stmt.columns
             stmt.reset!
             stmt.bind_params(type_casted_binds)
+            records = stmt.to_a
           end
 
-          ActiveRecord::Result.new(cols, stmt.to_a)
+          ActiveRecord::Result.new(cols, records)
         end
       end
 

data/lib/active_record/explain.rb

@@ -16,15 +16,14 @@ module ActiveRecord
     # Makes the adapter execute EXPLAIN for the tuples of queries and bindings.
     # Returns a formatted string ready to be logged.
     def exec_explain(queries) # :nodoc:
-      str = queries.map do |sql, bind|
-        [].tap do |msg|
-          msg << "EXPLAIN for: #{sql}"
-          unless bind.empty?
-            bind_msg = bind.map {|col, val| [col.name, val]}.inspect
-            msg.last << " #{bind_msg}"
-          end
-          msg << connection.explain(sql, bind)
-        end.join("\n")
+      str = queries.map do |sql, binds|
+        msg = "EXPLAIN for: #{sql}"
+        unless binds.empty?
+          msg << " "
+          msg << binds.map { |attr| render_bind(attr) }.inspect
+        end
+        msg << "\n"
+        msg << connection.explain(sql, binds)
       end.join("\n")
 
       # Overriding inspect to be more human readable, especially in the console.
@@ -34,5 +33,17 @@ module ActiveRecord
 
       str
     end
+
+    private
+
+      def render_bind(attr)
+        value = if attr.type.binary? && attr.value
+          "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+        else
+          connection.type_cast(attr.value_for_database)
+        end
+
+        [attr.name, value]
+      end
   end
 end

data/lib/active_record/gem_version.rb

@@ -7,7 +7,7 @@ module ActiveRecord
   module VERSION
     MAJOR = 5
     MINOR = 0
-    TINY  = 2
+    TINY  = 3
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/active_record/log_subscriber.rb

@@ -20,20 +20,6 @@ module ActiveRecord
       @odd = false
     end
 
-    def render_bind(attribute)
-      value = if attribute.type.binary? && attribute.value
-        if attribute.value.is_a?(Hash)
-          "<#{attribute.value_for_database.to_s.bytesize} bytes of binary data>"
-        else
-          "<#{attribute.value.bytesize} bytes of binary data>"
-        end
-      else
-        attribute.value_for_database
-      end
-
-      [attribute.name, value]
-    end
-
     def sql(event)
       self.class.runtime += event.duration
       return unless logger.debug?
@@ -47,7 +33,10 @@ module ActiveRecord
       binds = nil
 
       unless (payload[:binds] || []).empty?
-        binds = "  " + payload[:binds].map { |attr| render_bind(attr) }.inspect
+        casted_params = type_casted_binds(payload[:binds], payload[:type_casted_binds])
+        binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
+          render_bind(attr, value)
+        }.inspect
       end
 
       name = colorize_payload_name(name, payload[:name])
@@ -58,6 +47,20 @@ module ActiveRecord
 
     private
 
+    def type_casted_binds(binds, casted_binds)
+      casted_binds || ActiveRecord::Base.connection.type_casted_binds(binds)
+    end
+
+    def render_bind(attr, value)
+      if attr.is_a?(Array)
+        attr = attr.first
+      elsif attr.type.binary? && attr.value
+        value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+      end
+
+      [attr && attr.name, value]
+    end
+
     def colorize_payload_name(name, payload_name)
       if payload_name.blank? || payload_name == "SQL" # SQL vs Model Load/Exists
         color(name, MAGENTA, true)

data/lib/active_record/migration.rb

@@ -1057,10 +1057,6 @@ module ActiveRecord
         Array(@migrations_paths)
       end
 
-      def match_to_migration_filename?(filename) # :nodoc:
-        File.basename(filename) =~ Migration::MigrationFilenameRegexp
-      end
-
       def parse_migration_filename(filename) # :nodoc:
         File.basename(filename).scan(Migration::MigrationFilenameRegexp).first
       end
@@ -1068,9 +1064,7 @@ module ActiveRecord
       def migrations(paths)
         paths = Array(paths)
 
-        files = Dir[*paths.map { |p| "#{p}/**/[0-9]*_*.rb" }]
-
-        migrations = files.map do |file|
+        migrations = migration_files(paths).map do |file|
           version, name, scope = parse_migration_filename(file)
           raise IllegalMigrationNameError.new(file) unless version
           version = version.to_i
@@ -1082,6 +1076,30 @@ module ActiveRecord
         migrations.sort_by(&:version)
       end
 
+      def migrations_status(paths)
+        paths = Array(paths)
+
+        db_list = ActiveRecord::SchemaMigration.normalized_versions
+
+        file_list = migration_files(paths).map do |file|
+          version, name, scope = parse_migration_filename(file)
+          raise IllegalMigrationNameError.new(file) unless version
+          version = ActiveRecord::SchemaMigration.normalize_migration_number(version)
+          status = db_list.delete(version) ? "up" : "down"
+          [status, version, (name + scope).humanize]
+        end.compact
+
+        db_list.map! do |version|
+          ["up", version, "********** NO FILE **********"]
+        end
+
+        (db_list + file_list).sort_by { |_, version, _| version }
+      end
+
+      def migration_files(paths)
+        Dir[*paths.flat_map { |path| "#{path}/**/[0-9]*_*.rb" }]
+      end
+
       private
 
       def move(direction, migrations_paths, steps)

data/lib/active_record/persistence.rb

@@ -100,6 +100,10 @@ module ActiveRecord
       !(@new_record || @destroyed)
     end
 
+    ##
+    # :call-seq:
+    #   save(*args)
+    #
     # Saves the model.
     #
     # If the model is new, a record gets created in the database, otherwise
@@ -121,12 +125,16 @@ module ActiveRecord
     #
     # Attributes marked as readonly are silently ignored if the record is
     # being updated.
-    def save(*args)
-      create_or_update(*args)
+    def save(*args, &block)
+      create_or_update(*args, &block)
     rescue ActiveRecord::RecordInvalid
       false
     end
 
+    ##
+    # :call-seq:
+    #   save!(*args)
+    #
     # Saves the model.
     #
     # If the model is new, a record gets created in the database, otherwise
@@ -148,8 +156,8 @@ module ActiveRecord
     #
     # Attributes marked as readonly are silently ignored if the record is
     # being updated.
-    def save!(*args)
-      create_or_update(*args) || raise(RecordNotSaved.new("Failed to save the record", self))
+    def save!(*args, &block)
+      create_or_update(*args, &block) || raise(RecordNotSaved.new("Failed to save the record", self))
     end
 
     # Deletes the record in the database and freezes this instance to
@@ -535,9 +543,9 @@ module ActiveRecord
       self.class.unscoped.where(self.class.primary_key => id)
     end
 
-    def create_or_update(*args)
+    def create_or_update(*args, &block)
       raise ReadOnlyRecord, "#{self.class} is marked as readonly" if readonly?
-      result = new_record? ? _create_record : _update_record(*args)
+      result = new_record? ? _create_record(&block) : _update_record(*args, &block)
       result != false
     end
 
@@ -546,10 +554,14 @@ module ActiveRecord
     def _update_record(attribute_names = self.attribute_names)
       attributes_values = arel_attributes_with_values_for_update(attribute_names)
       if attributes_values.empty?
-        0
+        rows_affected = 0
       else
-        self.class.unscoped._update_record attributes_values, id, id_was
+        rows_affected = self.class.unscoped._update_record attributes_values, id, id_was
       end
+
+      yield(self) if block_given?
+
+      rows_affected
     end
 
     # Creates a record with values matching those of the instance attributes
@@ -561,6 +573,9 @@ module ActiveRecord
       self.id ||= new_id if self.class.primary_key
 
       @new_record = false
+
+      yield(self) if block_given?
+
       id
     end
 

data/lib/active_record/railties/databases.rake

@@ -77,6 +77,8 @@ db_namespace = namespace :db do
   namespace :migrate do
     # desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
     task :redo => [:environment, :load_config] do
+      raise "Empty VERSION provided" if ENV["VERSION"] && ENV["VERSION"].empty?
+
       if ENV['VERSION']
         db_namespace['migrate:down'].invoke
         db_namespace['migrate:up'].invoke
@@ -91,16 +93,17 @@ db_namespace = namespace :db do
 
     # desc 'Runs the "up" for a given migration VERSION.'
     task :up => [:environment, :load_config] do
+      raise "VERSION is required" if !ENV["VERSION"] || ENV["VERSION"].empty?
+
       version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise 'VERSION is required' unless version
       ActiveRecord::Migrator.run(:up, ActiveRecord::Tasks::DatabaseTasks.migrations_paths, version)
       db_namespace['_dump'].invoke
     end
 
     # desc 'Runs the "down" for a given migration VERSION.'
     task :down => [:environment, :load_config] do
+      raise "VERSION is required - To go down one migration, use db:rollback" if !ENV["VERSION"] || ENV["VERSION"].empty?
       version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise 'VERSION is required - To go down one migration, run db:rollback' unless version
       ActiveRecord::Migrator.run(:down, ActiveRecord::Tasks::DatabaseTasks.migrations_paths, version)
       db_namespace['_dump'].invoke
     end
@@ -110,28 +113,13 @@ db_namespace = namespace :db do
       unless ActiveRecord::SchemaMigration.table_exists?
         abort 'Schema migrations table does not exist yet.'
       end
-      db_list = ActiveRecord::SchemaMigration.normalized_versions
-
-      file_list =
-          ActiveRecord::Tasks::DatabaseTasks.migrations_paths.flat_map do |path|
-            Dir.foreach(path).map do |file|
-              next unless ActiveRecord::Migrator.match_to_migration_filename?(file)
-
-              version, name, scope = ActiveRecord::Migrator.parse_migration_filename(file)
-              version = ActiveRecord::SchemaMigration.normalize_migration_number(version)
-              status = db_list.delete(version) ? 'up' : 'down'
-              [status, version, (name + scope).humanize]
-            end.compact
-          end
 
-      db_list.map! do |version|
-        ['up', version, '********** NO FILE **********']
-      end
       # output
       puts "\ndatabase: #{ActiveRecord::Base.connection_config[:database]}\n\n"
       puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
       puts "-" * 50
-      (db_list + file_list).sort_by { |_, version, _| version }.each do |status, version, name|
+      paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
+      ActiveRecord::Migrator.migrations_status(paths).each do |status, version, name|
         puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
       end
       puts

data/lib/active_record/relation/calculations.rb

@@ -282,7 +282,7 @@ module ActiveRecord
           operation,
           distinct).as(aggregate_alias)
       ]
-      select_values += select_values unless having_clause.empty?
+      select_values += self.select_values unless having_clause.empty?
 
       select_values.concat group_columns.map { |aliaz, field|
         if field.respond_to?(:as)

data/lib/active_record/relation/delegation.rb

@@ -24,6 +24,8 @@ module ActiveRecord
 
       def inherited(child_class)
         child_class.initialize_relation_delegate_cache
+        delegate = child_class.relation_delegate_class(ActiveRecord::Associations::CollectionProxy)
+        delegate.include ActiveRecord::Associations::CollectionProxy::DelegateExtending
         super
       end
     end

data/lib/active_record/tasks/database_tasks.rb

@@ -154,6 +154,8 @@ module ActiveRecord
       end
 
       def migrate
+        raise "Empty VERSION provided" if ENV["VERSION"] && ENV["VERSION"].empty?
+
         verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
         version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
         scope   = ENV['SCOPE']

data/lib/active_record/transactions.rb

@@ -124,7 +124,7 @@ module ActiveRecord
     #     # statement will cause a PostgreSQL error, even though the unique
     #     # constraint is no longer violated:
     #     Number.create(i: 1)
-    #     # => "PGError: ERROR:  current transaction is aborted, commands
+    #     # => "PG::Error: ERROR:  current transaction is aborted, commands
     #     #     ignored until end of transaction block"
     #   end
     #

data/lib/rails/generators/active_record/migration.rb

@@ -20,6 +20,14 @@ module ActiveRecord
           key_type = options[:primary_key_type]
           ", id: :#{key_type}" if key_type
         end
+
+        def db_migrate_path
+          if defined?(Rails.application) && Rails.application
+            Rails.application.config.paths["db/migrate"].to_ary.first
+          else
+            "db/migrate"
+          end
+        end
     end
   end
 end

data/lib/rails/generators/active_record/migration/migration_generator.rb

@@ -68,14 +68,6 @@ module ActiveRecord
         def normalize_table_name(_table_name)
           pluralize_table_names? ? _table_name.pluralize : _table_name.singularize
         end
-
-        def db_migrate_path
-          if defined?(Rails) && Rails.application
-            Rails.application.config.paths["db/migrate"].to_ary.first
-          else
-            "db/migrate"
-          end
-        end
     end
   end
 end

data/lib/rails/generators/active_record/model/model_generator.rb

@@ -64,14 +64,6 @@ module ActiveRecord
             'app/models/application_record.rb'
           end
         end
-
-        def db_migrate_path
-          if defined?(Rails) && Rails.application
-            Rails.application.config.paths["db/migrate"].to_ary.first
-          else
-            "db/migrate"
-          end
-        end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord
 version: !ruby/object:Gem::Version
-  version: 5.0.2
+  version: 5.0.3
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-01 00:00:00.000000000 Z
+date: 2017-05-12 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.2
+        version: 5.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.0.2
+        version: 5.0.3
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.0.2
+        version: 5.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.0.2
+        version: 5.0.3
 - !ruby/object:Gem::Dependency
   name: arel
   requirement: !ruby/object:Gem::Requirement
@@ -333,3 +333,4 @@ signing_key:
 specification_version: 4
 summary: Object-relational mapper framework (part of Rails).
 test_files: []
+has_rdoc: