activerecord 5.2.0 → 5.2.1

data/lib/active_record/connection_adapters/sqlite3/quoting.rb

@@ -17,6 +17,7 @@ module ActiveRecord
         end
 
         def quoted_time(value)
+          value = value.change(year: 2000, month: 1, day: 1)
           quoted_date(value).sub(/\A\d\d\d\d-\d\d-\d\d /, "2000-01-01 ")
         end
 

data/lib/active_record/connection_adapters/sqlite3/schema_statements.rb

@@ -7,6 +7,10 @@ module ActiveRecord
         # Returns an array of indexes for the given table.
         def indexes(table_name)
           exec_query("PRAGMA index_list(#{quote_table_name(table_name)})", "SCHEMA").map do |row|
+            # Indexes SQLite creates implicitly for internal use start with "sqlite_".
+            # See https://www.sqlite.org/fileformat2.html#intschema
+            next if row["name"].starts_with?("sqlite_")
+
             index_sql = query_value(<<-SQL, "SCHEMA")
               SELECT sql
               FROM sqlite_master
@@ -40,7 +44,7 @@ module ActiveRecord
               where: where,
               orders: orders
             )
-          end
+          end.compact
         end
 
         def create_schema_dumper(options)

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -453,9 +453,6 @@ module ActiveRecord
         def copy_table_indexes(from, to, rename = {})
           indexes(from).each do |index|
             name = index.name
-            # indexes sqlite creates for internal use start with `sqlite_` and
-            # don't need to be copied
-            next if name.starts_with?("sqlite_")
             if to == "a#{from}"
               name = "t#{name}"
             elsif from == "a#{to}"

data/lib/active_record/counter_cache.rb

@@ -47,8 +47,12 @@ module ActiveRecord
           reflection   = child_class._reflections.values.find { |e| e.belongs_to? && e.foreign_key.to_s == foreign_key && e.options[:counter_cache].present? }
           counter_name = reflection.counter_cache_column
 
-          updates = { counter_name.to_sym => object.send(counter_association).count(:all) }
-          updates.merge!(touch_updates(touch)) if touch
+          updates = { counter_name => object.send(counter_association).count(:all) }
+
+          if touch
+            names = touch if touch != true
+            updates.merge!(touch_attributes_with_time(*names))
+          end
 
           unscoped.where(primary_key => object.id).update_all(updates)
         end
@@ -68,8 +72,8 @@ module ActiveRecord
       # * +counters+ - A Hash containing the names of the fields
       #   to update as keys and the amount to update the field by as values.
       # * <tt>:touch</tt> option - Touch timestamp columns when updating.
-      #   Pass +true+ to touch +updated_at+ and/or +updated_on+. Pass a symbol to
-      #   touch that column or an array of symbols to touch just those ones.
+      #   If attribute names are passed, they are updated along with updated_at/on
+      #   attributes.
       #
       # ==== Examples
       #
@@ -107,11 +111,18 @@ module ActiveRecord
         end
 
         if touch
-          touch_updates = touch_updates(touch)
+          names = touch if touch != true
+          touch_updates = touch_attributes_with_time(*names)
           updates << sanitize_sql_for_assignment(touch_updates) unless touch_updates.empty?
         end
 
-        unscoped.where(primary_key => id).update_all updates.join(", ")
+        if id.is_a?(Relation) && self == id.klass
+          relation = id
+        else
+          relation = unscoped.where!(primary_key => id)
+        end
+
+        relation.update_all updates.join(", ")
       end
 
       # Increment a numeric field by one, via a direct SQL update.
@@ -165,13 +176,6 @@ module ActiveRecord
       def decrement_counter(counter_name, id, touch: nil)
         update_counters(id, counter_name => -1, touch: touch)
       end
-
-      private
-        def touch_updates(touch)
-          touch = timestamp_attributes_for_update_in_model if touch == true
-          touch_time = current_time_from_proper_timezone
-          Array(touch).map { |column| [ column, touch_time ] }.to_h
-        end
     end
 
     private

data/lib/active_record/gem_version.rb

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

data/lib/active_record/log_subscriber.rb

@@ -125,7 +125,7 @@ module ActiveRecord
         ]
       end
 
