activerecord 5.1.4 → 5.1.5.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 28e7916b1dbc3b40c76d1c05b4e30f04d00dc210
-  data.tar.gz: 1ec9fb74675427203f1cded6cc322d39624cd3fd
+SHA256:
+  metadata.gz: 6016e93d2aaf0a0b209c596bfd75f89345d4c5e33a254d901bca0c8363e67edc
+  data.tar.gz: 87a1c2845000e04e863351025880efcd8a3a9c432fac308f73370817cce8b3b7
 SHA512:
-  metadata.gz: 94710c02a0c49929187fd1897b13d9a8cf8ea465c87c5ba90c0d17137d494ffeb08c64b38e278604e51670fa2bb74a36dce99721a1d16dee85728209902bfe18
-  data.tar.gz: 78e89e05559a4ee6fb64d13937a83f87f004f1bf3e86b3917f3df8f3a7cf177f1f1d2d0164ca5f84d08944814324e35394b16b76da3d6c868ef2875ea9a12513
+  metadata.gz: 78de0a487a64f1f212ee5c89ac80806f4cc21dc44af76855c856aef70525508330f1a177745811a3d6eb658ad4c5be0c2ca66e6808a40cfcb15a2c39fab73791
+  data.tar.gz: faac29bf1b8260798c0a1416ea73b8c45dc0ec738122a8adf68598688fa1e84d94357d3bc6ab892bcebabd39c595a377bb928fab7556bcd9ec9784609aa87a9d

data/CHANGELOG.md

@@ -1,3 +1,154 @@
+## Rails 5.1.5.rc1 (February 01, 2018) ##
+
+*   Fix `count(:all)` with eager loading and having an order other than the driving table.
+
+    Fixes #31783.
+
+    *Ryuta Kamizono*
+
+*   Use `count(:all)` in `HasManyAssociation#count_records` to prevent invalid
+    SQL queries for association counting.
+
+    *Klas Eskilson*
+
+*   Fix to invoke callbacks when using `update_attribute`.
+
+    *Mike Busch*
+
+*   Fix `count(:all)` to correctly work `distinct` with custom SELECT list.
+
+    *Ryuta Kamizono*
+
+*   Fix conflicts `counter_cache` with `touch: true` by optimistic locking.
+
+    ```
+    # create_table :posts do |t|
+    #   t.integer :comments_count, default: 0
+    #   t.integer :lock_version
+    #   t.timestamps
+    # end
+    class Post < ApplicationRecord
+    end
+
+    # create_table :comments do |t|
+    #   t.belongs_to :post
+    # end
+    class Comment < ApplicationRecord
+      belongs_to :post, touch: true, counter_cache: true
+    end
+    ```
+
+    Before:
+    ```
+    post = Post.create!
+    # => begin transaction
+         INSERT INTO "posts" ("created_at", "updated_at", "lock_version")
+         VALUES ("2017-12-11 21:27:11.387397", "2017-12-11 21:27:11.387397", 0)
+         commit transaction
+
+    comment = Comment.create!(post: post)
+    # => begin transaction
+         INSERT INTO "comments" ("post_id") VALUES (1)
+
+         UPDATE "posts" SET "comments_count" = COALESCE("comments_count", 0) + 1,
+         "lock_version" = COALESCE("lock_version", 0) + 1 WHERE "posts"."id" = 1
+
+         UPDATE "posts" SET "updated_at" = '2017-12-11 21:27:11.398330',
+         "lock_version" = 1 WHERE "posts"."id" = 1 AND "posts"."lock_version" = 0
+         rollback transaction
+    # => ActiveRecord::StaleObjectError: Attempted to touch a stale object: Post.
+
+    Comment.take.destroy!
+    # => begin transaction
+         DELETE FROM "comments" WHERE "comments"."id" = 1
+
+         UPDATE "posts" SET "comments_count" = COALESCE("comments_count", 0) - 1,
+         "lock_version" = COALESCE("lock_version", 0) + 1 WHERE "posts"."id" = 1
+
+         UPDATE "posts" SET "updated_at" = '2017-12-11 21:42:47.785901',
+         "lock_version" = 1 WHERE "posts"."id" = 1 AND "posts"."lock_version" = 0
+         rollback transaction
+    # => ActiveRecord::StaleObjectError: Attempted to touch a stale object: Post.
+    ```
+
+    After:
+    ```
+    post = Post.create!
+    # => begin transaction
+         INSERT INTO "posts" ("created_at", "updated_at", "lock_version")
+         VALUES ("2017-12-11 21:27:11.387397", "2017-12-11 21:27:11.387397", 0)
+         commit transaction
+
+    comment = Comment.create!(post: post)
+    # => begin transaction
+         INSERT INTO "comments" ("post_id") VALUES (1)
+
+         UPDATE "posts" SET "comments_count" = COALESCE("comments_count", 0) + 1,
+         "lock_version" = COALESCE("lock_version", 0) + 1,
+         "updated_at" = '2017-12-11 21:37:09.802642' WHERE "posts"."id" = 1
+         commit transaction
+
+    comment.destroy!
+    # => begin transaction
+         DELETE FROM "comments" WHERE "comments"."id" = 1
+
+         UPDATE "posts" SET "comments_count" = COALESCE("comments_count", 0) - 1,
+         "lock_version" = COALESCE("lock_version", 0) + 1,
+         "updated_at" = '2017-12-11 21:39:02.685520' WHERE "posts"."id" = 1
+         commit transaction
+    ```
+
+    Fixes #31199.
+
+    *bogdanvlviv*
+
+*   Query cache was unavailable when entering the `ActiveRecord::Base.cache` block
+    without being connected.
+
+    *Tsukasa Oishi*
+
+*   Fix `bin/rails db:setup` and `bin/rails db:test:prepare` create  wrong
+    ar_internal_metadata's data for a test database.
+
+    Before:
+    ```
+    $ RAILS_ENV=test rails dbconsole
+    > SELECT * FROM ar_internal_metadata;
+    key|value|created_at|updated_at
+    environment|development|2017-09-11 23:14:10.815679|2017-09-11 23:14:10.815679
+    ```
+
+    After:
+    ```
+    $ RAILS_ENV=test rails dbconsole
+    > SELECT * FROM ar_internal_metadata;
+    key|value|created_at|updated_at
+    environment|test|2017-09-11 23:14:10.815679|2017-09-11 23:14:10.815679
+    ```
+
+    Fixes #26731.
+
+    *bogdanvlviv*
+
+*   Fix longer sequence name detection for serial columns.
+
+    Fixes #28332.
+
+    *Ryuta Kamizono*
+
+*   MySQL: Don't lose `auto_increment: true` in the `db/schema.rb`.
+
+    Fixes #30894.
+
+    *Ryuta Kamizono*
+
+*   Fix `COUNT(DISTINCT ...)` for `GROUP BY` with `ORDER BY` and `LIMIT`.
+
+    Fixes #30886.
+
+    *Ryuta Kamizono*
+
+
 ## Rails 5.1.4 (September 07, 2017) ##
 
 *   No changes.

