activerecord 6.0.0.rc1 → 6.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eef34b080ecf453eb7de6b2b21fd1664c907b4a56ce8b34077da04422c14b528
-  data.tar.gz: 1f03004e330e5825d91500dd14584568fbbb647dd05a91d750d1f84ee83501b1
+  metadata.gz: 97bc72165e9eb1685576780f439be5be8894b7c589cc890d8c6340b8125de0a4
+  data.tar.gz: 74d58cd2f64976ef8faa42a02e94e6d9c9356fce3f0f2c219f7377a09712e7a4
 SHA512:
-  metadata.gz: a9368890aab4ae0d88d495501d21a21481a4ccd891c7ddd65219cfb18fd10418456959c9e1b24edc13ba0200ee9dd96fa0deea56da2214d03e838293625782c3
-  data.tar.gz: a5c09c091e320de679561ef84cd58833d8a3b4d477aa98f6d917fb494b20bbf3d55dfb6e3167e91a613f8868844a32ae71364b7fb35d5221ecf526066e8371cb
+  metadata.gz: 5306d17e736a64c87fc0115299b055c58343df4d18a53d532b09e570d6cc799abf84b4149deef9c03f56563ed23ee563cf57d03fc6c65529e9a6aa0324ca1614
+  data.tar.gz: 6fe8094ad7c0d0433c23691e372417124bddf17659c4bcb64b0bca5af0513d2c9b8599cfe0c244d28649529ab64b99c4a74b638bdf5ab9b4932c276a287d1e78

data/CHANGELOG.md

@@ -1,3 +1,42 @@
+## Rails 6.0.0.rc2 (July 22, 2019) ##
+
+*   Add database_exists? method to connection adapters to check if a database exists.
+
+    *Guilherme Mansur*
+
+*   PostgreSQL: Fix GROUP BY with ORDER BY virtual count attribute.
+
+    Fixes #36022.
+
+    *Ryuta Kamizono*
+
+*   Make ActiveRecord `ConnectionPool.connections` method thread-safe.
+
+    Fixes #36465.
+
+    *Jeff Doering*
+
+*   Fix sqlite3 collation parsing when using decimal columns.
+
+    *Martin R. Schuster*
+
+*   Fix invalid schema when primary key column has a comment.
+
+    Fixes #29966.
+
+    *Guilherme Goettems Schneider*
+
+*   Fix table comment also being applied to the primary key column.
+
+    *Guilherme Goettems Schneider*
+
+*   Fix merging left_joins to maintain its own `join_type` context.
+
+    Fixes #36103.
+
+    *Ryuta Kamizono*
+
+
 ## Rails 6.0.0.rc1 (April 24, 2019) ##
 
 *   Add `touch` option to `has_one` association.

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

@@ -22,9 +22,9 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     def self.define_extensions(model, name, &block)
       if block_given?
-        extension_module_name = "#{model.name.demodulize}#{name.to_s.camelize}AssociationExtension"
+        extension_module_name = "#{name.to_s.camelize}AssociationExtension"
         extension = Module.new(&block)
-        model.module_parent.const_set(extension_module_name, extension)
+        model.const_set(extension_module_name, extension)
       end
     end
 

data/lib/active_record/associations/collection_proxy.rb

@@ -1029,7 +1029,7 @@ module ActiveRecord
       alias_method :append, :<<
       alias_method :concat, :<<
 
-      def prepend(*args)
+      def prepend(*args) # :nodoc:
         raise NoMethodError, "prepend on association is not defined. Please use <<, push or append"
       end
 

data/lib/active_record/associations/join_dependency.rb

@@ -64,16 +64,17 @@ module ActiveRecord
         end
       end
 
-      def initialize(base, table, associations)
+      def initialize(base, table, associations, join_type)
         tree = self.class.make_tree associations
         @join_root = JoinBase.new(base, table, build(tree, base))
+        @join_type = join_type
       end
 
       def reflections
         join_root.drop(1).map!(&:reflection)
       end
 
-      def join_constraints(joins_to_add, join_type, alias_tracker)
+      def join_constraints(joins_to_add, alias_tracker)
         @alias_tracker = alias_tracker
 
         construct_tables!(join_root)
