activerecord-updateinbulk 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bac8ddb8a7317ff277d0afbf77432ed979aa3246ec4030fd62f64ef64c98127
-  data.tar.gz: f09a62eda8673ad252d49038a8f1c3605e435b04121069b531f8d56fef48a919
+  metadata.gz: 25ba0ab087a02a9c275429d50daa9b31bc2bc93fe4ae40c726402f4fd2f21ec2
+  data.tar.gz: d32540835f40aaaf11aa0180d9f49763c775ff7b55287dec5cd9db568b20f45f
 SHA512:
-  metadata.gz: 3f8e68e4bcc3704ffa56960fb9f12c4e49156c027f156eea4b356e710916e839a99e398e8aaddad9d7cb5e93b28a32bfd380e0f9372967c08bf76377fd7fcf9d
-  data.tar.gz: b6ec0dbcb9a18e1182aab529ca685a2edf441d030a28c8bc0951a79b8dcfe4f5b4c4822724d9e3fc01de7eeda387e5c0c25636ff9ca6c4d0504fe341165a1d26
+  metadata.gz: 2dee9dd00a22a4bebf1d692d926ce2dfafaf2730b3163ee384dda5038616fbef79812caba778280d7ed36523e5f0433dac5cbfc19667c8d038a79bf10fc6db0e
+  data.tar.gz: 8273e2806d3dfceca28214e461b0a6a7954d613e2fc9dfeebc4c754e1582121473a87817fdbc14498d534429163f3554f82ba46eb6b10c1a322aedbcffc558ae

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/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,97 +126,155 @@ module ActiveRecord::UpdateInBulk
       resolve_attribute_aliases!
       resolve_read_and_write_keys!
       verify_read_and_write_keys!
-      serialize_values!
-      detect_constant_columns!
+      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, :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(cast_for_column(row_conditions.fetch(key), table[key]))
+        end
+      end
+
+      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 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
 
       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)
             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 opaque_value?(value) || constant_assigns.key?(key)
             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::Casted.new(constant_assigns[key], lhs)
           else
             rhs = values_table[column]
             column += 1
@@ -224,64 +282,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]
+          [lhs, 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
-        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,21 +316,33 @@ 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)
       end
 
       def opaque_value?(value)
-        value.is_a?(Arel::Nodes::SqlLiteral) || value.is_a?(Arel::Nodes::BindParam)
+        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?
@@ -329,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.2"
+    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.2
+  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)