activerecord 6.0.0.beta1 → 6.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c6ced19e10b6f6d4eb33ac9745ce89e3b4ee124c02080e582abe07b9e5ac9a6
-  data.tar.gz: d0267bc9be2b86eea525eebd296a3eba6dd098ae154c6ec6b91978164e91a898
+  metadata.gz: 65ea4dc67676807bb1cec848b592808e9ae0c17428347bc1c54b9d8c7fe7540d
+  data.tar.gz: e0c6e2c537026df44775de8c26e8999ce304bfb77fddd9b8f854758c655540b7
 SHA512:
-  metadata.gz: 0fa88cf19b4df3cafcb246c31b104bc0df9a231f131d8c046fa20adb20f06285da1379a55ee82b3ef18e313212b4ae88f8f35752ae99bffcd0e669ca6f255b1d
-  data.tar.gz: 37f5229326765cb0c16f1501c4f3ade8594166a7999402f1016e23dfc9ec01ca009fa6abaf6e0751e288d533393592fe1db64fd0301c1ae1e1bfe5ff4c08d010
+  metadata.gz: 3f5d1751f4b0be87fe91d8aac2216dd3184374b59e84b02d02f5578729bf22a51e73a9b21fc2bbc86a869cdbdd2386f6e25c0aba3424be842de17d2891844f4d
+  data.tar.gz: 1826fca9a8b097f7e4dd896fc08012bf10ce40159d75676838e16cb2dd72dce252eef5f3a4ab2a0a7eef1438c47584b0521d7fd9f573fa5bfb61cbfe11d98d52

data/CHANGELOG.md

@@ -1,3 +1,100 @@
+## Rails 6.0.0.beta2 (February 25, 2019) ##
+
+*   Fix prepared statements caching to be enabled even when query caching is enabled.
+
+    *Ryuta Kamizono*
+
+*   Ensure `update_all` series cares about optimistic locking.
+
+    *Ryuta Kamizono*
+
+*   Don't allow `where` with non numeric string matches to 0 values.
+
+    *Ryuta Kamizono*
+
+*   Introduce `ActiveRecord::Relation#destroy_by` and `ActiveRecord::Relation#delete_by`.
+
+    `destroy_by` allows relation to find all the records matching the condition and perform
+    `destroy_all` on the matched records.
+
+    Example:
+
+        Person.destroy_by(name: 'David')
+        Person.destroy_by(name: 'David', rating: 4)
+
+        david = Person.find_by(name: 'David')
+        david.posts.destroy_by(id: [1, 2, 3])
+
+    `delete_by` allows relation to find all the records matching the condition and perform
+    `delete_all` on the matched records.
+
+    Example:
+
+        Person.delete_by(name: 'David')
+        Person.delete_by(name: 'David', rating: 4)
+
+        david = Person.find_by(name: 'David')
+        david.posts.delete_by(id: [1, 2, 3])
+
+    *Abhay Nikam*
+
+*   Don't allow `where` with invalid value matches to nil values.
+
+    Fixes #33624.
+
+    *Ryuta Kamizono*
+
+*   SQLite3: Implement `add_foreign_key` and `remove_foreign_key`.
+
+    *Ryuta Kamizono*
+
+*   Deprecate using class level querying methods if the receiver scope
+    regarded as leaked. Use `klass.unscoped` to avoid the leaking scope.
+
+    *Ryuta Kamizono*
+
+*   Allow applications to automatically switch connections.
+
+    Adds a middleware and configuration options that can be used in your
+    application to automatically switch between the writing and reading
+    database connections.
+
+    `GET` and `HEAD` requests will read from the replica unless there was
+    a write in the last 2 seconds, otherwise they will read from the primary.
+    Non-get requests will always write to the primary. The middleware accepts
+    an argument for a Resolver class and a Operations class where you are able
+    to change how the auto-switcher works to be most beneficial for your
+    application.
+
+    To use the middleware in your application you can use the following
+    configuration options:
+
+    ```
+    config.active_record.database_selector = { delay: 2.seconds }
+    config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
+    config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
+    ```
+
+    To change the database selection strategy, pass a custom class to the
+    configuration options:
+
+    ```
+    config.active_record.database_selector = { delay: 10.seconds }
+    config.active_record.database_resolver = MyResolver
+    config.active_record.database_resolver_context = MyResolver::MyCookies
+    ```
+
+    *Eileen M. Uchitelle*
+
+*   MySQL: Support `:size` option to change text and blob size.
+
+    *Ryuta Kamizono*
+
+*   Make `t.timestamps` with precision by default.
+
+    *Ryuta Kamizono*
+
+
 ## Rails 6.0.0.beta1 (January 18, 2019) ##
 
 *   Remove deprecated `#set_state` from the transaction object.
