activerecord-updateinbulk 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d50d84d5dbf5f42cee6fc93e3e4718b2e1b7993baac8d4bde92b7634d9e5675
-  data.tar.gz: bc16526ad3800298a96bdb5cc3c9365d8d600ac083a9273e0f45ef8655d96fad
+  metadata.gz: 3bac8ddb8a7317ff277d0afbf77432ed979aa3246ec4030fd62f64ef64c98127
+  data.tar.gz: f09a62eda8673ad252d49038a8f1c3605e435b04121069b531f8d56fef48a919
 SHA512:
-  metadata.gz: 7f1cc791591f474b8f93c124a74f27083bc6d134292d3c3a3a076370aff29e067874ffbc684e55808d639b890657300c0c9cfd9a23f2e12d161134f34ada7926
-  data.tar.gz: 23a234ef95ada21deab31cdcefbd075caa4d856546f69ad6622d5b70ddd24d72c4b2633763b5b2e721baba3e5e013a4a2118e58ec39d2eaf62f09e00e6e4aa0c
+  metadata.gz: 3f8e68e4bcc3704ffa56960fb9f12c4e49156c027f156eea4b356e710916e839a99e398e8aaddad9d7cb5e93b28a32bfd380e0f9372967c08bf76377fd7fcf9d
+  data.tar.gz: b6ec0dbcb9a18e1182aab529ca685a2edf441d030a28c8bc0951a79b8dcfe4f5b4c4822724d9e3fc01de7eeda387e5c0c25636ff9ca6c4d0504fe341165a1d26

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
@@ -75,6 +73,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.

data/lib/activerecord-updateinbulk/builder.rb

@@ -126,6 +126,8 @@ module ActiveRecord::UpdateInBulk
       resolve_attribute_aliases!
       resolve_read_and_write_keys!
       verify_read_and_write_keys!
+      serialize_values!
+      detect_constant_columns!
     end
 
     def build_arel
@@ -138,7 +140,41 @@ module ActiveRecord::UpdateInBulk
     end
 
     private
-      attr_reader :read_keys, :write_keys
+      attr_reader :read_keys, :write_keys, :constant_conditions, :constant_assigns
+
+      def serialize_values!
+        types = (read_keys | write_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
+        @assigns.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
+      end
+
+      def detect_constant_columns!
+        @constant_conditions = {}
+        @constant_assigns = {}
+
+        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
+
+        (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 }
+        end
+      end
 
       def optional_keys
         @optional_keys ||= write_keys - @assigns.map(&:keys).reduce(write_keys, &:intersection)
@@ -149,32 +185,44 @@ module ActiveRecord::UpdateInBulk
       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))
-        end
+        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_join_conditions(table, values_table)
-        read_keys.map.with_index do |key, index|
-          table[key].eq(values_table[index])
+        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
         end
       end
 
       def build_set_assignments(table, values_table, bitmask_keys)
+        column = read_keys.count { |k| !constant_conditions.key?(k) }
+
         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.with_index do |key, index|
+        set_assignments = write_keys.map do |key|
           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 constant_assigns.key?(key)
+            rhs = Arel::Nodes::Casted.new(constant_assigns[key], table[key])
+          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(table[key])
           elsif optional_keys.include?(key)
@@ -184,33 +232,39 @@ module ActiveRecord::UpdateInBulk
         end
 
         if timestamp_keys.any?
-          set_assignments += timestamp_assignments(set_assignments)
+          # 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) }
         columns_hash = model.columns_hash
-        model_types = read_keys.to_a.concat(write_keys.to_a).map! { |key| columns_hash.fetch(key) }
+        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(&)
+      def serialize_values_rows
         bitmask_keys = Set.new
 
         rows = @conditions.each_with_index.map do |row_conditions, row_index|
           row_assigns = @assigns[row_index]
-          condition_values = read_keys.map do |key|
-            yield(key, row_conditions[key])
+          row = []
+          read_keys.each do |key|
+            next if constant_conditions.key?(key)
+            row << row_conditions[key]
           end
-          write_values = write_keys.map do |key|
-            next unless row_assigns.key?(key)
-            value = yield(key, row_assigns[key])
+          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)
-            value
+            row << value
           end
-          condition_values.concat(write_values)
+          row
         end
 
         [rows, bitmask_keys]
@@ -240,10 +294,14 @@ module ActiveRecord::UpdateInBulk
         end
       end
 
-      # When you assign a value to NULL, we need to use a bitmask to distinguish that
+      # When you assign a value to NULL, we need to use a bitmask to distinguish
       # 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)
+        value.is_a?(Arel::Nodes::SqlLiteral) || value.is_a?(Arel::Nodes::BindParam)
       end
 
       def normalize_formulas(formulas)

data/lib/activerecord-updateinbulk/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module UpdateInBulk
-    VERSION = "0.1.1"
+    VERSION = "0.1.2"
   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.1.2
 platform: ruby
 authors:
 - Bruno Carvalho