@@ -82,9 +83,9 @@ module ActiveRecord
         joins.concat joins_to_add.flat_map { |oj|
           construct_tables!(oj.join_root)
           if join_root.match? oj.join_root
-            walk join_root, oj.join_root
+            walk(join_root, oj.join_root, oj.join_type)
           else
-            make_join_constraints(oj.join_root, join_type)
+            make_join_constraints(oj.join_root, oj.join_type)
           end
         }
       end
@@ -125,7 +126,7 @@ module ActiveRecord
       end
 
       protected
-        attr_reader :join_root
+        attr_reader :join_root, :join_type
 
       private
         attr_reader :alias_tracker
@@ -151,7 +152,7 @@ module ActiveRecord
           end
         end
 
-        def make_constraints(parent, child, join_type = Arel::Nodes::OuterJoin)
+        def make_constraints(parent, child, join_type)
           foreign_table = parent.table
           foreign_klass = parent.base_klass
           joins = child.join_constraints(foreign_table, foreign_klass, join_type, alias_tracker)
@@ -173,13 +174,13 @@ module ActiveRecord
           join ? "#{name}_join" : name
         end
 
-        def walk(left, right)
+        def walk(left, right, join_type)
           intersection, missing = right.children.map { |node1|
             [left.children.find { |node2| node1.match? node2 }, node1]
           }.partition(&:first)
 
-          joins = intersection.flat_map { |l, r| r.table = l.table; walk(l, r) }
-          joins.concat missing.flat_map { |_, n| make_constraints(left, n) }
+          joins = intersection.flat_map { |l, r| r.table = l.table; walk(l, r, join_type) }
+          joins.concat missing.flat_map { |_, n| make_constraints(left, n, join_type) }
         end
 
         def find_reflection(klass, name)

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

@@ -44,8 +44,7 @@ module ActiveRecord
 
             unless others.empty?
               joins.concat arel.join_sources
-              right = joins.last.right
-              right.expr.children.concat(others)
+              append_constraints(joins.last, others)
             end
 
             # The current table in this iteration becomes the foreign table in the next
@@ -65,6 +64,16 @@ module ActiveRecord
 
           @readonly = reflection.scope && reflection.scope_for(base_klass.unscoped).readonly_value
         end
+
+        private
+          def append_constraints(join, constraints)
+            if join.is_a?(Arel::Nodes::StringJoin)
+              join_string = table.create_and(constraints.unshift(join.left))
+              join.left = Arel.sql(base_klass.connection.visitor.compile(join_string))
+            else
+              join.right.expr.children.concat(constraints)
+            end
+          end
       end
     end
   end

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

@@ -27,7 +27,9 @@ module ActiveRecord
         end
 
         def records_by_owner
-          @records_by_owner ||= preloaded_records.each_with_object({}) do |record, result|
+          # owners can be duplicated when a relation has a collection association join
+          # #compare_by_identity makes such owners different hash keys
+          @records_by_owner ||= preloaded_records.each_with_object({}.compare_by_identity) do |record, result|
             owners_by_key[convert_key(record[association_key_name])].each do |owner|
               (result[owner] ||= []) << record
             end

data/lib/active_record/attribute_methods.rb

@@ -159,57 +159,6 @@ module ActiveRecord
         end
       end
 
