activerecord 6.0.0.beta1 → 6.0.0

data/lib/active_record/relation/delegation.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "mutex_m"
+
 module ActiveRecord
   module Delegation # :nodoc:
     module DelegateCache # :nodoc:
@@ -31,6 +33,10 @@ module ActiveRecord
         super
       end
 
+      def generate_relation_method(method)
+        generated_relation_methods.generate_method(method)
+      end
+
       protected
         def include_relation_methods(delegate)
           superclass.include_relation_methods(delegate) unless base_class?
@@ -39,27 +45,35 @@ module ActiveRecord
 
       private
         def generated_relation_methods
-          @generated_relation_methods ||= Module.new.tap do |mod|
-            mod_name = "GeneratedRelationMethods"
-            const_set mod_name, mod
-            private_constant mod_name
+          @generated_relation_methods ||= GeneratedRelationMethods.new.tap do |mod|
+            const_set(:GeneratedRelationMethods, mod)
+            private_constant :GeneratedRelationMethods
           end
         end
+    end
+
+    class GeneratedRelationMethods < Module # :nodoc:
+      include Mutex_m
+
+      def generate_method(method)
+        synchronize do
+          return if method_defined?(method)
 
-        def generate_relation_method(method)
           if /\A[a-zA-Z_]\w*[!?]?\z/.match?(method)