@@ -454,8 +551,8 @@
 
     Iterating over the database configurations has also changed. Instead of
     calling hash methods on the `configurations` hash directly, a new method `configs_for` has
-    been provided that allows you to select the correct configuration. `env_name`, and
-    `spec_name` arguments are optional. For example these return an array of
+    been provided that allows you to select the correct configuration. `env_name` and
+    `spec_name` arguments are optional. For example, these return an array of
     database config objects for the requested environment and a single database config object
     will be returned for the requested environment and specification name respectively.
 

data/lib/active_record.rb

@@ -74,6 +74,7 @@ module ActiveRecord
   autoload :Translation
   autoload :Validations
   autoload :SecureToken
+  autoload :DatabaseSelector, "active_record/middleware/database_selector"
 
   eager_autoload do
     autoload :ActiveRecordError, "active_record/errors"
@@ -153,6 +154,12 @@ module ActiveRecord
     end
   end
 
+  module Middleware
+    extend ActiveSupport::Autoload
+
+    autoload :DatabaseSelector, "active_record/middleware/database_selector"
+  end
+
   module Tasks
     extend ActiveSupport::Autoload
 

data/lib/active_record/associations/association.rb

@@ -17,6 +17,23 @@ module ActiveRecord
     #     CollectionAssociation
     #       HasManyAssociation + ForeignAssociation
     #         HasManyThroughAssociation + ThroughAssociation
+    #
+    # Associations in Active Record are middlemen between the object that
+    # holds the association, known as the <tt>owner</tt>, and the associated
+    # result set, known as the <tt>target</tt>. Association metadata is available in
+    # <tt>reflection</tt>, which is an instance of <tt>ActiveRecord::Reflection::AssociationReflection</tt>.
+    #
+    # For example, given
+    #
+    #   class Blog < ActiveRecord::Base
+    #     has_many :posts
+    #   end
+    #
+    #   blog = Blog.first
+    #
+    # The association of <tt>blog.posts</tt> has the object +blog+ as its
+    # <tt>owner</tt>, the collection of its posts as <tt>target</tt>, and
+    # the <tt>reflection</tt> object represents a <tt>:has_many</tt> macro.
     class Association #:nodoc:
       attr_reader :owner, :target, :reflection
 

data/lib/active_record/associations/collection_association.rb

@@ -109,9 +109,8 @@ module ActiveRecord
         end
       end
 
-      # Add +records+ to this association. Returns +self+ so method calls may
-      # be chained. Since << flattens its argument list and inserts each record,
-      # +push+ and +concat+ behave identically.
+      # Add +records+ to this association. Since +<<+ flattens its argument list
+      # and inserts each record, +push+ and +concat+ behave identically.
       def concat(*records)
         records = records.flatten
         if owner.new_record?
@@ -233,7 +232,7 @@ module ActiveRecord
       # loaded and you are going to fetch the records anyway it is better to
       # check <tt>collection.length.zero?</tt>.
       def empty?
-        if loaded? || @association_ids
+        if loaded? || @association_ids || reflection.has_cached_counter?
           size.zero?
         else
           target.empty? && !scope.exists?
@@ -347,7 +346,6 @@ module ActiveRecord
               add_to_target(record) do
                 result = insert_record(record, true, raise) {
                   @_was_loaded = loaded?
-                  @association_ids = nil
                 }
               end
               raise ActiveRecord::Rollback unless result
@@ -384,6 +382,7 @@ module ActiveRecord
 
           delete_records(existing_records, method) if existing_records.any?
           @target -= records
+          @association_ids = nil
 
           records.each { |record| callback(:after_remove, record) }
         end