data/lib/active_record/associations/belongs_to_association.rb

@@ -47,9 +47,9 @@ module ActiveRecord
         def update_counters(by)
           if require_counter_update? && foreign_key_present?
             if target && !stale_target?
-              target.increment!(reflection.counter_cache_column, by)
+              target.increment!(reflection.counter_cache_column, by, touch: reflection.options[:touch])
             else
-              klass.update_counters(target_id, reflection.counter_cache_column => by)
+              klass.update_counters(target_id, reflection.counter_cache_column => by, touch: reflection.options[:touch])
             end
           end
         end

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

@@ -114,9 +114,13 @@ module ActiveRecord::Associations::Builder # :nodoc:
         BelongsTo.touch_record(record, record.send(changes_method), foreign_key, n, touch, belongs_to_touch_method)
       }}
 
-      model.after_save    callback.(:saved_changes), if: :saved_changes?
-      model.after_touch   callback.(:changes_to_save)
-      model.after_destroy callback.(:changes_to_save)
+      unless reflection.counter_cache_column
+        model.after_create callback.(:saved_changes), if: :saved_changes?
+        model.after_destroy callback.(:changes_to_save)
+      end
+
+      model.after_update callback.(:saved_changes), if: :saved_changes?
+      model.after_touch callback.(:changes_to_save)
     end
 
     def self.add_default_callbacks(model, reflection)

data/lib/active_record/associations/has_many_association.rb

@@ -61,7 +61,7 @@ module ActiveRecord
           count = if reflection.has_cached_counter?
             owner._read_attribute(reflection.counter_cache_column).to_i
           else
-            scope.count
+            scope.count(:all)
           end
 
           # If there's nothing in the database and @target has no new records

data/lib/active_record/associations/join_dependency.rb

@@ -126,7 +126,7 @@ module ActiveRecord
       end
 
       def aliases