-            generated_relation_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            module_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{method}(*args, &block)
                 scoping { klass.#{method}(*args, &block) }
               end
             RUBY
           else
-            generated_relation_methods.define_method(method) do |*args, &block|
+            define_method(method) do |*args, &block|
               scoping { klass.public_send(method, *args, &block) }
             end
           end
         end
+      end
     end
+    private_constant :GeneratedRelationMethods
 
     extend ActiveSupport::Concern
 
@@ -78,39 +92,17 @@ module ActiveRecord
     module ClassSpecificRelation # :nodoc:
       extend ActiveSupport::Concern
 
-      included do
-        @delegation_mutex = Mutex.new
-      end
-
       module ClassMethods # :nodoc:
         def name
           superclass.name
         end
-
-        def delegate_to_scoped_klass(method)
-          @delegation_mutex.synchronize do
-            return if method_defined?(method)
-
-            if /\A[a-zA-Z_]\w*[!?]?\z/.match?(method)
-              module_eval <<-RUBY, __FILE__, __LINE__ + 1
-                def #{method}(*args, &block)
-                  scoping { @klass.#{method}(*args, &block) }
-                end
-              RUBY
-            else
-              define_method method do |*args, &block|
-                scoping { @klass.public_send(method, *args, &block) }
-              end
-            end
-          end
-        end
       end
 
       private
 
         def method_missing(method, *args, &block)
           if @klass.respond_to?(method)
-            self.class.delegate_to_scoped_klass(method)
+            @klass.generate_relation_method(method)
             scoping { @klass.public_send(method, *args, &block) }
           else
             super
@@ -132,7 +124,7 @@ module ActiveRecord
 
     private
       def respond_to_missing?(method, _)
-        super || @klass.respond_to?(method) || arel.respond_to?(method)
+        super || @klass.respond_to?(method)
       end
   end
 end

data/lib/active_record/relation/finder_methods.rb

@@ -7,8 +7,8 @@ module ActiveRecord
     ONE_AS_ONE = "1 AS one"
 
     # Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
-    # If one or more records can not be found for the requested ids, then RecordNotFound will be raised. If the primary key
-    # is an integer, find by id coerces its arguments using +to_i+.
+    # If one or more records cannot be found for the requested ids, then ActiveRecord::RecordNotFound will be raised.
+    # If the primary key is an integer, find by id coerces its arguments by using +to_i+.
     #
     #   Person.find(1)          # returns the object for ID = 1
     #   Person.find("1")        # returns the object for ID = 1
@@ -307,8 +307,6 @@ module ActiveRecord
 
       return false if !conditions || limit_value == 0
 
-      conditions = sanitize_forbidden_attributes(conditions)
-
       if eager_loading?
         relation = apply_join_dependency(eager_loading: false)
         return relation.exists?(conditions)
@@ -316,7 +314,7 @@ module ActiveRecord
 
       relation = construct_relation_for_exists(conditions)
 
-      skip_query_cache_if_necessary { connection.select_value(relation.arel, "#{name} Exists") } ? true : false
+      skip_query_cache_if_necessary { connection.select_one(relation.arel, "#{name} Exists?") } ? true : false
     end
 
     # This method is called whenever no records are found with either a single
@@ -354,7 +352,13 @@ module ActiveRecord
       end
 
       def construct_relation_for_exists(conditions)
-        relation = except(:select, :distinct, :order)._select!(ONE_AS_ONE).limit!(1)
+        conditions = sanitize_forbidden_attributes(conditions)
+
+        if distinct_value && offset_value
+          relation = except(:order).limit!(1)
+        else
+          relation = except(:select, :distinct, :order)._select!(ONE_AS_ONE).limit!(1)
+        end
 
         case conditions
         when Array, Hash
@@ -366,14 +370,10 @@ module ActiveRecord
         relation
       end
 
-      def construct_join_dependency(associations)
-        ActiveRecord::Associations::JoinDependency.new(
-          klass, table, associations
-        )
-      end
-
       def apply_join_dependency(eager_loading: group_values.empty?)
-        join_dependency = construct_join_dependency(eager_load_values + includes_values)
+        join_dependency = construct_join_dependency(
+          eager_load_values + includes_values, Arel::Nodes::OuterJoin
+        )
         relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
 
         if eager_loading && !using_limitable_reflections?(join_dependency.reflections)

data/lib/active_record/relation/merger.rb

@@ -117,16 +117,16 @@ module ActiveRecord
           if other.klass == relation.klass
             relation.joins!(*other.joins_values)
           else
-            joins_dependency = other.joins_values.map do |join|
+            associations, others = other.joins_values.partition do |join|
               case join
-              when Hash, Symbol, Array
-                other.send(:construct_join_dependency, join)
-              else
-                join
+              when Hash, Symbol, Array; true
               end
             end
 
-            relation.joins!(*joins_dependency)
+            join_dependency = other.construct_join_dependency(
+              associations, Arel::Nodes::InnerJoin
+            )
+            relation.joins!(join_dependency, *others)
           end
         end
 
@@ -136,16 +136,11 @@ module ActiveRecord
           if other.klass == relation.klass
             relation.left_outer_joins!(*other.left_outer_joins_values)
           else
-            joins_dependency = other.left_outer_joins_values.map do |join|
-              case join
-              when Hash, Symbol, Array
-                other.send(:construct_join_dependency, join)
-              else
-                join
-              end
-            end
-
-            relation.left_outer_joins!(*joins_dependency)
+            associations = other.left_outer_joins_values
+            join_dependency = other.construct_join_dependency(
+              associations, Arel::Nodes::OuterJoin
+            )
+            relation.joins!(join_dependency)
           end
         end
 

data/lib/active_record/relation/query_attribute.rb

@@ -18,8 +18,10 @@ module ActiveRecord
       end
 
       def nil?
-        !value_before_type_cast.is_a?(StatementCache::Substitute) &&
-          (value_before_type_cast.nil? || value_for_database.nil?)
+        unless value_before_type_cast.is_a?(StatementCache::Substitute)
+          value_before_type_cast.nil? ||
+            type.respond_to?(:subtype, true) && value_for_database.nil?
+        end
       rescue ::RangeError
       end
 
@@ -32,7 +34,7 @@ module ActiveRecord
         if defined?(@_unboundable)
           @_unboundable
         else
-          value_for_database
+          value_for_database unless value_before_type_cast.is_a?(StatementCache::Substitute)
           @_unboundable = nil
         end
       rescue ::RangeError