activerecord 5.2.2.1 → 5.2.5

data/lib/active_record/gem_version.rb

@@ -9,8 +9,8 @@ module ActiveRecord
   module VERSION
     MAJOR = 5
     MINOR = 2
-    TINY  = 2
-    PRE   = "1"
+    TINY  = 5
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/migration/compatibility.rb

@@ -17,20 +17,18 @@ module ActiveRecord
 
       class V5_1 < V5_2
         def change_column(table_name, column_name, type, options = {})
-          if adapter_name == "PostgreSQL"
-            clear_cache!
-            sql = connection.send(:change_column_sql, table_name, column_name, type, options)
-            execute "ALTER TABLE #{quote_table_name(table_name)} #{sql}"
-            change_column_default(table_name, column_name, options[:default]) if options.key?(:default)
-            change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
-            change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
+          if connection.adapter_name == "PostgreSQL"
+            super(table_name, column_name, type, options.except(:default, :null, :comment))
+            connection.change_column_default(table_name, column_name, options[:default]) if options.key?(:default)
+            connection.change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
+            connection.change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
           else
             super
           end
         end
 
         def create_table(table_name, options = {})
-          if adapter_name == "Mysql2"
+          if connection.adapter_name == "Mysql2"
             super(table_name, options: "ENGINE=InnoDB", **options)
           else
             super
@@ -52,13 +50,13 @@ module ActiveRecord
         end
 
         def create_table(table_name, options = {})
-          if adapter_name == "PostgreSQL"
+          if connection.adapter_name == "PostgreSQL"
             if options[:id] == :uuid && !options.key?(:default)
               options[:default] = "uuid_generate_v4()"
             end
           end
 
-          unless adapter_name == "Mysql2" && options[:id] == :bigint
+          unless connection.adapter_name == "Mysql2" && options[:id] == :bigint
             if [:integer, :bigint].include?(options[:id]) && !options.key?(:default)
               options[:default] = nil
             end
@@ -175,7 +173,7 @@ module ActiveRecord
             if options[:name].present?
               options[:name].to_s
             else
-              index_name(table_name, column: column_names)
+              connection.index_name(table_name, column: column_names)
             end
           super
         end
@@ -195,15 +193,17 @@ module ActiveRecord
           end
 
           def index_name_for_remove(table_name, options = {})
-            index_name = index_name(table_name, options)
+            index_name = connection.index_name(table_name, options)
 
-            unless index_name_exists?(table_name, index_name)
+            unless connection.index_name_exists?(table_name, index_name)
               if options.is_a?(Hash) && options.has_key?(:name)
                 options_without_column = options.dup
                 options_without_column.delete :column
-                index_name_without_column = index_name(table_name, options_without_column)
+                index_name_without_column = connection.index_name(table_name, options_without_column)
 
-                return index_name_without_column if index_name_exists?(table_name, index_name_without_column)
+                if connection.index_name_exists?(table_name, index_name_without_column)
+                  return index_name_without_column
+                end
               end
 
               raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"

data/lib/active_record/persistence.rb

@@ -97,11 +97,13 @@ module ActiveRecord
       # When running callbacks is not needed for each record update,
       # it is preferred to use {update_all}[rdoc-ref:Relation#update_all]
       # for updating all records in a single query.
-      def update(id, attributes)
+      def update(id = :all, attributes)
         if id.is_a?(Array)
           id.map { |one_id| find(one_id) }.each_with_index { |object, idx|
             object.update(attributes[idx])
           }
+        elsif id == :all
+          all.each { |record| record.update(attributes) }
         else
           if ActiveRecord::Base === id
             raise ArgumentError,

data/lib/active_record/querying.rb

@@ -40,8 +40,7 @@ module ActiveRecord
     def find_by_sql(sql, binds = [], preparable: nil, &block)
       result_set = connection.select_all(sanitize_sql(sql), "#{name} Load", binds, preparable: preparable)
       column_types = result_set.column_types.dup
