activerecord-updateinbulk 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d50d84d5dbf5f42cee6fc93e3e4718b2e1b7993baac8d4bde92b7634d9e5675
-  data.tar.gz: bc16526ad3800298a96bdb5cc3c9365d8d600ac083a9273e0f45ef8655d96fad
+  metadata.gz: 25ba0ab087a02a9c275429d50daa9b31bc2bc93fe4ae40c726402f4fd2f21ec2
+  data.tar.gz: d32540835f40aaaf11aa0180d9f49763c775ff7b55287dec5cd9db568b20f45f
 SHA512:
-  metadata.gz: 7f1cc791591f474b8f93c124a74f27083bc6d134292d3c3a3a076370aff29e067874ffbc684e55808d639b890657300c0c9cfd9a23f2e12d161134f34ada7926
-  data.tar.gz: 23a234ef95ada21deab31cdcefbd075caa4d856546f69ad6622d5b70ddd24d72c4b2633763b5b2e721baba3e5e013a4a2118e58ec39d2eaf62f09e00e6e4aa0c
+  metadata.gz: 2dee9dd00a22a4bebf1d692d926ce2dfafaf2730b3163ee384dda5038616fbef79812caba778280d7ed36523e5f0433dac5cbfc19667c8d038a79bf10fc6db0e
+  data.tar.gz: 8273e2806d3dfceca28214e461b0a6a7954d613e2fc9dfeebc4c754e1582121473a87817fdbc14498d534429163f3554f82ba46eb6b10c1a322aedbcffc558ae

data/README.md

@@ -10,8 +10,6 @@ Similar to `update_all`, it returns the number of affected rows, and bumps updat
 
 Tested on Ruby 3.4 and Rails 8 for all builtin databases on latest versions.
 
-Important note: there is a flaky test on MySQL (that is not flaky on MariaDB) that I am still investigating.
-
 ## Usage
 
 ```ruby
@@ -61,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
@@ -75,6 +88,8 @@ Employee.update_in_bulk({
 }, record_timestamps: false)
 ```
 
+Note: On MySQL [assignments are processed in series](https://dev.mysql.com/doc/refman/9.0/en/update.html), so there is no real guarantee that the timestamps are actually updated.
+
 ### Formulas (computed assignments)
 
 In all examples so far the queries simply assign predetermined values to rows matched, irrespective of their previous values.
@@ -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/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,20 @@ 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
   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 +31,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,13 @@
 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:
+    FORMULAS = [:add, :subtract, :concat_append, :concat_prepend].freeze
+    SAFE_COMPARISON_TYPES = [:boolean, :string, :text, :integer, :float, :decimal].freeze
 
     class << self
       attr_accessor :values_table_name
+      attr_accessor :ignore_scope_order
 
       # Normalize all input formats into separated format [conditions, assigns].
       def normalize_updates(model, updates, values = nil)
@@ -46,19 +48,16 @@ module ActiveRecord::UpdateInBulk
       end
 
       def apply_formula(formula, lhs, rhs, model)
+        formula = formula.to_sym if formula.is_a?(String)
         case formula
-        when "add"
+        when :add
           lhs + rhs
-        when "subtract"
+        when :subtract
           lhs - rhs
-        when "concat_append"
+        when :concat_append
           lhs.concat(rhs)
-        when "concat_prepend"
+        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)
@@ -66,7 +65,7 @@ module ActiveRecord::UpdateInBulk
           end
           node
         else
-          rhs
+          raise ArgumentError, "Unknown formula: #{formula.inspect}"
         end
       end
 
@@ -113,6 +112,7 @@ module ActiveRecord::UpdateInBulk
         end
     end
     self.values_table_name = "t"
+    self.ignore_scope_order = true
 
     attr_reader :model, :connection
 
@@ -126,91 +126,102 @@ module ActiveRecord::UpdateInBulk
       resolve_attribute_aliases!
       resolve_read_and_write_keys!
       verify_read_and_write_keys!
+      unless simple_update?
+        detect_constant_columns!
+        serialize_values!
+      end
     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
+      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 ? model.timestamp_attributes_for_update_in_model.to_set - write_keys : Set.new
+        @timestamp_keys ||= record_timestamps_enabled? ? model.timestamp_attributes_for_update_in_model.to_set - write_keys : Set.new
       end
 
-      def build_values_table
-        types = (read_keys | write_keys).index_with { |key| model.type_for_attribute(key) }
-        rows, bitmask_keys = serialize_values_rows do |key, value|
-          next value if Arel::Nodes::SqlLiteral === value
-          ActiveModel::Type::SerializeCastValue.serialize(type = types[key], type.cast(value))
+      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(cast_for_column(row_conditions.fetch(key), table[key]))
         end
-        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_join_conditions(table, values_table)
-        read_keys.map.with_index do |key, index|
-          table[key].eq(values_table[index])
+      def build_simple_assignments(table)
+        row_assigns = @assigns.first
+        write_keys.map do |key|
+          [table[key], cast_for_column(row_assigns.fetch(key), table[key])]
         end
       end
 