-        Aliases.new join_root.each_with_index.map { |join_part, i|
+        @aliases ||= Aliases.new join_root.each_with_index.map { |join_part, i|
           columns = join_part.column_names.each_with_index.map { |column_name, j|
             Aliases::Column.new column_name, "t#{i}_r#{j}"
           }
@@ -134,7 +134,7 @@ module ActiveRecord
         }
       end
 
-      def instantiate(result_set, aliases)
+      def instantiate(result_set, &block)
         primary_key = aliases.column_alias(join_root, join_root.primary_key)
 
         seen = Hash.new { |i, object_id|
@@ -157,7 +157,7 @@ module ActiveRecord
         message_bus.instrument("instantiation.active_record", payload) do
           result_set.each { |row_hash|
             parent_key = primary_key ? row_hash[primary_key] : row_hash
-            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases)
+            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, &block)
             construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
           }
         end

data/lib/active_record/associations/join_dependency/join_association.rb

@@ -40,15 +40,7 @@ module ActiveRecord
 
             constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
 
-            predicate_builder = PredicateBuilder.new(TableMetadata.new(klass, table))
-            scope_chain_items = reflection.join_scopes(table, predicate_builder)
-            klass_scope       = reflection.klass_join_scope(table, predicate_builder)
-
-            scope_chain_items.concat [klass_scope].compact
-
-            rel = scope_chain_items.inject(scope_chain_items.shift) do |left, right|
-              left.merge right
-            end
+            rel = reflection.join_scope(table)
 
             if rel && !rel.arel.constraints.empty?
               binds += rel.bound_attributes

data/lib/active_record/associations/preloader/association.rb

@@ -90,7 +90,11 @@ module ActiveRecord
           end
 
           def key_conversion_required?
-            @key_conversion_required ||= association_key_type != owner_key_type
+            unless defined?(@key_conversion_required)
+              @key_conversion_required = (association_key_type != owner_key_type)
+            end
+
+            @key_conversion_required
           end
 
           def convert_key(key)
@@ -127,42 +131,15 @@ module ActiveRecord
           end
 
           def build_scope
-            scope = klass.unscoped
-
-            values = reflection_scope.values
-            preload_values = preload_scope.values
-
-            scope.where_clause = reflection_scope.where_clause + preload_scope.where_clause
-            scope.references_values = Array(values[:references]) + Array(preload_values[:references])
-
-            if preload_values[:select] || values[:select]
-              scope._select!(preload_values[:select] || values[:select])
-            end
-            scope.includes! preload_values[:includes] || values[:includes]
-            if preload_scope.joins_values.any?
-              scope.joins!(preload_scope.joins_values)
-            else
-              scope.joins!(reflection_scope.joins_values)
-            end
-
-            if order_values = preload_values[:order] || values[:order]
-              scope.order!(order_values)
-            end
-
-            if preload_values[:reordering] || values[:reordering]
-              scope.reordering_value = true
-            end
-
-            if preload_values[:readonly] || values[:readonly]
-              scope.readonly!
-            end
+            scope = klass.scope_for_association
 
-            if options[:as]
-              scope.where!(klass.table_name => { reflection.type => model.base_class.sti_name })
+            if reflection.type
+              scope.where!(reflection.type => model.base_class.sti_name)
             end
 
-            scope.unscope_values = Array(values[:unscope]) + Array(preload_values[:unscope])
-            klass.scope_for_association.merge(scope)
+            scope.merge!(reflection_scope)
+            scope.merge!(preload_scope) if preload_scope != NULL_RELATION
+            scope
           end
       end
     end

data/lib/active_record/associations/preloader/through_association.rb

@@ -81,17 +81,24 @@ module ActiveRecord
 
           def through_scope
             scope = through_reflection.klass.unscoped
+            values = reflection_scope.values
 
             if options[:source_type]
               scope.where! reflection.foreign_type => options[:source_type]
             else
               unless reflection_scope.where_clause.empty?
-                scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
+                scope.includes_values = Array(values[:includes] || options[:source])
                 scope.where_clause = reflection_scope.where_clause
+                if joins = values[:joins]
+                  scope.joins!(source_reflection.name => joins)
+                end
+                if left_outer_joins = values[:left_outer_joins]
+                  scope.left_outer_joins!(source_reflection.name => left_outer_joins)
+                end
               end
 