-      # Regexp for column names (with or without a table name prefix). Matches
-      # the following:
-      #   "#{table_name}.#{column_name}"
-      #   "#{column_name}"
-      COLUMN_NAME = /\A(?:\w+\.)?\w+\z/i
-
-      # Regexp for column names with order (with or without a table name
-      # prefix, with or without various order modifiers). Matches the following:
-      #   "#{table_name}.#{column_name}"
-      #   "#{table_name}.#{column_name} #{direction}"
-      #   "#{table_name}.#{column_name} #{direction} NULLS FIRST"
-      #   "#{table_name}.#{column_name} NULLS LAST"
-      #   "#{column_name}"
-      #   "#{column_name} #{direction}"
-      #   "#{column_name} #{direction} NULLS FIRST"
-      #   "#{column_name} NULLS LAST"
-      COLUMN_NAME_WITH_ORDER = /
-        \A
-        (?:\w+\.)?
-        \w+
-        (?:\s+asc|\s+desc)?
-        (?:\s+nulls\s+(?:first|last))?
-        \z
-      /ix
-
-      def disallow_raw_sql!(args, permit: COLUMN_NAME) # :nodoc:
-        unexpected = args.reject do |arg|
-          Arel.arel_node?(arg) ||
-            arg.to_s.split(/\s*,\s*/).all? { |part| permit.match?(part) }
-        end
-
-        return if unexpected.none?
-
-        if allow_unsafe_raw_sql == :deprecated
-          ActiveSupport::Deprecation.warn(
-            "Dangerous query method (method whose arguments are used as raw " \
-            "SQL) called with non-attribute argument(s): " \
-            "#{unexpected.map(&:inspect).join(", ")}. Non-attribute " \
-            "arguments will be disallowed in Rails 6.1. This method should " \
-            "not be called with user-provided values, such as request " \
-            "parameters or model attributes. Known-safe values can be passed " \
-            "by wrapping them in Arel.sql()."
-          )
-        else
-          raise(ActiveRecord::UnknownAttributeReference,
-            "Query method called with non-attribute argument(s): " +
-            unexpected.map(&:inspect).join(", ")
-          )
-        end
-      end
-
       # Returns true if the given attribute exists, otherwise false.
       #
       #   class Person < ActiveRecord::Base

data/lib/active_record/attribute_methods/dirty.rb

@@ -177,6 +177,11 @@ module ActiveRecord
 
           affected_rows = super
 
+          if @_skip_dirty_tracking ||= false
+            clear_attribute_changes(@_touch_attr_names)
+            return affected_rows
+          end
+
           changes = {}
           @attributes.keys.each do |attr_name|
             next if @_touch_attr_names.include?(attr_name)
@@ -193,7 +198,7 @@ module ActiveRecord
 
           affected_rows
         ensure
-          @_touch_attr_names = nil
+          @_touch_attr_names, @_skip_dirty_tracking = nil, nil
         end
 
         def _update_record(attribute_names = attribute_names_for_partial_writes)

data/lib/active_record/autosave_association.rb

@@ -416,7 +416,7 @@ module ActiveRecord
                 saved = record.save(validate: false)
               end
 
-              raise ActiveRecord::Rollback unless saved
+              raise(RecordInvalid.new(association.owner)) unless saved
             end
           end
         end

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

@@ -3,6 +3,7 @@
 require "thread"
 require "concurrent/map"
 require "monitor"
+require "weakref"
 
 module ActiveRecord
   # Raised when a connection could not be obtained within the connection
@@ -19,6 +20,26 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
+    module AbstractPool # :nodoc:
+      def get_schema_cache(connection)
+        @schema_cache ||= SchemaCache.new(connection)
+        @schema_cache.connection = connection
+        @schema_cache
+      end
+
+      def set_schema_cache(cache)
+        @schema_cache = cache
+      end
+    end
+
+    class NullPool # :nodoc:
+      include ConnectionAdapters::AbstractPool
+
+      def initialize
+        @schema_cache = nil
+      end
+    end
+
     # Connection pool base class for managing Active Record database
     # connections.
     #
@@ -294,23 +315,51 @@ module ActiveRecord
           @frequency = frequency
         end
 
+        @mutex = Mutex.new
+        @pools = {}
+
+        class << self
+          def register_pool(pool, frequency) # :nodoc:
+            @mutex.synchronize do
+              unless @pools.key?(frequency)
+                @pools[frequency] = []
+                spawn_thread(frequency)
+              end
+              @pools[frequency] << WeakRef.new(pool)
+            end
+          end
+
+          private
+
+            def spawn_thread(frequency)
+              Thread.new(frequency) do |t|
+                loop do
+                  sleep t
+                  @mutex.synchronize do
+                    @pools[frequency].select!(&:weakref_alive?)
+                    @pools[frequency].each do |p|
+                      p.reap
+                      p.flush
+                    rescue WeakRef::RefError
+                    end
+                  end
+                end
+              end
+            end
+        end
+
         def run
           return unless frequency && frequency > 0