@@ -424,7 +423,6 @@ module ActiveRecord
               unless owner.new_record?
                 result &&= insert_record(record, true, raise) {
                   @_was_loaded = loaded?
-                  @association_ids = nil
                 }
               end
             end
@@ -447,6 +445,7 @@ module ActiveRecord
           if index
             target[index] = record
           elsif @_was_loaded || !loaded?
+            @association_ids = nil
             target << record
           end
 

data/lib/active_record/associations/collection_proxy.rb

@@ -2,11 +2,8 @@
 
 module ActiveRecord
   module Associations
-    # Association proxies in Active Record are middlemen between the object that
-    # holds the association, known as the <tt>@owner</tt>, and the actual associated
-    # object, known as the <tt>@target</tt>. The kind of association any proxy is
-    # about is available in <tt>@reflection</tt>. That's an instance of the class
-    # ActiveRecord::Reflection::AssociationReflection.
+    # Collection proxies in Active Record are middlemen between an
+    # <tt>association</tt>, and its <tt>target</tt> result set.
     #
     # For example, given
     #
@@ -16,14 +13,14 @@ module ActiveRecord
     #
     #   blog = Blog.first
     #
-    # the association proxy in <tt>blog.posts</tt> has the object in +blog+ as
-    # <tt>@owner</tt>, the collection of its posts as <tt>@target</tt>, and
-    # the <tt>@reflection</tt> object represents a <tt>:has_many</tt> macro.
+    # The collection proxy returned by <tt>blog.posts</tt> is built from a
+    # <tt>:has_many</tt> <tt>association</tt>, and delegates to a collection
+    # of posts as the <tt>target</tt>.
     #
-    # This class delegates unknown methods to <tt>@target</tt> via
-    # <tt>method_missing</tt>.
+    # This class delegates unknown methods to the <tt>association</tt>'s
+    # relation class via a delegate cache.
     #
-    # The <tt>@target</tt> object is not \loaded until needed. For example,
+    # The <tt>target</tt> result set is not loaded until needed. For example,
     #
     #   blog.posts.count
     #
@@ -366,34 +363,6 @@ module ActiveRecord
         @association.create!(attributes, &block)
       end
 
-      # Add one or more records to the collection by setting their foreign keys
-      # to the association's primary key. Since #<< flattens its argument list and
-      # inserts each record, +push+ and #concat behave identically. Returns +self+
-      # so method calls may be chained.
-      #
-      #   class Person < ActiveRecord::Base
-      #     has_many :pets
-      #   end
-      #
-      #   person.pets.size # => 0
-      #   person.pets.concat(Pet.new(name: 'Fancy-Fancy'))
-      #   person.pets.concat(Pet.new(name: 'Spook'), Pet.new(name: 'Choo-Choo'))
-      #   person.pets.size # => 3
-      #
-      #   person.id # => 1
-      #   person.pets
-      #   # => [
-      #   #       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
-      #   #       #<Pet id: 2, name: "Spook", person_id: 1>,
-      #   #       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
-      #   #    ]
-      #
-      #   person.pets.concat([Pet.new(name: 'Brain'), Pet.new(name: 'Benny')])
-      #   person.pets.size # => 5
-      def concat(*records)
-        @association.concat(*records)
-      end
-
       # Replaces this collection with +other_array+. This will perform a diff
       # and delete/add only records that have changed.
       #
@@ -1033,8 +1002,9 @@ module ActiveRecord
       end
 
       # Adds one or more +records+ to the collection by setting their foreign keys
-      # to the association's primary key. Returns +self+, so several appends may be
-      # chained together.
+      # to the association's primary key. Since +<<+ flattens its argument list and
+      # inserts each record, +push+ and +concat+ behave identically. Returns +self+
+      # so several appends may be chained together.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets
@@ -1057,6 +1027,7 @@ module ActiveRecord
       end
       alias_method :push, :<<
       alias_method :append, :<<
+      alias_method :concat, :<<
 
       def prepend(*args)
         raise NoMethodError, "prepend on association is not defined. Please use <<, push or append"

data/lib/active_record/associations/has_many_association.rb

