activerecord-batch_touching 1.0.pre.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 829e262f5bb2081c84c1d8baea4afc937806119fbc605a0f13b5bccaecbf9616
+  data.tar.gz: ed048b0b157de0f9e6dbf6dcdfe08253c95177759e692fe718eda84f7460d0d5
+SHA512:
+  metadata.gz: 625f5ed7a40621a366cd5c110a23d7f1a4048b92d7568feec17206c6f72d3507a6d4f4a1862f472147e980f0b632420ff0afe70372c297716718ec00b6c6671f
+  data.tar.gz: 52ba63a3c2df1cb8431ab5f17703cf51021250bba311bdcd483657ae24f4ebef5a86299c0a9e84b8869a08a08821b6188e417cdb08f62f09d9d8ec482208d725

data/.gitignore

@@ -0,0 +1,4 @@
+.idea
+.ruby-version
+Gemfile.lock
+coverage

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--tty
+--format documentation
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activerecord-batch_touching.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Phil Phillips
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/activerecord-batch_touching.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'activerecord/batch_touching/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "activerecord-batch_touching"
+  spec.version       = "1.0-beta" # Activerecord::BatchTouching::VERSION
+  spec.authors       = ["Brian Morearty", "Phil Phillips"]
+  spec.email         = ["phil@productplan.com"]
+  spec.summary       = %q{Batch up your ActiveRecord "touch" operations for better performance.}
+  spec.description   = %q{Batch up your ActiveRecord "touch" operations for better performance. All accumulated "touch" calls will be consolidated into as few database round trips as possible.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency             "activerecord", ">= 6"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "timecop"
+  spec.add_development_dependency "rspec-rails"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov-rcov"
+end

data/lib/activerecord/batch_touching/state.rb

@@ -0,0 +1,54 @@
+module ActiveRecord
+  # = Active Record Batch Touching
+  module BatchTouching
+
+    # Tracking of the touch state. This class has no class-level data, so you can
+    # store per-thread instances in thread-local variables.
+    class State # :nodoc:
+      # Return the records grouped by class and columns that were touched:
+      #
+      #   {
+      #     [Owner, [:updated_at]]               => Set.new([owner1, owner2]),
+      #     [Pet,   [:neutered_at, :updated_at]] => Set.new([pet1]),
+      #     [Pet,   [:updated_at]]               => Set.new([pet2])
+      #   }
+      #
+      attr_reader :records
+
+      def initialize
+        @records = Hash.new { Set.new }
+      end
+
+      def clear_records!
+        @records = Hash.new { Set.new }
+      end
+
+      def more_records?
+        @records.present?
+      end
+
+      def add_record(record, columns)
+        # Include the standard updated_at column and any additional specified columns
+        columns += record.send(:timestamp_attributes_for_update_in_model)
+        columns = columns.map(&:to_sym).sort
+
+        key = [record.class, columns]
+        @records[key] += [record]
+      end
+
+      # Merge another state into this one
+      def merge!(other_state)
+        merge_records!(@records, other_state.records)
+      end
+
+      protected
+
+      # Merge from_records into into_records
+      def merge_records!(into_records, from_records)
+        from_records.each do |key, records|
+          into_records[key] += records
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/batch_touching/version.rb

@@ -0,0 +1,5 @@
+module Activerecord
+  module BatchTouching
+    VERSION = "1.0"
+  end
+end

data/lib/activerecord/batch_touching.rb

@@ -0,0 +1,140 @@
+require "activerecord/batch_touching/version"
+require "activerecord/batch_touching/state"
+
+module ActiveRecord
+  # = Active Record Batch Touching
+  module BatchTouching # :nodoc:
+    extend ActiveSupport::Concern
+
+    # Override ActiveRecord::Base#touch_later.  This will effectively disable the current built-in mechanism AR uses
+    # to delay touching in favor of our method of batch touching.
+    def touch_later(*names)
+      touch(*names)
+    end
+
+    # Override ActiveRecord::Base#touch.  If currently batching touches, always return
+    # true because there's no way to tell if the write would have failed.
+    def touch(*names, time: nil)
+      if BatchTouching.batch_touching? && !no_touching?
+        add_to_transaction
+        BatchTouching.add_record(self, names)
+        true
+      else
+        super
+      end
+    end
+
+    # These get added as class methods to ActiveRecord::Base.
+    module ClassMethods
+      # Batches up +touch+ calls for the duration of a transaction.
+      # +after_touch+ callbacks are also delayed until the transaction is committed.
+      #
+      # ==== Examples
+      #
+      #   # Touches Person.first and Person.last in a single database round-trip.
+      #   Person.transaction do
+      #     Person.first.touch
+      #     Person.last.touch
+      #   end
+      #
+      #   # Touches Person.first once, not twice, right before the transaction is committed.
+      #   Person.transaction do
+      #     Person.first.touch
+      #     Person.first.touch
+      #   end
+      #
+      def transaction(**options, &block)
+        super(**options) do
+          BatchTouching.start(**options, &block)
+        end
+      end
+    end
+
+    class << self
+      def states
+        Thread.current[:batch_touching_states] ||= []
+      end
+
+      def current_state
+        states.last
+      end
+
+      delegate :add_record, to: :current_state
+
+      def batch_touching?
+        states.present?
+      end
+
+      # Start batching all touches. When done, apply them. (Unless nested.)
+      def start(options = {})
+        states.push State.new
+        yield.tap do
+          apply_touches if states.length == 1
+        end
+      ensure
+        merge_transactions unless $! && options[:requires_new]
+
+        # Decrement nesting even if +apply_touches+ raised an error. To ensure the stack of States
+        # is empty after the top-level transaction exits.
+        states.pop
+      end
+
+      # When exiting a nested transaction, merge the nested transaction's
+      # touched records with the outer transaction's touched records.
+      def merge_transactions
+        states[-2].merge!(current_state) if states.length > 1
+      end
+
+      # Apply the touches that were batched. We're in a transaction already so there's no need to open one.
+      def apply_touches
+        callbacks_run = Set.new
+        all_states = State.new
+        while current_state.more_records?
+          all_states.merge!(current_state)
+          state_records = current_state.records
+          current_state.clear_records!
+          state_records.each do |_, records|
+            # Run callbacks to collect more touches (i.e. touch: true for associations)
+            records.each do |record|
+              unless callbacks_run.include?(record)
+                record._run_touch_callbacks
+                callbacks_run.add(record)
+              end
+            end
+          end
+        end
+
+        # Sort by class name. Having a consistent order can help mitigate deadlocks.
+        sorted_records = all_states.records.keys.sort_by { |k| k.first.name }.map { |k| [k, all_states.records[k]] }.to_h
+        sorted_records.each do |(klass, columns), records|
+          touch_records klass, columns, records
+        end
+      end
+
+      # Touch the specified records--non-empty set of instances of the same class.
+      def touch_records(klass, columns, records)
+        if columns.present?
+          current_time = records.first.send(:current_time_from_proper_timezone)
+
+          records.each do |record|
+            record.instance_eval do
+              columns.each { |column| write_attribute column, current_time }
+              if locking_enabled?
+                self[self.class.locking_column] += 1
+                clear_attribute_change(self.class.locking_column)
+              end
+              clear_attribute_changes(columns)
+            end
+          end
+
+          sql = columns.map { |column| "#{klass.connection.quote_column_name(column)} = :current_time" }.join(", ")
+          sql += ", #{klass.locking_column} = #{klass.locking_column} + 1" if klass.locking_enabled?
+
+          klass.unscoped.where(klass.primary_key => records.to_a).update_all([sql, current_time: current_time])
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.include ActiveRecord::BatchTouching

data/spec/active_record/batch_touching_spec.rb

@@ -0,0 +1,369 @@
+require 'spec_helper'
+
+describe Activerecord::BatchTouching do
+  let!(:owner) { Owner.create name: "Rosey" }
+  let!(:pet1) { Pet.create(name: "Bones", owner: owner) }
+  let!(:pet2) { Pet.create(name: "Ema", owner: owner) }
+  let!(:car) { Car.create(name: "Ferrari", lock_version: 1) }
+
+  it 'has a version number' do
+    expect(Activerecord::BatchTouching::VERSION).not_to be nil
+  end
+
+  it "touch returns true when not in a batch_touching block" do
+    expect(owner.touch).to equal(true)
+  end
+
+  it "touch returns true in a batch_touching block" do
+    ActiveRecord::Base.transaction do
+      expect(owner.touch).to equal(true)
+    end
+  end
+
+  it "consolidates touches on a single record when inside a transaction" do
+    expect_updates [{ "owners" => { ids: owner } }] do
+      ActiveRecord::Base.transaction do
+        owner.touch
+        owner.touch
+      end
+    end
+  end
+
+  it "calls touch callbacks just once when there are multiple touches" do
+    expect(owner).to receive(:_run_touch_callbacks).once.and_call_original
+    ActiveRecord::Base.transaction do
+      owner.touch
+      owner.touch
+    end
+  end
+
+  it 'sets updated_at on the in-memory instance when it eventually touches the record' do
+    original_time = new_time = nil
+
+    Timecop.freeze(2014, 7, 4, 12, 0, 0) do
+      original_time = Time.current
+      owner.touch
+    end
+
+    Timecop.freeze(2014, 7, 10, 12, 0, 0) do
+      new_time = Time.current
+      ActiveRecord::Base.transaction do
+        owner.touch
+        expect(owner.updated_at).to eq(original_time)
+        expect(owner.changed?).to be_falsey
+      end
+    end
+
+    expect(owner.updated_at).to eq(new_time)
+    expect(owner.changed?).to be_falsey
+  end
+
+  it "does not mark the instance as changed when touch is called" do
+    ActiveRecord::Base.transaction do
+      owner.touch
+      expect(owner).not_to be_changed
+    end
+  end
+
+  it "does not mark the instance as changed, even if its lock_version is incremented" do
+    ActiveRecord::Base.transaction do
+      car.touch
+    end
+    expect(car).not_to be_changed
+  end
+
+  it "consolidates touches for all instances in a single table" do
+    expect_updates [{ "pets" => { ids: [pet1, pet2] } }, "owners" => { ids: owner }] do
+      ActiveRecord::Base.transaction do
+        pet1.touch
+        pet2.touch
+      end
+    end
+  end
+
+  it "does nothing if no_touching is on" do
+    expect(owner).to receive(:_run_touch_callbacks).never
+    expect_updates [] do
+      ActiveRecord::Base.no_touching do
+        ActiveRecord::Base.transaction do
+          owner.touch
+        end
+      end
+    end
+  end
+
+  it "only applies touches for which no_touching is off" do
+    expect(owner).to receive(:_run_touch_callbacks).never
+    expect(pet1).to receive(:_run_touch_callbacks).once.and_call_original
+    expect_updates ["pets" => { ids: pet1 }] do
+      Owner.no_touching do
+        ActiveRecord::Base.transaction do
+          owner.touch
+          pet1.touch
+        end
+      end
+    end
+  end
+
+  it "does not apply nested touches if no_touching was turned on inside batch_touching" do
+    expect(owner).to receive(:_run_touch_callbacks).once.and_call_original
+    expect(pet1).to receive(:_run_touch_callbacks).never
+    expect_updates ["owners" => { ids: owner }] do
+      ActiveRecord::Base.transaction do
+        owner.touch
+        ActiveRecord::Base.no_touching do
+          pet1.touch
+        end
+      end
+    end
+  end
+
+  it "can update nonstandard columns" do
+    expect_updates ["owners" => { ids: owner, columns: ["updated_at", "happy_at"] }] do
+      ActiveRecord::Base.transaction do
+        owner.touch :happy_at
+      end
+    end
+  end
+
+  it "treats string column names and symbol column names as the same" do
+    expect_updates ["owners" => { ids: owner, columns: ["updated_at", "happy_at"] }] do
+      ActiveRecord::Base.transaction do
+        owner.touch :happy_at
+        owner.touch "happy_at"
+      end
+    end
+  end
+
+  it "splits up nonstandard column touches and standard column touches" do
+    owner2 = Owner.create name: "Guybrush"
+
+    expect_updates [{ "owners" => { ids: owner, columns: ["updated_at", "happy_at"] } },
+                    { "owners" => { ids: owner2, columns: ["updated_at"] } }] do
+
+      ActiveRecord::Base.transaction do
+        owner.touch :happy_at
+        owner2.touch
+      end
+    end
+  end
+
+  it "can update multiple nonstandard columns of a single record in different calls to touch" do
+    expect_updates [{ "owners" => { ids: owner, columns: ["updated_at", "happy_at"] } },
+                    { "owners" => { ids: owner, columns: ["updated_at", "sad_at"] } }] do
+
+      ActiveRecord::Base.transaction do
+        owner.touch :happy_at
+        owner.touch :sad_at
+      end
+    end
+  end
+
+  it "can update multiple nonstandard columns of a single record in a single call to touch" do
+    expect_updates [{ "owners" => { ids: owner, columns: [ "updated_at", "happy_at", "sad_at"] } }] do
+
+      ActiveRecord::Base.transaction do
+        owner.touch :happy_at, :sad_at
+      end
+    end
+  end
+
+  it "consolidates touch: true touches" do
+    expect_updates [{ "pets" => { ids: [pet1, pet2] } }, { "owners" => { ids: owner } }] do
+      ActiveRecord::Base.transaction do
+        pet1.touch
+        pet2.touch
+      end
+    end
+  end
+
+  it "does not touch the owning record via touch: true if it was already touched explicitly" do
+    expect(owner).to receive(:_run_touch_callbacks).once.and_call_original
+    expect(pet1).to receive(:_run_touch_callbacks).once.and_call_original
+    expect(pet2).to receive(:_run_touch_callbacks).once.and_call_original
+
+    expect_updates [{ "pets" => { ids: [pet1, pet2] } }, { "owners" => { ids: owner } }] do
+      ActiveRecord::Base.transaction do
+        owner.touch
+        pet1.touch
+        pet2.touch
+      end
+    end
+  end
+
+  it "does not consolidate touches when outside a transaction" do
+    expect_updates [{ "owners" => { ids: owner } },
+                    { "owners" => { ids: owner } }] do
+      owner.touch
+      owner.touch
+    end
+  end
+
+  it "nested transactions get consolidated into a single set of touches" do
+    expect(owner).to receive(:_run_touch_callbacks).once.and_call_original
+    expect(pet1).to receive(:_run_touch_callbacks).once.and_call_original
+    expect(pet2).to receive(:_run_touch_callbacks).once.and_call_original
+
+    expect_updates [{ "pets" => { ids: [pet1, pet2] } }, { "owners" => { ids: owner } }] do
+      ActiveRecord::Base.transaction do
+        pet1.touch
+        ActiveRecord::Base.transaction do
+          pet2.touch
+        end
+      end
+    end
+  end
+
+  it "rolling back from a nested transaction without :requires_new touches the records in the inner transaction" do
+    expect_updates [{ "pets" => { ids: [pet1, pet2] } }, { "owners" => { ids: owner } }] do
+      ActiveRecord::Base.transaction do
+        pet1.touch
+        ActiveRecord::Base.transaction do
+          pet2.touch
+          raise ActiveRecord::Rollback
+        end
+      end
+    end
+  end
+
+  it "rolling back from a nested transaction with :requires_new does not touch the records in the inner transaction" do
+    expect_updates [{ "pets" => { ids: pet1 } }, { "owners" => { ids: owner } }] do
+      ActiveRecord::Base.transaction do
+        pet1.touch
+        ActiveRecord::Base.transaction(requires_new: true) do
+          pet2.touch
+          raise ActiveRecord::Rollback
+        end
+      end
+    end
+  end
+
+  it "touching a record in an outer and inner new transaction, then rolling back the inner one, still touches the record" do
+    expect_updates [{ "pets" => { ids: pet1 } }, { "owners" => { ids: owner } }] do
+      ActiveRecord::Base.transaction do
+        pet1.touch
+        ActiveRecord::Base.transaction(requires_new: true) do
+          pet1.touch
+          raise ActiveRecord::Rollback
+        end
+      end
+    end
+  end
+
+  it "rolling back from an outer transaction does not touch any records" do
+    expect_updates [] do
+      ActiveRecord::Base.transaction do
+        pet1.touch
+        ActiveRecord::Base.transaction do
+          pet2.touch :neutered_at
+        end
+        raise ActiveRecord::Rollback
+      end
+    end
+  end
+
+  it "consolidates touch: :column_name touches" do
+    pet_klass = Class.new(ActiveRecord::Base) do
+      def self.name; 'Pet'; end
+      belongs_to :owner, :touch => :happy_at
+      after_touch :after_touch_callback
+      def after_touch_callback; end
+    end
+
+    pet = pet_klass.first
+    owner = pet.owner
+
+    expect_updates [{ "owners" => { ids: owner, columns: ["updated_at", "happy_at"] } }, { "pets" => { ids: pet } }] do
+      ActiveRecord::Base.transaction do
+        pet.touch
+        pet.touch
+      end
+    end
+  end
+
+  it "keeps iterating as long as after_touch keeps causing more records to be touched" do
+    pet_klass = Class.new(ActiveRecord::Base) do
+      def self.name; 'Pet'; end
+      belongs_to :owner
+
+      # Touch the owner in after_touch instead of using touch: true
+      after_touch :touch_owner
+      def touch_owner; owner.touch; end
+    end
+
+    pet = pet_klass.first
+    owner = pet.owner
+
+    expect_updates [{ "owners" => { ids: owner } }, { "pets" => { ids: pet } }] do
+      ActiveRecord::Base.transaction do
+        pet.touch
+      end
+    end
+  end
+
+  it "increments the optimistic lock column in memory and in the DB" do
+    car1 = Car.create(name: "Ferrari", lock_version: 1)
+    car2 = Car.create(name: "Lambo", lock_version: 2)
+
+    ActiveRecord::Base.transaction do
+      car1.touch
+      car2.touch
+    end
+
+    expect(car1.lock_version).to equal(2)
+    expect(car2.lock_version).to equal(3)
+
+    expect(car1.reload.lock_version).to equal(2)
+    expect(car2.reload.lock_version).to equal(3)
+  end
+
+  private
+
+  def expect_updates(tables_ids_and_columns)
+    expected_sql = expected_sql_for(tables_ids_and_columns)
+    expect(ActiveRecord::Base.connection).to receive(:update).exactly(expected_sql.length).times do |stmt, _, _|
+      if stmt.to_sql =~ /UPDATE /i
+        index = expected_sql.index { |expected_stmt| stmt.to_sql =~ expected_stmt }
+        expect(index).to be, "An unexpected touch occurred: #{stmt.to_sql}"
+        expected_sql.delete_at(index)
+      end
+    end
+
+    yield
+
+    expect(expected_sql).to be_empty, "Some of the expected updates were not executed."
+  end
+
+  # Creates an array of regular expressions to match the SQL statements that we expect
+  # to execute.
+  #
+  # Each element in the tables_ids_and_columns array is in this form:
+  #
+  #   { "table_name" => { ids: id_or_array_of_ids, columns: column_name_or_array } }
+  #
+  # 'columns' is optional. If it's missing it is assumed that "updated_at" is the only
+  # column that gets touched.
+  def expected_sql_for(tables_ids_and_columns)
+    tables_ids_and_columns.map do |entry|
+      entry.map do |table, options|
+        ids = Array.wrap(options[:ids])
+        columns = Array.wrap(options[:columns]).presence || ["updated_at"]
+        columns = columns.sort
+        Regexp.new(touch_sql(table, columns, ids))
+      end
+    end.flatten
+  end
+
+  # in:  array of records or record ids
+  # out: "( = 1|= \?|= \$1)" or " IN (1, 2)"
+  #
+  # In some cases, such as SQLite3 when outside a transaction, the logged SQL uses ? instead of record ids.
+  def ids_sql(ids)
+    ids = ids.map { |id| id.class.respond_to?(:primary_key) ? id.send(id.class.primary_key) : id }
+    ids.length > 1 ? %{ IN \\(#{Array.new(ids.length, '\?').join(", ")}\\)} : %{( = #{ids.first}|= \\?|= \\$1)}
+  end
+
+  def touch_sql(table, columns, ids)
+    %{UPDATE \\"#{table}"\\ SET #{columns.map { |column| %{\\"#{column}\\" =.+} }.join(", ") } .+#{ids_sql(ids)}\\Z}
+  end
+end

data/spec/rcov_exclude_list.rb

@@ -0,0 +1,3 @@
+@exclude_list = [
+  'spec/**/*.rb'
+]

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+if ENV["COVERAGE"]
+  require_relative 'rcov_exclude_list.rb'
+  exlist = Dir.glob(@exclude_list)
+  require 'simplecov'
+  require 'simplecov-rcov'
+  SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+  SimpleCov.start do
+    exlist.each do |p|
+      add_filter p
+    end
+  end
+end
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'active_record'
+require 'activerecord/batch_touching'
+require 'timecop'
+
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+
+load File.dirname(__FILE__) + '/support/schema.rb'
+require File.dirname(__FILE__) + '/support/models.rb'

data/spec/support/models.rb

@@ -0,0 +1,9 @@
+class Owner < ActiveRecord::Base
+  has_many :pets, inverse_of: :owner
+end
+
+class Pet < ActiveRecord::Base
+  belongs_to :owner, touch: true, inverse_of: :pets
+end
+
+class Car < ActiveRecord::Base; end

data/spec/support/schema.rb

@@ -0,0 +1,27 @@
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :owners, :force => true do |t|
+    t.string :name
+
+    t.timestamps
+    t.datetime :happy_at
+    t.datetime :sad_at
+  end
+
+  create_table :pets, :force => true do |t|
+    t.string :name
+    t.integer :owner_id
+    t.datetime :neutered_at
+
+    t.timestamps
+  end
+
+  create_table :cars, force: true do |t|
+    t.string :name
+    t.column :lock_version, :integer, null: false, default: 0
+
+    t.timestamps
+  end
+
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-batch_touching
+version: !ruby/object:Gem::Version
+  version: 1.0.pre.beta
+platform: ruby
+authors:
+- Brian Morearty
+- Phil Phillips
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-07-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-rcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Batch up your ActiveRecord "touch" operations for better performance.
+  All accumulated "touch" calls will be consolidated into as few database round trips
+  as possible.
+email:
+- phil@productplan.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE
+- activerecord-batch_touching.gemspec
+- lib/activerecord/batch_touching.rb
+- lib/activerecord/batch_touching/state.rb
+- lib/activerecord/batch_touching/version.rb
+- spec/active_record/batch_touching_spec.rb
+- spec/rcov_exclude_list.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/support/schema.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Batch up your ActiveRecord "touch" operations for better performance.
+test_files:
+- spec/active_record/batch_touching_spec.rb
+- spec/rcov_exclude_list.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/support/schema.rb