activerecord-updateinbulk 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bac8ddb8a7317ff277d0afbf77432ed979aa3246ec4030fd62f64ef64c98127
-  data.tar.gz: f09a62eda8673ad252d49038a8f1c3605e435b04121069b531f8d56fef48a919
+  metadata.gz: 1a844813b98d092d304542eb4f8c3ffc6b99a50f7510d430bef229e47c969415
+  data.tar.gz: e83aa71485ad9255b977b96afe9a8ec55820eda485d489d16e30629c1a79a971
 SHA512:
-  metadata.gz: 3f8e68e4bcc3704ffa56960fb9f12c4e49156c027f156eea4b356e710916e839a99e398e8aaddad9d7cb5e93b28a32bfd380e0f9372967c08bf76377fd7fcf9d
-  data.tar.gz: b6ec0dbcb9a18e1182aab529ca685a2edf441d030a28c8bc0951a79b8dcfe4f5b4c4822724d9e3fc01de7eeda387e5c0c25636ff9ca6c4d0504fe341165a1d26
+  metadata.gz: 45d04870ea3981cc5bb3533572f8fd412cc442bfbde77163d2d78bb47af3e3234658db990afdea09fc754f6d492ed400bc50f7f23508f01a82614f1803fae05e
+  data.tar.gz: 33dfb33a7963b357eb8da64afc3353e671fa33cab926e8bf3b9380ccecd47dbae1360f776159e35dc02a44c0c8f98721d7ed58306eebc456bf89673b0fc14900

data/README.md

@@ -59,11 +59,26 @@ Order.joins(:items).where(items: { status: :shipped }).update_in_bulk({
 })
 ```
 
+### Rails configuration
+
+Railtie options are available at `config.active_record_update_in_bulk`:
+
+- `values_table_alias` (`String`, optional): alias used for generated VALUES tables (default `"t"`).
+- `ignore_scope_order` (`Boolean`, default `true`): when true, ORDER BY scopes are ignored by `update_in_bulk`; when false, ordered relations raise `NotImplementedError`.
+
+Example initializer:
+
+```ruby
+Rails.application.config.active_record_update_in_bulk.values_table_alias = "vals"
+Rails.application.config.active_record_update_in_bulk.ignore_scope_order = true
+```
+
 ### Record timestamps
 
 By default `update_in_bulk` implicitly bumps update timestamps similar to `upsert_all`.
 - If the model has `updated_at`/`updated_on`, these are bumped *iff the row actually changed*.
 - Passing `record_timestamps: false` can disable bumping the update timestamps for the query.
+- Passing `record_timestamps: :always` always sets update timestamps to `CURRENT_TIMESTAMP`.
 - The `updated_at` columns can also be manually assigned, this disables the implicit bump behaviour.
 
 ```ruby