@@ -36,14 +36,6 @@ module ActiveRecord
         super
       end
 
-      def empty?
-        if reflection.has_cached_counter?
-          size.zero?
-        else
-          super
-        end
-      end
-
       private
 
         # Returns the number of records in this collection.
@@ -69,7 +61,7 @@ module ActiveRecord
           # If there's nothing in the database and @target has no new records
           # we are certain the current target is an empty array. This is a
           # documented side-effect of the method that may avoid an extra SELECT.
-          (@target ||= []) && loaded! if count == 0
+          loaded! if count == 0
 
           [association_scope.limit_value, count].compact.min
         end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_record/associations/join_dependency/join_part"
+require "active_support/core_ext/array/extract"
 
 module ActiveRecord
   module Associations
@@ -30,17 +31,21 @@ module ActiveRecord
             table = tables[-i]
             klass = reflection.klass
 
-            constraint = reflection.build_join_constraint(table, foreign_table)
+            join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
 
-            joins << table.create_join(table, table.create_on(constraint), join_type)
-
-            join_scope = reflection.join_scope(table, foreign_klass)
             arel = join_scope.arel(alias_tracker.aliases)
+            nodes = arel.constraints.first
+
+            others = nodes.children.extract! do |node|
+              Arel.fetch_attribute(node) { |attr| attr.relation.name != table.name }
+            end
+
+            joins << table.create_join(table, table.create_on(nodes), join_type)
 
-            if arel.constraints.any?
+            unless others.empty?
               joins.concat arel.join_sources
               right = joins.last.right
-              right.expr = right.expr.and(arel.constraints)
+              right.expr.children.concat(others)
             end
 
             # The current table in this iteration becomes the foreign table in the next

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

@@ -42,11 +42,10 @@ module ActiveRecord
 
           def associate_records_to_owner(owner, records)
             association = owner.association(reflection.name)
-            association.loaded!
             if reflection.collection?
-              association.target.concat(records)
+              association.target = records
             else
-              association.target = records.first unless records.empty?
+              association.target = records.first
             end
           end
 
@@ -116,7 +115,7 @@ module ActiveRecord
           def build_scope
             scope = klass.scope_for_association
 
-            if reflection.type
+            if reflection.type && !reflection.through_reflection?
               scope.where!(reflection.type => model.polymorphic_name)
             end
 

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

@@ -7,10 +7,9 @@ module ActiveRecord
         def run(preloader)
           already_loaded     = owners.first.association(through_reflection.name).loaded?
           through_scope      = through_scope()
-          reflection_scope   = target_reflection_scope
           through_preloaders = preloader.preload(owners, through_reflection.name, through_scope)
           middle_records     = through_preloaders.flat_map(&:preloaded_records)
-          preloaders         = preloader.preload(middle_records, source_reflection.name, reflection_scope)
+          preloaders         = preloader.preload(middle_records, source_reflection.name, scope)
           @preloaded_records = preloaders.flat_map(&:preloaded_records)
 
           owners.each do |owner|
@@ -25,18 +24,18 @@ module ActiveRecord
               owner.association(through_reflection.name).reset if through_scope
             end
             result = through_records.flat_map do |record|
-              association = record.association(source_reflection.name)
-              target = association.target
-              association.reset if preload_scope
-              target
+              record.association(source_reflection.name).target
             end
             result.compact!
-            if reflection_scope
-              result.sort_by! { |rhs| preload_index[rhs] } if reflection_scope.order_values.any?
-              result.uniq! if reflection_scope.distinct_value
-            end
+            result.sort_by! { |rhs| preload_index[rhs] } if scope.order_values.any?
+            result.uniq! if scope.distinct_value
             associate_records_to_owner(owner, result)
           end
+          unless scope.empty_scope?
+            middle_records.each do |owner|
+              owner.association(source_reflection.name).reset
+            end
+          end
         end
 
         private
@@ -91,16 +90,6 @@ module ActiveRecord
 
             scope unless scope.empty_scope?
           end
-
-          def target_reflection_scope
-            if preload_scope
-              reflection_scope.merge(preload_scope)
-            elsif reflection.scope
-              reflection_scope
-            else
-              nil
-            end
-          end
       end
     end
   end