-              scope.references! reflection_scope.values[:references]
-              if scope.eager_loading? && order_values = reflection_scope.values[:order]
+              scope.references! values[:references]
+              if scope.eager_loading? && order_values = values[:order]
                 scope = scope.order(order_values)
               end
             end

data/lib/active_record/attribute_methods/dirty.rb

@@ -63,7 +63,7 @@ module ActiveRecord
       end
 
       def changes_internally_applied # :nodoc:
-        @mutations_before_last_save = mutation_tracker
+        @mutations_before_last_save = mutations_from_database
         forget_attribute_assignments
         @mutations_from_database = AttributeMutationTracker.new(@attributes)
       end
@@ -71,7 +71,8 @@ module ActiveRecord
       def changes_applied # :nodoc:
         @previous_mutation_tracker = mutation_tracker
         @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-        clear_mutation_trackers
+        @mutation_tracker = nil
+        @mutations_from_database = nil
       end
 
       def clear_changes_information # :nodoc:

data/lib/active_record/collection_cache_key.rb

@@ -4,8 +4,8 @@ module ActiveRecord
       query_signature = Digest::MD5.hexdigest(collection.to_sql)
       key = "#{collection.model_name.cache_key}/query-#{query_signature}"
 
-      if collection.loaded?
-        size = collection.size
+      if collection.loaded? || collection.distinct_value
+        size = collection.records.size
         if size > 0
           timestamp = collection.max_by(&timestamp_column)._read_attribute(timestamp_column)
         end

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

@@ -108,6 +108,7 @@ module ActiveRecord
                   "sql.active_record",
                   sql: sql,
                   binds: binds,
+                  type_casted_binds: -> { type_casted_binds(binds) },
                   name: name,
                   connection_id: object_id,
                   cached: true,

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

@@ -60,7 +60,7 @@ module ActiveRecord
           end
 
           def visit_PrimaryKeyDefinition(o)
-            "PRIMARY KEY (#{o.name.join(', ')})"
+            "PRIMARY KEY (#{o.name.map { |name| quote_column_name(name) }.join(', ')})"
           end
 
           def visit_ForeignKeyDefinition(o)

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

@@ -121,7 +121,7 @@ module ActiveRecord
         end
 
         def polymorphic_options
-          as_options(polymorphic).merge(null: options[:null])
+          as_options(polymorphic).merge(options.slice(:null, :first, :after))
         end
 
         def index_options

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -4,6 +4,7 @@ require "active_record/connection_adapters/schema_cache"
 require "active_record/connection_adapters/sql_type_metadata"
 require "active_record/connection_adapters/abstract/schema_dumper"
 require "active_record/connection_adapters/abstract/schema_creation"
+require "active_support/concurrency/load_interlock_aware_monitor"
 require "arel/collectors/bind"
 require "arel/collectors/sql_string"
 
@@ -105,7 +106,7 @@ module ActiveRecord
         @schema_cache        = SchemaCache.new self
         @quoted_column_names, @quoted_table_names = {}, {}
         @visitor = arel_visitor
-        @lock = Monitor.new
+        @lock = ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
 
         if self.class.type_cast_config_to_boolean(config.fetch(:prepared_statements) { true })
           @prepared_statements = true

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -140,11 +140,11 @@ module ActiveRecord
       end
 
       def get_advisory_lock(lock_name, timeout = 0) # :nodoc:
-        query_value("SELECT GET_LOCK(#{quote(lock_name)}, #{timeout})") == 1
+        query_value("SELECT GET_LOCK(#{quote(lock_name.to_s)}, #{timeout})") == 1
       end
 
       def release_advisory_lock(lock_name) # :nodoc:
-        query_value("SELECT RELEASE_LOCK(#{quote(lock_name)})") == 1
+        query_value("SELECT RELEASE_LOCK(#{quote(lock_name.to_s)})") == 1
       end
 
       def native_database_types
@@ -464,12 +464,13 @@ module ActiveRecord
                  fk.constraint_name AS 'name',
                  rc.update_rule AS 'on_update',
                  rc.delete_rule AS 'on_delete'
-          FROM information_schema.key_column_usage fk
-          JOIN information_schema.referential_constraints rc
+          FROM information_schema.referential_constraints rc
+          JOIN information_schema.key_column_usage fk
           USING (constraint_schema, constraint_name)
           WHERE fk.referenced_column_name IS NOT NULL
             AND fk.table_schema = #{scope[:schema]}
             AND fk.table_name = #{scope[:name]}
+            AND rc.constraint_schema = #{scope[:schema]}
             AND rc.table_name = #{scope[:name]}
         SQL