-          Thread.new(frequency, pool) { |t, p|
-            loop do
-              sleep t
-              p.reap
-              p.flush
-            end
-          }
+          self.class.register_pool(pool, frequency)
         end
       end
 
       include MonitorMixin
       include QueryCache::ConnectionPoolConfiguration
+      include ConnectionAdapters::AbstractPool
 
       attr_accessor :automatic_reconnect, :checkout_timeout, :schema_cache
-      attr_reader :spec, :connections, :size, :reaper
+      attr_reader :spec, :size, :reaper
 
       # Creates a new ConnectionPool object. +spec+ is a ConnectionSpecification
       # object which describes database connection information (e.g. adapter,
@@ -379,7 +428,7 @@ module ActiveRecord
       # #connection can be called any number of times; the connection is
       # held in a cache keyed by a thread.
       def connection
-        @thread_cached_conns[connection_cache_key(@lock_thread || Thread.current)] ||= checkout
+        @thread_cached_conns[connection_cache_key(current_thread)] ||= checkout
       end
 
       # Returns true if there is an open connection being used for the current thread.
@@ -388,7 +437,7 @@ module ActiveRecord
       # #connection or #with_connection methods. Connections obtained through
       # #checkout will not be detected by #active_connection?
       def active_connection?
-        @thread_cached_conns[connection_cache_key(Thread.current)]
+        @thread_cached_conns[connection_cache_key(current_thread)]
       end
 
       # Signal that the thread is finished with the current connection.
@@ -423,6 +472,21 @@ module ActiveRecord
         synchronize { @connections.any? }
       end
 
+      # Returns an array containing the connections currently in the pool.
+      # Access to the array does not require synchronization on the pool because
+      # the array is newly created and not retained by the pool.
+      #
+      # However; this method bypasses the ConnectionPool's thread-safe connection
+      # access pattern. A returned connection may be owned by another thread,
+      # unowned, or by happen-stance owned by the calling thread.
+      #
+      # Calling methods on a connection without ownership is subject to the
+      # thread-safety guarantees of the underlying method. Many of the methods
+      # on connection adapter classes are inherently multi-thread unsafe.
+      def connections
+        synchronize { @connections.dup }
+      end
+
       # Disconnects all connections in the pool, and clears the pool.
       #
       # Raises:
@@ -668,6 +732,10 @@ module ActiveRecord
           thread
         end
 
+        def current_thread
+          @lock_thread || Thread.current
+        end
+
         # Take control of all existing connections so a "group" action such as
         # reload/disconnect can be performed safely. It is no longer enough to
         # wrap it in +synchronize+ because some pool's actions are allowed
@@ -809,7 +877,6 @@ module ActiveRecord
 
         def new_connection
           Base.send(spec.adapter_method, spec.config).tap do |conn|
-            conn.schema_cache = schema_cache.dup if schema_cache
             conn.check_version
           end
         end
@@ -938,15 +1005,30 @@ module ActiveRecord
         end
       end
 
+      attr_reader :prevent_writes
+
       def initialize
         # These caches are keyed by spec.name (ConnectionSpecification#name).
         @owner_to_pool = ConnectionHandler.create_owner_to_pool
+        @prevent_writes = false
 
         # Backup finalizer: if the forked child never needed a pool, the above
         # early discard has not occurred
         ObjectSpace.define_finalizer self, ConnectionHandler.unowned_pool_finalizer(@owner_to_pool)
       end
 
+      # Prevent writing to the database regardless of role.
+      #
+      # In some cases you may want to prevent writes to the database
+      # even if you are on a database that can write. `while_preventing_writes`
+      # will prevent writes to the database for the duration of the block.
+      def while_preventing_writes
+        original, @prevent_writes = @prevent_writes, true
+        yield
+      ensure
+        @prevent_writes = original
+      end
+
       def connection_pool_list
         owner_to_pool.values.compact
       end