-      RAILS_GEM_ROOT = File.expand_path("../../../..", __FILE__) + "/"
+      RAILS_GEM_ROOT = File.expand_path("../../..", __dir__) + "/"
 
       def ignored_callstack(path)
         path.start_with?(RAILS_GEM_ROOT) ||

data/lib/active_record/persistence.rb

@@ -373,7 +373,7 @@ module ActiveRecord
       became = klass.allocate
       became.send(:initialize)
       became.instance_variable_set("@attributes", @attributes)
-      became.instance_variable_set("@mutations_from_database", @mutations_from_database) if defined?(@mutations_from_database)
+      became.instance_variable_set("@mutations_from_database", @mutations_from_database ||= nil)
       became.instance_variable_set("@changed_attributes", attributes_changed_by_setter)
       became.instance_variable_set("@new_record", new_record?)
       became.instance_variable_set("@destroyed", destroyed?)

data/lib/active_record/query_cache.rb

@@ -26,19 +26,12 @@ module ActiveRecord
     end
 
     def self.run
-      ActiveRecord::Base.connection_handler.connection_pool_list.map do |pool|
-        caching_was_enabled = pool.query_cache_enabled
-
-        pool.enable_query_cache!
-
-        [pool, caching_was_enabled]
-      end
+      ActiveRecord::Base.connection_handler.connection_pool_list.
+        reject { |p| p.query_cache_enabled }.each { |p| p.enable_query_cache! }
     end
 
-    def self.complete(caching_pools)
-      caching_pools.each do |pool, caching_was_enabled|
-        pool.disable_query_cache! unless caching_was_enabled
-      end
+    def self.complete(pools)
+      pools.each { |pool| pool.disable_query_cache! }
 
       ActiveRecord::Base.connection_handler.connection_pool_list.each do |pool|
         pool.release_connection if pool.active_connection? && !pool.connection.transaction_open?

data/lib/active_record/relation.rb

@@ -277,10 +277,10 @@ module ActiveRecord
     # Please check unscoped if you want to remove all previous scopes (including
     # the default_scope) during the execution of a block.
     def scoping
-      previous, klass.current_scope = klass.current_scope(true), self
+      previous, klass.current_scope = klass.current_scope(true), self unless @delegate_to_klass
       yield
     ensure
-      klass.current_scope = previous
+      klass.current_scope = previous unless @delegate_to_klass
     end
 
     def _exec_scope(*args, &block) # :nodoc:
@@ -436,17 +436,16 @@ module ActiveRecord
     #   # => SELECT "users".* FROM "users"  WHERE "users"."name" = 'Oscar'
     def to_sql
       @to_sql ||= begin
-                    relation = self
-
-                    if eager_loading?
-                      apply_join_dependency { |rel, _| relation = rel }
-                    end
-
-                    conn = klass.connection
-                    conn.unprepared_statement {
-                      conn.to_sql(relation.arel)
-                    }
-                  end
+        if eager_loading?
+          apply_join_dependency do |relation, join_dependency|
+            relation = join_dependency.apply_column_aliases(relation)
+            relation.to_sql
+          end
+        else
+          conn = klass.connection
+          conn.unprepared_statement { conn.to_sql(arel) }
+        end
+      end
     end
 
     # Returns a hash of where conditions.
@@ -546,6 +545,7 @@ module ActiveRecord
                 if ActiveRecord::NullRelation === relation
                   []
                 else
+                  relation = join_dependency.apply_column_aliases(relation)
                   rows = connection.select_all(relation.arel, "SQL")
                   join_dependency.instantiate(rows, &block)
                 end.freeze

data/lib/active_record/relation/finder_methods.rb

@@ -373,13 +373,12 @@ module ActiveRecord
 
       def construct_join_dependency
         including = eager_load_values + includes_values
-        joins = joins_values.select { |join| join.is_a?(Arel::Nodes::Join) }
         ActiveRecord::Associations::JoinDependency.new(
-          klass, table, including, alias_tracker(joins)
+          klass, table, including
         )
       end
 
-      def apply_join_dependency(eager_loading: true)
+      def apply_join_dependency(eager_loading: group_values.empty?)
         join_dependency = construct_join_dependency
         relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
 