-      def build_set_assignments(table, values_table, bitmask_keys)
-        bitmask_functions = bitmask_keys.index_with.with_index(1) do |key, index|
-          Arel::Nodes::NamedFunction.new("SUBSTRING", [values_table[-1], index, 1])
+      def detect_constant_columns!
+        @constant_assigns = {}
+        columns_hash = model.columns_hash
+
+        (write_keys - optional_keys).each do |key|
+          next if @formulas.key?(key) # need to pass Arel::Attribute as argument to formula
+          next unless SAFE_COMPARISON_TYPES.include?(columns_hash.fetch(key).type)
+          first = @assigns.first[key]
+          @constant_assigns[key] = first if @assigns.all? { |a| !opaque_value?(v = a[key]) && v == first }
         end
+      end
 
-        set_assignments = write_keys.map.with_index do |key, index|
-          formula = @formulas[key]
-          lhs = table[key]
-          rhs = values_table[index + read_keys.size]
-          rhs = self.class.apply_formula(formula, lhs, rhs, model) if formula
-          if function = bitmask_functions[key]
-            rhs = Arel::Nodes::Case.new(function).when("1").then(rhs).else(table[key])
-          elsif optional_keys.include?(key)
-            rhs = table.coalesce(rhs, table[key])
+      def serialize_values!
+        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)
+            row[key] = ActiveModel::Type::SerializeCastValue.serialize(type = types[key], type.cast(value))
           end
-          [table[key], rhs]
         end
-
-        if timestamp_keys.any?
-          set_assignments += timestamp_assignments(set_assignments)
+        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) || constant_assigns.key?(key)
+            row[key] = ActiveModel::Type::SerializeCastValue.serialize(type = types[key], type.cast(value))
+          end
         end
-
-        set_assignments
       end
 
-      def typecast_values_table(values_table)
-        columns_hash = model.columns_hash
-        model_types = read_keys.to_a.concat(write_keys.to_a).map! { |key| columns_hash.fetch(key) }
-        connection.typecast_values_table(values_table, model_types).alias(self.class.values_table_name)
+      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
 
-      def serialize_values_rows(&)
+      def build_values_table_rows
         bitmask_keys = Set.new
+        non_constant_write_keys = write_keys - constant_assigns.keys
 
-        rows = @conditions.each_with_index.map do |row_conditions, row_index|
+        rows = @conditions.map.with_index do |row_conditions, row_index|
           row_assigns = @assigns[row_index]
-          condition_values = read_keys.map do |key|
-            yield(key, row_conditions[key])
-          end
-          write_values = write_keys.map do |key|
-            next unless row_assigns.key?(key)
-            value = yield(key, row_assigns[key])
+          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)
-            value
+            row << value
           end
-          condition_values.concat(write_values)
+          row
         end
 
         [rows, bitmask_keys]
@@ -227,7 +238,72 @@ module ActiveRecord::UpdateInBulk
         end
       end
 
+      def build_conditions(table, values_table)
+        return build_simple_conditions(table) unless values_table
+
+        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)
+        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
+
+        write_keys.map do |key|
+          formula = @formulas[key]
+          lhs = table[key]
+
+          if constant_assigns.key?(key)
+            rhs = Arel::Nodes::Casted.new(constant_assigns[key], lhs)
+          else
+            rhs = values_table[column]
+            column += 1
+            rhs = self.class.apply_formula(formula, lhs, rhs, model) if formula
+          end
+
+          if function = bitmask_functions[key]
+            rhs = Arel::Nodes::Case.new(function).when("1").then(rhs).else(lhs)
+          elsif optional_keys.include?(key)
+            rhs = table.coalesce(rhs, lhs)
+          end
+          [lhs, rhs]
+        end
+      end
+
+      def typecast_values_table(values_table)
+        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 timestamp_assignments(set_assignments)
+        if always_record_timestamps?
+          return timestamp_keys.map do |key|
+            [model.arel_table[key], connection.high_precision_current_timestamp]
+          end
+        end
+
         case_conditions = set_assignments.map do |left, right|
           left.is_not_distinct_from(right)
         end
@@ -240,17 +316,33 @@ module ActiveRecord::UpdateInBulk
         end
       end
 
+      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? || value.is_a?(Arel::Nodes::SqlLiteral) || value.is_a?(Arel::Nodes::BindParam)
+        value.nil? || opaque_value?(value)
+      end
+
+      def opaque_value?(value)
+        Arel.arel_node?(value)
+      end
+
+      def cast_for_column(value, column)
+        opaque_value?(value) ? value : Arel::Nodes::Casted.new(value, column)
       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
         if invalid.any?
@@ -271,7 +363,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,8 +4,30 @@ 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)
@@ -15,6 +37,14 @@ module ActiveRecord
           ActiveRecord::UpdateInBulk::Builder.values_table_name = bulk_alias
         end
       end
+
+      initializer "active_record_update_in_bulk.ignore_scope_order", after: :load_config_initializers do |app|
+        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
 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.1"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-updateinbulk
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Bruno Carvalho
@@ -52,12 +52,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)