@@ -91,21 +106,20 @@ Inventory.update_in_bulk({
 ```
 
 Built-in formulas:
-- `:add :subtract :min :max :concat_append :concat_prepend`
+- `:add :subtract :concat_append :concat_prepend`
 
 Custom formulas are supported by providing a `Proc`. The proc takes `(lhs,rhs,model)` and must return an **Arel node**.
 Here `lhs` and `rhs` are instances of `Arel::Attribute` corresponding to the target table and values table respectively.
 
 ```ruby
-# Restock some products, but cap inventory at some maximum amount.
-# LEAST(metadata.max_stock, inventories.quantity + t.quantity)
-add_capped = proc |lhs, rhs| do
-  Arel::Nodes::Least.new([Arel::Attribute.new("metadata", "max_stock"), lhs + rhs])
+# Restock some products with a custom expression.
+add_tax = proc do |lhs, rhs|
+  lhs + rhs + 1
 end
-Inventory.joins(:metadata).update_in_bulk({
+Inventory.update_in_bulk({
   "Christmas balls" => { quantity: 300 },
   "Christmas tree"  => { quantity: 10 }
-}, formulas: { quantity: add_capped })
+}, formulas: { quantity: add_tax })
 ```
 
 ## Notes
@@ -124,7 +138,9 @@ The `UPDATE` is single-shot in any compliant database:
 
 ## Limitations
 
-There is no support for `ORDER BY`, `LIMIT`, `OFFSET`, `GROUP` or `HAVING` clauses in the relation.
+By default `ORDER BY` scopes are ignored for `update_in_bulk` (configurable via railtie setting
+`config.active_record_update_in_bulk.ignore_scope_order = true/false`).
+There is no support for `LIMIT`, `OFFSET`, `GROUP` or `HAVING` clauses in the relation.
 
 The implementation does not automatically batch (nor reject) impermissibly large queries. The size of the values table is `rows * columns` when all rows assign to the same columns, or `rows * (distinct_columns + 1)` when the assign columns are not uniform (an extra bitmask indicator column is used).
 

data/lib/activerecord-updateinbulk/adapters/abstract_adapter.rb

@@ -1,8 +1,14 @@
 # frozen_string_literal: true
 
 module ActiveRecord::UpdateInBulk
+  # Extension points mixed into +ActiveRecord::ConnectionAdapters::AbstractAdapter+
+  # and consumed by the builder/visitor pipeline.
+  #
+  # Concrete adapters may override any of these methods to describe their SQL
+  # capabilities and VALUES table semantics.
   module AbstractAdapter
     # Whether the database supports the SQL VALUES table constructor.
+    # When false, +Relation#update_in_bulk+ raises ArgumentError.
     def supports_values_tables?
       true
     end
@@ -36,6 +42,8 @@ module ActiveRecord::UpdateInBulk
     #
     # Returns the typecasted Arel node: a new node or +values_table+ itself,
     # possibly modified in place.
+    #
+    # The default implementation does no explicit type casting.
     def typecast_values_table(values_table, _columns)
       values_table
     end

data/lib/activerecord-updateinbulk/adapters/postgresql_adapter.rb

@@ -12,8 +12,9 @@ module ActiveRecord::UpdateInBulk
         case column
         when ActiveRecord::ConnectionAdapters::PostgreSQL::Column
           if SAFE_TYPES_FOR_VALUES_TABLE.exclude?(column.type) ||
+              column.array ||
               values_table.rows.all? { |row| row[index].nil? }
-            column.sql_type
+            column.sql_type_metadata.sql_type
           end
         when Arel::Nodes::SqlLiteral, nil
           column

data/lib/activerecord-updateinbulk/arel/select_manager.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveRecord::UpdateInBulk
-  module SelectManager
-    def alias(name)
+  module SelectManager # :nodoc:
+    def alias(name) # :nodoc:
       Arel::Nodes::TableAlias.new(self, name)
     end
   end

data/lib/activerecord-updateinbulk/arel/visitors/to_sql.rb

@@ -2,18 +2,6 @@
 
 module ActiveRecord::UpdateInBulk
   module ToSql
-    def visit_Arel_Nodes_Least(o, collector)
-      collector << "LEAST("
-      inject_join(o.expressions, collector, ", ")
-      collector << ")"
-    end
-
-    def visit_Arel_Nodes_Greatest(o, collector)
-      collector << "GREATEST("
-      inject_join(o.expressions, collector, ", ")
-      collector << ")"
-    end
-
     def visit_Arel_Nodes_ValuesTable(o, collector)
       row_prefix = @connection.values_table_row_prefix
 
@@ -40,7 +28,7 @@ module ActiveRecord::UpdateInBulk
     private
       def build_values_table_single_value(value, collector)
         case value
-        when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam, ActiveModel::Attribute
+        when Arel::Nodes::SqlLiteral, Arel::Nodes::BoundSqlLiteral, Arel::Nodes::BindParam, ActiveModel::Attribute
           visit(value, collector)
         else
           collector << quote(value).to_s

data/lib/activerecord-updateinbulk/base.rb

@@ -10,24 +10,32 @@ module ActiveRecord
       "trilogy" => "abstract_mysql",
     }
 
-    def self.require_adapter(adapter)
+    def self.require_adapter(adapter) # :nodoc:
       adapter = ADAPTER_EXTENSION_MAP.fetch(adapter, adapter)
       require File.join(ADAPTER_PATH, "#{adapter}_adapter")
     end
 
-    def self.load_from_connection_pool(connection_pool)
+    def self.load_from_connection_pool(connection_pool) # :nodoc:
       require_adapter connection_pool.db_config.adapter
     end
+
+    def self.register_formula(name, &formula)
+      Builder.register_formula(name, &formula)
+    end
+
+    def self.unregister_formula(name)
+      Builder.unregister_formula(name)
+    end
+
+    def self.registered_formula?(name)
+      Builder.registered_formula?(name)
+    end
   end
 end
 
 require "activerecord-updateinbulk/builder"
-require "activerecord-updateinbulk/arel/math"
-require "activerecord-updateinbulk/arel/nodes/least"
-require "activerecord-updateinbulk/arel/nodes/greatest"
 require "activerecord-updateinbulk/arel/nodes/values_table"
 require "activerecord-updateinbulk/arel/visitors/to_sql"
-require "activerecord-updateinbulk/arel/visitors/sqlite"
 require "activerecord-updateinbulk/arel/select_manager"
 require "activerecord-updateinbulk/relation"
 require "activerecord-updateinbulk/querying"
@@ -35,8 +43,8 @@ require "activerecord-updateinbulk/querying"
 require "activerecord-updateinbulk/adapters/abstract_adapter"
 
 module ActiveRecord::UpdateInBulk
-  module ConnectionHandler
-    def establish_connection(*args, **kwargs, &block)
+  module ConnectionHandler # :nodoc:
+    def establish_connection(*args, **kwargs, &block) # :nodoc:
       pool = super(*args, **kwargs, &block)
       ActiveRecord::UpdateInBulk.load_from_connection_pool pool
       pool

data/lib/activerecord-updateinbulk/builder.rb

@@ -3,11 +3,31 @@
 require "active_support/core_ext/enumerable"
 
 module ActiveRecord::UpdateInBulk
-  class Builder
-    FORMULAS = %w[add subtract concat_append concat_prepend min max].freeze
+  class Builder # :nodoc:
+    SAFE_COMPARISON_TYPES = [:boolean, :string, :text, :integer, :float, :decimal].freeze
 
     class << self
       attr_accessor :values_table_name
+      attr_accessor :ignore_scope_order
+
+      def register_formula(name, &formula)
+        raise ArgumentError, "Missing block" unless formula
+
+        name = name.to_sym
+        if registered_formulas.key?(name)
+          raise ArgumentError, "Formula already registered: #{name.inspect}"
+        end
+
+        registered_formulas[name] = formula
+      end
+
+      def unregister_formula(name)
+        registered_formulas.delete(name.to_sym)
+      end
+
+      def registered_formula?(name)
+        registered_formulas.key?(name.to_sym)
+      end
 
       # Normalize all input formats into separated format [conditions, assigns].
       def normalize_updates(model, updates, values = nil)
@@ -46,42 +66,37 @@ module ActiveRecord::UpdateInBulk
       end
 
       def apply_formula(formula, lhs, rhs, model)
-        case formula
-        when "add"
-          lhs + rhs
-        when "subtract"
-          lhs - rhs
-        when "concat_append"
-          lhs.concat(rhs)
-        when "concat_prepend"
-          rhs.concat(lhs)
-        when "min"
-          lhs.least(rhs)
-        when "max"
-          lhs.greatest(rhs)
-        when Proc
-          node = apply_proc_formula(formula, lhs, rhs, model)
-          unless Arel.arel_node?(node)
-            raise ArgumentError, "Custom formula must return an Arel node"
-          end
-          node
+        formula_proc = case formula
+        when Proc then formula
         else
-          rhs
+          registered_formulas.fetch(formula.to_sym) do
+            raise ArgumentError, "Unknown formula: #{formula.inspect}"
+          end
         end
+
+        node = apply_proc_formula(formula_proc, lhs, rhs, model)
+        raise ArgumentError, "Custom formula must return an Arel node" unless Arel.arel_node?(node)
+
+        node
       end
 
       def apply_proc_formula(formula, lhs, rhs, model)
         case formula.arity
-        when 2
-          formula.call(lhs, rhs)
-        when 3
-          formula.call(lhs, rhs, model)
-        else
-          raise ArgumentError, "Custom formula must accept 2 or 3 arguments"
+        when 2 then formula.call(lhs, rhs)
+        else formula.call(lhs, rhs, model)
         end
       end
 
       private
+        def registered_formulas
+          @registered_formulas ||= {
+            add: lambda { |lhs, rhs| lhs + rhs },
+            subtract: lambda { |lhs, rhs| lhs - rhs },
+            concat_append: lambda { |lhs, rhs| lhs.concat(rhs) },
+            concat_prepend: lambda { |lhs, rhs| rhs.concat(lhs) }
+          }
+        end
+
         def normalize_conditions(model, conditions)
           if conditions.is_a?(Hash)
             conditions
@@ -113,6 +128,7 @@ module ActiveRecord::UpdateInBulk
         end
     end
     self.values_table_name = "t"
+    self.ignore_scope_order = true
 
     attr_reader :model, :connection
 
@@ -127,96 +143,150 @@ module ActiveRecord::UpdateInBulk
       resolve_read_and_write_keys!
       verify_read_and_write_keys!
       serialize_values!
-      detect_constant_columns!
+      detect_constant_columns! unless simple_update?
     end
 
     def build_arel
-      values_table, bitmask_keys = build_values_table
-      join_conditions = build_join_conditions(model.arel_table, values_table)
-      set_assignments = build_set_assignments(model.arel_table, values_table, bitmask_keys)
-      derived_table = typecast_values_table(values_table)
+      table = model.arel_table
+      values_table, bitmask_keys = build_values_table unless simple_update?
+      conditions = build_conditions(table, values_table)
+      set_assignments = build_set_assignments(table, values_table, bitmask_keys || Set.new)
+      derived_table = typecast_values_table(values_table) if values_table
 
-      [derived_table, join_conditions, set_assignments]
+      [derived_table, conditions, set_assignments]
     end
 
     private
-      attr_reader :read_keys, :write_keys, :constant_conditions, :constant_assigns
+      attr_reader :read_keys, :write_keys, :constant_assigns
+
+      def optional_keys
+        @optional_keys ||= write_keys - @assigns.map(&:keys).reduce(write_keys, &:intersection)
+      end
+
+      def timestamp_keys
+        @timestamp_keys ||= record_timestamps_enabled? ? model.timestamp_attributes_for_update_in_model.to_set - write_keys : Set.new
+      end
+
+      def simple_update?
+        @conditions.size == 1 && @formulas.empty?
+      end
+
+      def build_simple_conditions(table)
+        row_conditions = @conditions.first
+        read_keys.map do |key|
+          table[key].eq(quoted_value(row_conditions.fetch(key)))
+        end
+      end
+
+      def build_simple_assignments(table)
+        row_assigns = @assigns.first
+        write_keys.map do |key|
+          [table[key], quoted_value(row_assigns.fetch(key))]
+        end
+      end
+
+      def detect_constant_columns!
+        @constant_assigns = {}
+
+        (write_keys - optional_keys).each do |key|
+          next if @formulas.key?(key) # need to pass Arel::Attribute as argument to formula
+          first = @assigns.first[key]
+          @constant_assigns[key] = first if @assigns.all? { |a| !Arel.arel_node?(v = a[key]) && v == first }
+        end
+      end
 
       def serialize_values!
-        types = (read_keys | write_keys).index_with { |key| model.type_for_attribute(key) }
+        types = read_keys.index_with { |key| model.type_for_attribute(key) }
         @conditions.each do |row|
           row.each do |key, value|
-            next if opaque_value?(value)
+            next if Arel.arel_node?(value)
             row[key] = ActiveModel::Type::SerializeCastValue.serialize(type = types[key], type.cast(value))
           end
         end
+        types = write_keys.index_with { |key| model.type_for_attribute(key) }
         @assigns.each do |row|
           row.each do |key, value|
-            next if opaque_value?(value)
+            next if Arel.arel_node?(value)
             row[key] = ActiveModel::Type::SerializeCastValue.serialize(type = types[key], type.cast(value))
           end
         end
       end
 
-      def detect_constant_columns!
-        @constant_conditions = {}
-        @constant_assigns = {}
+      def build_values_table
+        rows, bitmask_keys = build_values_table_rows
+        append_bitmask_column(rows, bitmask_keys) unless bitmask_keys.empty?
+        column_names = connection.values_table_default_column_names(rows.first.size)
+        values_table = Arel::Nodes::ValuesTable.new(self.class.values_table_name, rows, column_names)
+        [values_table, bitmask_keys]
+      end
 
-        read_keys.each do |key|
-          first = @conditions.first.fetch(key)
-          @constant_conditions[key] = first if @conditions.all? { |c| !opaque_value?(v = c.fetch(key)) && v == first }
-        end
-        # We can't drop all the conditions columns
-        @constant_conditions.delete(read_keys.first) if @constant_conditions.size == read_keys.size
+      def build_values_table_rows
+        bitmask_keys = Set.new
+        non_constant_write_keys = write_keys - constant_assigns.keys
 
-        (write_keys - optional_keys).each do |key|
-          next if @formulas.key?(key) # need to pass Arel::Attribute as argument to formula
-          first = @assigns.first[key]
-          @constant_assigns[key] = first if @assigns.all? { |a| !opaque_value?(v = a[key]) && v == first }
+        rows = @conditions.map.with_index do |row_conditions, row_index|
+          row_assigns = @assigns[row_index]
+          row = row_conditions.fetch_values(*read_keys)
+          non_constant_write_keys.each do |key|
+            next row << nil unless row_assigns.key?(key)
+            value = row_assigns[key]
+            bitmask_keys.add(key) if optional_keys.include?(key) && might_be_nil_value?(value)
+            row << value
+          end
+          row
         end
-      end
 
-      def optional_keys
-        @optional_keys ||= write_keys - @assigns.map(&:keys).reduce(write_keys, &:intersection)
+        [rows, bitmask_keys]
       end
 
-      def timestamp_keys
-        @timestamp_keys ||= @record_timestamps ? model.timestamp_attributes_for_update_in_model.to_set - write_keys : Set.new
+      def append_bitmask_column(rows, bitmask_keys)
+        rows.each_with_index do |row, row_index|
+          row_assigns = @assigns[row_index]
+          bitmask = "0" * bitmask_keys.size
+          bitmask_keys.each_with_index do |key, index|
+            bitmask[index] = "1" if row_assigns.key?(key)
+          end
+          row.push(bitmask)
+        end
       end
 
-      def build_values_table
-        rows, bitmask_keys = serialize_values_rows
-        append_bitmask_column(rows, bitmask_keys) unless bitmask_keys.empty?
-        values_table = Arel::Nodes::ValuesTable.new(self.class.values_table_name, rows, connection.values_table_default_column_names(rows.first.size))
-        [values_table, bitmask_keys]
-      end
+      def build_conditions(table, values_table)
+        return build_simple_conditions(table) unless values_table
 
-      def build_join_conditions(table, values_table)
-        variable_index = 0
-        read_keys.map do |key|
-          if constant_conditions.key?(key)
-            table[key].eq(Arel::Nodes::Casted.new(constant_conditions[key], table[key]))
-          else
-            condition = table[key].eq(values_table[variable_index])
-            variable_index += 1
-            condition
-          end
+        read_keys.map.with_index do |key, index|
+          table[key].eq(values_table[index])
         end
       end
 
       def build_set_assignments(table, values_table, bitmask_keys)
-        column = read_keys.count { |k| !constant_conditions.key?(k) }
+        set_assignments = if values_table
+          build_join_assignments(table, values_table, bitmask_keys)
+        else
+          build_simple_assignments(table)
+        end
+
+        if timestamp_keys.any?
+          # Timestamp assignments precede data assignments to increase the
+          # chance MySQL will actually run them against the original data.
+          set_assignments = timestamp_assignments(set_assignments) + set_assignments
+        end
+
+        set_assignments
+      end
+
+      def build_join_assignments(table, values_table, bitmask_keys)
+        column = read_keys.size
 
         bitmask_functions = bitmask_keys.index_with.with_index(1) do |key, index|
           Arel::Nodes::NamedFunction.new("SUBSTRING", [values_table[-1], index, 1])
         end
 
-        set_assignments = write_keys.map do |key|
+        write_keys.map do |key|
           formula = @formulas[key]
           lhs = table[key]
 
           if constant_assigns.key?(key)
-            rhs = Arel::Nodes::Casted.new(constant_assigns[key], table[key])
+            rhs = Arel::Nodes::Quoted.new(constant_assigns[key])
           else
             rhs = values_table[column]
             column += 1
@@ -224,64 +294,28 @@ module ActiveRecord::UpdateInBulk
           end
 
           if function = bitmask_functions[key]
-            rhs = Arel::Nodes::Case.new(function).when("1").then(rhs).else(table[key])
+            rhs = Arel::Nodes::Case.new(function).when("1").then(rhs).else(lhs)
           elsif optional_keys.include?(key)
-            rhs = table.coalesce(rhs, table[key])
+            rhs = table.coalesce(rhs, lhs)
           end
-          [table[key], rhs]
-        end
-
-        if timestamp_keys.any?
-          # Timestamp assignments precede data assignments to increase the
-          # change MySQL will actually run them against the original data.
-          set_assignments = timestamp_assignments(set_assignments) + set_assignments
+          [lhs, rhs]
         end
-
-        set_assignments
       end
 
       def typecast_values_table(values_table)
-        variable_keys = read_keys.reject { |k| constant_conditions.key?(k) } + write_keys.reject { |k| constant_assigns.key?(k) }
+        variable_keys = read_keys + write_keys.reject { |k| constant_assigns.key?(k) }
         columns_hash = model.columns_hash
         model_types = variable_keys.map! { |key| columns_hash.fetch(key) }
         connection.typecast_values_table(values_table, model_types).alias(self.class.values_table_name)
       end
 
-      def serialize_values_rows
-        bitmask_keys = Set.new
-
-        rows = @conditions.each_with_index.map do |row_conditions, row_index|
-          row_assigns = @assigns[row_index]
-          row = []
-          read_keys.each do |key|
-            next if constant_conditions.key?(key)
-            row << row_conditions[key]
-          end
-          write_keys.each do |key|
-            next if constant_assigns.key?(key)
-            next row << nil unless row_assigns.key?(key)
-            value = row_assigns[key]
-            bitmask_keys.add(key) if optional_keys.include?(key) && might_be_nil_value?(value)
-            row << value
-          end
-          row
-        end
-
-        [rows, bitmask_keys]
-      end
-
-      def append_bitmask_column(rows, bitmask_keys)
-        rows.each_with_index do |row, row_index|
-          row_assigns = @assigns[row_index]
-          bitmask = "0" * bitmask_keys.size
-          bitmask_keys.each_with_index do |key, index|
-            bitmask[index] = "1" if row_assigns.key?(key)
+      def timestamp_assignments(set_assignments)
+        if always_record_timestamps?
+          return timestamp_keys.map do |key|
+            [model.arel_table[key], connection.high_precision_current_timestamp]
           end
-          row.push(bitmask)
         end
-      end
 
-      def timestamp_assignments(set_assignments)
         case_conditions = set_assignments.map do |left, right|
           left.is_not_distinct_from(right)
         end
@@ -294,23 +328,31 @@ module ActiveRecord::UpdateInBulk
         end
       end
 
-      # When you assign a value to NULL, we need to use a bitmask to distinguish
+      def record_timestamps_enabled?
+        !@record_timestamps.nil? && @record_timestamps != false
+      end
+
+      def always_record_timestamps?
+        @record_timestamps == :always
+      end
+
+      # When you assign a value to NULL, we need to use a bitmask to distinguish that
       # row in the values table from rows where the column is not to be assigned at all.
       def might_be_nil_value?(value)
-        value.nil? || opaque_value?(value)
+        value.nil? || Arel.arel_node?(value)
       end
 
-      def opaque_value?(value)
-        value.is_a?(Arel::Nodes::SqlLiteral) || value.is_a?(Arel::Nodes::BindParam)
+      def quoted_value(value)
+        Arel.arel_node?(value) ? value : Arel::Nodes::Quoted.new(value)
       end
 
       def normalize_formulas(formulas)
         return {} if formulas.blank?
 
         normalized = formulas.to_h do |key, value|
-          [key.to_s, value.is_a?(Proc) ? value : value.to_s]
+          [key.to_s, value.is_a?(Proc) ? value : value.to_sym]
         end
-        invalid = normalized.values.reject { |v| v.is_a?(Proc) } - FORMULAS
+        invalid = normalized.values.reject { |v| v.is_a?(Proc) || self.class.registered_formula?(v) }
         if invalid.any?
           raise ArgumentError, "Unknown formula: #{invalid.first.inspect}"
         end
@@ -329,7 +371,7 @@ module ActiveRecord::UpdateInBulk
 
       def resolve_read_and_write_keys!
         @read_keys = @conditions.first.keys.to_set
-        @write_keys = @assigns.flat_map(&:keys).to_set
+        @write_keys = @assigns.reduce(Set.new) { |set, row| set.merge(row.keys) }
       end
 
       def verify_read_and_write_keys!

data/lib/activerecord-updateinbulk/querying.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveRecord::UpdateInBulk
-  module Querying
-    def update_in_bulk(...)
+  module Querying # :nodoc:
+    def update_in_bulk(...) # :nodoc:
       all.update_in_bulk(...)
     end
   end

data/lib/activerecord-updateinbulk/railtie.rb

@@ -4,15 +4,49 @@ require "rails/railtie"
 
 module ActiveRecord
   module UpdateInBulk
+    # Railtie integration for configuration values consumed by this gem.
+    #
+    # ==== Configuration
+    #
+    # Configure these in a Rails initializer (for example
+    # <tt>config/initializers/update_in_bulk.rb</tt>):
+    #
+    #   Rails.application.config.active_record_update_in_bulk.values_table_alias = "vals"
+    #   Rails.application.config.active_record_update_in_bulk.ignore_scope_order = true
+    #
+    # [config.active_record_update_in_bulk.values_table_alias]
+    #   Optional string alias to use for the generated VALUES table.
+    #   Defaults to <tt>"t"</tt>.
+    #
+    # [config.active_record_update_in_bulk.ignore_scope_order]
+    #   Whether <tt>Relation#update_in_bulk</tt> should ignore any ORDER BY scope
+    #   on the input relation. Necessary for invoking the method on scope-ordered
+    #   associations, or models with a default scope that includes an order.
+    #
+    #   * <tt>true</tt> (default): ORDER BY scopes are stripped.
+    #   * <tt>false</tt>: ordered relations raise NotImplementedError.
     class Railtie < Rails::Railtie
       config.active_record_update_in_bulk = ActiveSupport::OrderedOptions.new
+      config.active_record_update_in_bulk.ignore_scope_order = true
 
-      initializer "active_record_update_in_bulk.values_table_alias", after: :load_config_initializers do |app|
-        if (bulk_alias = app.config.active_record_update_in_bulk.values_table_alias)
-          unless bulk_alias.instance_of?(String) && !bulk_alias.empty?
-            raise ArgumentError, "values_table_alias must be a non-empty String"
+      initializer "active_record_update_in_bulk.values_table_alias" do |app|
+        ActiveSupport.on_load(:active_record) do
+          if (bulk_alias = app.config.active_record_update_in_bulk.values_table_alias)
+            unless bulk_alias.instance_of?(String) && !bulk_alias.empty?
+              raise ArgumentError, "values_table_alias must be a non-empty String"
+            end
+            ActiveRecord::UpdateInBulk::Builder.values_table_name = bulk_alias
           end
-          ActiveRecord::UpdateInBulk::Builder.values_table_name = bulk_alias
+        end
+      end
+
+      initializer "active_record_update_in_bulk.ignore_scope_order" do |app|
+        ActiveSupport.on_load(:active_record) do
+          ignore_scope_order = app.config.active_record_update_in_bulk.ignore_scope_order
+          unless ignore_scope_order == true || ignore_scope_order == false
+            raise ArgumentError, "ignore_scope_order must be true or false"
+          end
+          ActiveRecord::UpdateInBulk::Builder.ignore_scope_order = ignore_scope_order
         end
       end
     end

data/lib/activerecord-updateinbulk/relation.rb

@@ -51,13 +51,17 @@ module ActiveRecord::UpdateInBulk
     #   To override this and force automatic setting of timestamp columns one
     #   way or the other, pass <tt>:record_timestamps</tt>.
     #
+    #   Pass <tt>record_timestamps: :always</tt> to always assign timestamp
+    #   columns to the current database timestamp (without change-detection
+    #   CASE logic).
+    #
     # [:formulas]
     #   A hash of column names to formula identifiers or Procs. Instead of
     #   a simple assignment, the column is set to an expression that can
     #   reference both the current selected row value and the incoming value.
     #
-    #   Built-in formulas: <tt>:add</tt>, <tt>:subtract</tt>, <tt>:min</tt>,
-    #   <tt>:max</tt>, <tt>:concat_append</tt>, <tt>:concat_prepend</tt>.
+    #   Built-in formulas: <tt>:add</tt>, <tt>:subtract</tt>,
+    #   <tt>:concat_append</tt>, <tt>:concat_prepend</tt>.
     #
     #     Inventory.update_in_bulk({
     #       "Christmas balls" => { quantity: 73 },
@@ -68,8 +72,8 @@ module ActiveRecord::UpdateInBulk
     #   <tt>(lhs, rhs)</tt> or <tt>(lhs, rhs, model)</tt> and returns an
     #   Arel node:
     #
-    #     add_capped = ->(lhs, rhs) { lhs.least(lhs + rhs) }
-    #     Inventory.update_in_bulk(updates, formulas: { quantity: add_capped })
+    #     add_tax = ->(lhs, rhs) { lhs + rhs + 1 }
+    #     Inventory.update_in_bulk(updates, formulas: { quantity: add_tax })
     #
     # ==== Examples
     #
@@ -87,8 +91,11 @@ module ActiveRecord::UpdateInBulk
     #   })
     #
     def update_in_bulk(updates, values = nil, record_timestamps: nil, formulas: nil)
-      unless limit_value.nil? && offset_value.nil? && order_values.empty? && group_values.empty? && having_clause.empty?
-        raise NotImplementedError, "No support to update grouped or ordered relations (offset, limit, order, group, having clauses)"
+      unless limit_value.nil? && offset_value.nil? && group_values.empty? && having_clause.empty?
+        raise NotImplementedError, "No support to update relations with offset, limit, group, or having clauses"
+      end
+      if order_values.any? && !Builder.ignore_scope_order
+        raise NotImplementedError, "No support to update ordered relations (order clause)"
       end
 
       conditions, assigns = Builder.normalize_updates(model, updates, values)
@@ -101,8 +108,9 @@ module ActiveRecord::UpdateInBulk
 
         arel = eager_loading? ? apply_join_dependency.arel : arel()
         arel.source.left = table
+        arel.ast.orders = [] if Builder.ignore_scope_order
 
-        values_table, join_conditions, set_assignments = Builder.new(
+        values_table, conditions, set_assignments = Builder.new(
           self,
           c,
           conditions,
@@ -110,7 +118,11 @@ module ActiveRecord::UpdateInBulk
           record_timestamps:,
           formulas:
         ).build_arel
-        arel = arel.join(values_table).on(*join_conditions)
+        if values_table
+          arel = arel.join(values_table).on(*conditions)
+        else
+          conditions.each { |condition| arel.where(condition) }
+        end
 
         key = if model.composite_primary_key?
           primary_key.map { |pk| table[pk] }

data/lib/activerecord-updateinbulk/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module UpdateInBulk
-    VERSION = "0.1.2"
+    VERSION = "0.2.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-updateinbulk
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
 platform: ruby
 authors:
 - Bruno Carvalho
@@ -23,20 +23,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '8.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'
 description: Introduces update_in_bulk(), a method to update many records in a table
   with different values in a single SQL statement.
 email:
@@ -52,12 +38,8 @@ files:
 - lib/activerecord-updateinbulk/adapters/abstract_mysql_adapter.rb
 - lib/activerecord-updateinbulk/adapters/postgresql_adapter.rb
 - lib/activerecord-updateinbulk/adapters/sqlite3_adapter.rb
-- lib/activerecord-updateinbulk/arel/math.rb
-- lib/activerecord-updateinbulk/arel/nodes/greatest.rb
-- lib/activerecord-updateinbulk/arel/nodes/least.rb
 - lib/activerecord-updateinbulk/arel/nodes/values_table.rb
 - lib/activerecord-updateinbulk/arel/select_manager.rb
-- lib/activerecord-updateinbulk/arel/visitors/sqlite.rb
 - lib/activerecord-updateinbulk/arel/visitors/to_sql.rb
 - lib/activerecord-updateinbulk/base.rb
 - lib/activerecord-updateinbulk/builder.rb

data/lib/activerecord-updateinbulk/arel/math.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Arel
-  module Math
-    def least(other)
-      lhs = is_a?(Arel::Nodes::Least) ? self.expressions : [self]
-      rhs = other.is_a?(Arel::Nodes::Least) ? other.expressions : [other]
-      Arel::Nodes::Least.new(lhs + rhs)
-    end
-
-    def greatest(other)
-      lhs = is_a?(Arel::Nodes::Greatest) ? self.expressions : [self]
-      rhs = other.is_a?(Arel::Nodes::Greatest) ? other.expressions : [other]
-      Arel::Nodes::Greatest.new(lhs + rhs)
-    end
-  end
-end

data/lib/activerecord-updateinbulk/arel/nodes/greatest.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Arel::Nodes
-  class Greatest < Function
-  end
-end

data/lib/activerecord-updateinbulk/arel/nodes/least.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Arel::Nodes
-  class Least < Function
-  end
-end

data/lib/activerecord-updateinbulk/arel/visitors/sqlite.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord::UpdateInBulk
-  module SQLiteToSql
-    private
-      def visit_Arel_Nodes_Least(o, collector)
-        collector << "MIN("
-        inject_join(o.expressions, collector, ", ")
-        collector << ")"
-      end
-
-      def visit_Arel_Nodes_Greatest(o, collector)
-        collector << "MAX("
-        inject_join(o.expressions, collector, ", ")
-        collector << ")"
-      end
-  end
-end
-
-Arel::Visitors::SQLite.prepend(ActiveRecord::UpdateInBulk::SQLiteToSql)