-      cached_columns_hash = connection.schema_cache.columns_hash(table_name)
-      cached_columns_hash.each_key { |k| column_types.delete k }
+      attribute_types.each_key { |k| column_types.delete k }
       message_bus = ActiveSupport::Notifications.instrumenter
 
       payload = {

data/lib/active_record/reflection.rb

@@ -174,28 +174,24 @@ module ActiveRecord
         scope ? [scope] : []
       end
 
-      def build_join_constraint(table, foreign_table)
-        key         = join_keys.key
-        foreign_key = join_keys.foreign_key
-
-        constraint = table[key].eq(foreign_table[foreign_key])
-
-        if klass.finder_needs_type_condition?
-          table.create_and([constraint, klass.send(:type_condition, table)])
-        else
-          constraint
-        end
-      end
-
-      def join_scope(table, foreign_klass)
+      def join_scope(table, foreign_table, foreign_klass)
         predicate_builder = predicate_builder(table)
         scope_chain_items = join_scopes(table, predicate_builder)
         klass_scope       = klass_join_scope(table, predicate_builder)
 
+        key         = join_keys.key
+        foreign_key = join_keys.foreign_key
+
+        klass_scope.where!(table[key].eq(foreign_table[foreign_key]))
+
         if type
           klass_scope.where!(type => foreign_klass.polymorphic_name)
         end
 
+        if klass.finder_needs_type_condition?
+          klass_scope.where!(klass.send(:type_condition, table))
+        end
+
         scope_chain_items.inject(klass_scope, &:merge!)
       end
 

data/lib/active_record/relation/calculations.rb

@@ -133,11 +133,12 @@ module ActiveRecord
         relation = apply_join_dependency
 
         if operation.to_s.downcase == "count"
-          relation.distinct!
-          # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
-          if (column_name == :all || column_name.nil?) && select_values.empty?
-            relation.order_values = []
+          unless distinct_value || distinct_select?(column_name || select_for_count)
+            relation.distinct!
+            relation.select_values = [ klass.primary_key || table[Arel.star] ]
           end
+          # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
+          relation.order_values = []
         end
 
         relation.calculate(operation, column_name)
@@ -190,11 +191,9 @@ module ActiveRecord
         relation = apply_join_dependency
         relation.pluck(*column_names)
       else
-        enforce_raw_sql_whitelist(column_names)
+        klass.enforce_raw_sql_whitelist(column_names)
         relation = spawn
-        relation.select_values = column_names.map { |cn|
-          @klass.has_attribute?(cn) || @klass.attribute_alias?(cn) ? arel_attribute(cn) : cn
-        }
+        relation.select_values = column_names
         result = skip_query_cache_if_necessary { klass.connection.select_all(relation.arel, nil) }
         result.cast_values(klass.attribute_types)
       end
@@ -209,7 +208,6 @@ module ActiveRecord
     end
 
     private
-
       def has_include?(column_name)
         eager_loading? || (includes_values.present? && column_name && column_name != :all)
       end
@@ -224,10 +222,12 @@ module ActiveRecord
         if operation == "count"
           column_name ||= select_for_count
           if column_name == :all
-            if distinct && (group_values.any? || select_values.empty? && order_values.empty?)
+            if !distinct
+              distinct = distinct_select?(select_for_count) if group_values.empty?
+            elsif group_values.any? || select_values.empty? && order_values.empty?
               column_name = primary_key
             end
-          elsif column_name =~ /\s*DISTINCT[\s(]+/i
+          elsif distinct_select?(column_name)
             distinct = nil
           end
         end
@@ -239,6 +239,10 @@ module ActiveRecord
         end
       end
 
+      def distinct_select?(column_name)
+        column_name.is_a?(::String) && /\bDISTINCT[\s(]/i.match?(column_name)
+      end
+
       def aggregate_column(column_name)
         return column_name if Arel::Expressions === column_name
 
@@ -383,7 +387,7 @@ module ActiveRecord
         case operation
         when "count"   then value.to_i
         when "sum"     then type.deserialize(value || 0)
-        when "average" then value.respond_to?(:to_d) ? value.to_d : value
+        when "average" then value && value.respond_to?(:to_d) ? value.to_d : value
         else type.deserialize(value)
         end
       end

data/lib/active_record/relation/finder_methods.rb

@@ -319,7 +319,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
     rescue ::RangeError
       false
     end
@@ -359,7 +359,11 @@ module ActiveRecord
       end
 
       def construct_relation_for_exists(conditions)
-        relation = except(:select, :distinct, :order)._select!(ONE_AS_ONE).limit!(1)
+        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

data/lib/active_record/relation/merger.rb

@@ -175,9 +175,7 @@ module ActiveRecord
         end
 
         def merge_clauses
-          if relation.from_clause.empty? && !other.from_clause.empty?
-            relation.from_clause = other.from_clause
-          end
+          relation.from_clause = other.from_clause if replace_from_clause?
 
           where_clause = relation.where_clause.merge(other.where_clause)
           relation.where_clause = where_clause unless where_clause.empty?
@@ -185,6 +183,11 @@ module ActiveRecord
           having_clause = relation.having_clause.merge(other.having_clause)
           relation.having_clause = having_clause unless having_clause.empty?
         end
+
+        def replace_from_clause?
+          relation.from_clause.empty? && !other.from_clause.empty? &&
+            relation.klass.base_class == other.klass.base_class
+        end
     end
   end
 end

data/lib/active_record/relation/predicate_builder.rb

@@ -93,16 +93,21 @@ module ActiveRecord
             queries.reduce(&:or)
           elsif table.aggregated_with?(key)
             mapping = table.reflect_on_aggregation(key).mapping
-            queries = Array.wrap(value).map do |object|
-              mapping.map do |field_attr, aggregate_attr|
-                if mapping.size == 1 && !object.respond_to?(aggregate_attr)
-                  build(table.arel_attribute(field_attr), object)
-                else
-                  build(table.arel_attribute(field_attr), object.send(aggregate_attr))
-                end
-              end.reduce(&:and)
+            values = value.nil? ? [nil] : Array.wrap(value)
+            if mapping.length == 1 || values.empty?
+              column_name, aggr_attr = mapping.first
+              values = values.map do |object|
+                object.respond_to?(aggr_attr) ? object.public_send(aggr_attr) : object
+              end
+              build(table.arel_attribute(column_name), values)
+            else
+              queries = values.map do |object|
+                mapping.map do |field_attr, aggregate_attr|
+                  build(table.arel_attribute(field_attr), object.try!(aggregate_attr))
+                end.reduce(&:and)
+              end
+              queries.reduce(&:or)
             end
-            queries.reduce(&:or)
           else
             build(table.arel_attribute(key), value)
           end

data/lib/active_record/relation/query_attribute.rb

@@ -18,13 +18,15 @@ 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
       end
 
       def boundable?
         return @_boundable if defined?(@_boundable)
-        nil?
+        value_for_database unless value_before_type_cast.is_a?(StatementCache::Substitute)
         @_boundable = true
       rescue ::RangeError
         @_boundable = false

data/lib/active_record/relation/query_methods.rb

@@ -232,9 +232,6 @@ module ActiveRecord
 
     def _select!(*fields) # :nodoc:
       fields.flatten!
-      fields.map! do |field|
-        klass.attribute_alias?(field) ? klass.attribute_alias(field).to_sym : field
-      end
       self.select_values += fields
       self
     end
@@ -1051,11 +1048,14 @@ module ActiveRecord
 
       def arel_columns(columns)
         columns.flat_map do |field|
-          if (Symbol === field || String === field) && (klass.has_attribute?(field) || klass.attribute_alias?(field)) && !from_clause.value
-            arel_attribute(field)
-          elsif Symbol === field
-            connection.quote_table_name(field.to_s)
-          elsif Proc === field
+          case field
+          when Symbol
+            arel_column(field.to_s) do |attr_name|
+              connection.quote_table_name(attr_name)
+            end
+          when String
+            arel_column(field, &:itself)
+          when Proc
             field.call
           else
             field
@@ -1063,6 +1063,21 @@ module ActiveRecord
         end
       end
 
+      def arel_column(field)
+        field = klass.attribute_alias(field) if klass.attribute_alias?(field)
+        from = from_clause.name || from_clause.value
+
+        if klass.columns_hash.key?(field) && (!from || table_name_matches?(from))
+          arel_attribute(field)
+        else
+          yield field
+        end
+      end
+
+      def table_name_matches?(from)
+        /(?:\A|(?<!FROM)\s)(?:\b#{table.name}\b|#{connection.quote_table_name(table.name)})(?!\.)/i.match?(from.to_s)
+      end
+
       def reverse_sql_order(order_query)
         if order_query.empty?
           return [arel_attribute(primary_key).desc] if primary_key
@@ -1144,14 +1159,14 @@ module ActiveRecord
         order_args.map! do |arg|
           case arg
           when Symbol
-            arel_attribute(arg).asc
+            order_column(arg.to_s).asc
           when Hash
             arg.map { |field, dir|
               case field
               when Arel::Nodes::SqlLiteral
                 field.send(dir.downcase)
               else
-                arel_attribute(field).send(dir.downcase)
+                order_column(field.to_s).send(dir.downcase)
               end
             }
           else
@@ -1160,6 +1175,16 @@ module ActiveRecord
         end.flatten!
       end
 
+      def order_column(field)
+        arel_column(field) do |attr_name|
+          if attr_name == "count" && !group_values.empty?
+            arel_attribute(attr_name)
+          else
+            Arel.sql(connection.quote_table_name(attr_name))
+          end
+        end
+      end
+
       # Checks to make sure that the arguments are not blank. Note that if some
       # blank-like object were initially passed into the query method, then this
       # method will not raise an error.

data/lib/active_record/scoping/default.rb

@@ -86,8 +86,8 @@ module ActiveRecord
           #       # Should return a scope, you can call 'super' here etc.
           #     end
           #   end
-          def default_scope(scope = nil) # :doc:
-            scope = Proc.new if block_given?
+          def default_scope(scope = nil, &block) # :doc:
+            scope = block if block_given?
 
             if scope.is_a?(Relation) || !scope.respond_to?(:call)
               raise ArgumentError,

data/lib/active_record/statement_cache.rb

@@ -87,8 +87,8 @@ module ActiveRecord
       end
     end
 
-    def self.create(connection, block = Proc.new)
-      relation = block.call Params.new
+    def self.create(connection, callable = nil, &block)
+      relation = (callable || block).call Params.new
       query_builder, binds = connection.cacheable_query(self, relation.arel)
       bind_map = BindMap.new(binds)
       new(query_builder, bind_map, relation.klass)

data/lib/active_record/transactions.rb

@@ -340,6 +340,7 @@ module ActiveRecord
     # Ensure that it is not called if the object was never persisted (failed create),
     # but call it after the commit of a destroyed object.
     def committed!(should_run_callbacks: true) #:nodoc:
+      force_clear_transaction_record_state
       if should_run_callbacks && (destroyed? || persisted?)
         @_committed_already_called = true
         _run_commit_without_transaction_enrollment_callbacks
@@ -347,7 +348,6 @@ module ActiveRecord
       end
     ensure
       @_committed_already_called = false
-      force_clear_transaction_record_state
     end
 
     # Call the #after_rollback callbacks. The +force_restore_state+ argument indicates if the record