@@ -392,7 +391,6 @@ module ActiveRecord
         end
 
         if block_given?
-          relation._select!(join_dependency.aliases.columns)
           yield relation, join_dependency
         else
           relation

data/lib/active_record/relation/merger.rb

@@ -117,13 +117,11 @@ module ActiveRecord
           if other.klass == relation.klass
             relation.joins!(*other.joins_values)
           else
-            alias_tracker = nil
             joins_dependency = other.joins_values.map do |join|
               case join
               when Hash, Symbol, Array
-                alias_tracker ||= other.alias_tracker
                 ActiveRecord::Associations::JoinDependency.new(
-                  other.klass, other.table, join, alias_tracker
+                  other.klass, other.table, join
                 )
               else
                 join
@@ -140,13 +138,11 @@ module ActiveRecord
           if other.klass == relation.klass
             relation.left_outer_joins!(*other.left_outer_joins_values)
           else
-            alias_tracker = nil
             joins_dependency = other.left_outer_joins_values.map do |join|
               case join
               when Hash, Symbol, Array
-                alias_tracker ||= other.alias_tracker
                 ActiveRecord::Associations::JoinDependency.new(
-                  other.klass, other.table, join, alias_tracker
+                  other.klass, other.table, join
                 )
               else
                 join

data/lib/active_record/relation/predicate_builder.rb

@@ -48,7 +48,12 @@ module ActiveRecord
     end
 
     def build(attribute, value)
-      handler_for(value).call(attribute, value)
+      if table.type(attribute.name).force_equality?(value)
+        bind = build_bind_attribute(attribute.name, value)
+        attribute.eq(bind)
+      else
+        handler_for(value).call(attribute, value)
+      end
     end
 
     def build_bind_attribute(column_name, value)
@@ -98,10 +103,6 @@ module ActiveRecord
               end.reduce(&:and)
             end
             queries.reduce(&:or)
-          # FIXME: Deprecate this and provide a public API to force equality
-          elsif (value.is_a?(Range) || value.is_a?(Array)) &&
-            table.type(key.to_s).respond_to?(:subtype)
-            BasicObjectHandler.new(self).call(table.arel_attribute(key), value)
           else
             build(table.arel_attribute(key), value)
           end

data/lib/active_record/relation/query_methods.rb

@@ -893,8 +893,8 @@ module ActiveRecord
       self
     end
 
-    def skip_query_cache! # :nodoc:
-      self.skip_query_cache_value = true
+    def skip_query_cache!(value = true) # :nodoc:
+      self.skip_query_cache_value = value
       self
     end
 
@@ -903,11 +903,12 @@ module ActiveRecord
       @arel ||= build_arel(aliases)
     end
 
+    # Returns a relation value with a given name
+    def get_value(name) # :nodoc:
+      @values.fetch(name, DEFAULT_VALUES[name])
+    end
+
     protected
-      # Returns a relation value with a given name
-      def get_value(name) # :nodoc:
-        @values.fetch(name, DEFAULT_VALUES[name])
-      end
 
       # Sets the relation value with the given name
       def set_value(name, value) # :nodoc:
@@ -1011,19 +1012,19 @@ module ActiveRecord
       def build_join_query(manager, buckets, join_type, aliases)
         buckets.default = []
 
-        association_joins         = buckets[:association_join]
-        stashed_association_joins = buckets[:stashed_join]
-        join_nodes                = buckets[:join_node].uniq
-        string_joins              = buckets[:string_join].map(&:strip).uniq
+        association_joins = buckets[:association_join]
+        stashed_joins     = buckets[:stashed_join]
+        join_nodes        = buckets[:join_node].uniq
+        string_joins      = buckets[:string_join].map(&:strip).uniq
 
         join_list = join_nodes + convert_join_strings_to_ast(string_joins)
         alias_tracker = alias_tracker(join_list, aliases)
 
         join_dependency = ActiveRecord::Associations::JoinDependency.new(
-          klass, table, association_joins, alias_tracker
+          klass, table, association_joins
         )
 
-        joins = join_dependency.join_constraints(stashed_association_joins, join_type)
+        joins = join_dependency.join_constraints(stashed_joins, join_type, alias_tracker)
         joins.each { |join| manager.from(join) }
 
         manager.join_sources.concat(join_list)
@@ -1049,11 +1050,13 @@ module ActiveRecord
       end
 
       def arel_columns(columns)
-        columns.map do |field|
+        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
+            field.call
           else
             field
           end

data/lib/active_record/timestamp.rb

@@ -52,7 +52,14 @@ module ActiveRecord
       clear_timestamp_attributes
     end
 
-    class_methods do
+    module ClassMethods # :nodoc:
+      def touch_attributes_with_time(*names, time: nil)
+        attribute_names = timestamp_attributes_for_update_in_model
+        attribute_names |= names.map(&:to_s)
+        time ||= current_time_from_proper_timezone
+        attribute_names.each_with_object({}) { |attr_name, result| result[attr_name] = time }
+      end
+
       private
         def timestamp_attributes_for_create_in_model
           timestamp_attributes_for_create.select { |c| column_names.include?(c) }

data/lib/active_record/transactions.rb

@@ -340,11 +340,13 @@ 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:
-      if should_run_callbacks && destroyed? || persisted?
+      if should_run_callbacks && (destroyed? || persisted?)
+        @_committed_already_called = true
         _run_commit_without_transaction_enrollment_callbacks
         _run_commit_callbacks
       end
     ensure
+      @_committed_already_called = false
       force_clear_transaction_record_state
     end
 
@@ -382,13 +384,7 @@ module ActiveRecord
       status = nil
       self.class.transaction do
         add_to_transaction
-        begin
-          status = yield
-        rescue ActiveRecord::Rollback
-          clear_transaction_record_state
-          status = nil
-        end
-
+        status = yield
         raise ActiveRecord::Rollback unless status
       end
       status
@@ -398,17 +394,29 @@ module ActiveRecord
       end
     end
 
+    protected
+      attr_reader :_committed_already_called, :_trigger_update_callback, :_trigger_destroy_callback
+
     private
 
       # Save the new record state and id of a record so it can be restored later if a transaction fails.
       def remember_transaction_record_state
-        @_start_transaction_state[:id] = id
         @_start_transaction_state.reverse_merge!(
+          id: id,
           new_record: @new_record,
           destroyed: @destroyed,
           frozen?: frozen?,
         )
         @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) + 1
+        remember_new_record_before_last_commit
+      end
+
+      def remember_new_record_before_last_commit
+        if _committed_already_called
+          @_new_record_before_last_commit = false
+        else
+          @_new_record_before_last_commit = @_start_transaction_state[:new_record]
+        end
       end
 
       # Clear the new record state and id of a record.
@@ -440,22 +448,16 @@ module ActiveRecord
         end
       end
 
-      # Determine if a record was created or destroyed in a transaction. State should be one of :new_record or :destroyed.
-      def transaction_record_state(state)
-        @_start_transaction_state[state]
-      end
-
       # Determine if a transaction included an action for :create, :update, or :destroy. Used in filtering callbacks.
       def transaction_include_any_action?(actions)
         actions.any? do |action|
           case action
           when :create
-            transaction_record_state(:new_record)
-          when :destroy
-            defined?(@_trigger_destroy_callback) && @_trigger_destroy_callback
+            persisted? && @_new_record_before_last_commit
           when :update
-            !(transaction_record_state(:new_record) || destroyed?) &&
-              (defined?(@_trigger_update_callback) && @_trigger_update_callback)
+            !(@_new_record_before_last_commit || destroyed?) && _trigger_update_callback
+          when :destroy
+            _trigger_destroy_callback
           end
         end
       end
@@ -491,7 +493,8 @@ module ActiveRecord
 
       def update_attributes_from_transaction_state(transaction_state)
         if transaction_state && transaction_state.finalized?
-          restore_transaction_record_state if transaction_state.rolledback?
+          restore_transaction_record_state(transaction_state.fully_rolledback?) if transaction_state.rolledback?
+          force_clear_transaction_record_state if transaction_state.fully_committed?
           clear_transaction_record_state if transaction_state.fully_completed?
         end
       end