activerecord-updateinbulk 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25ba0ab087a02a9c275429d50daa9b31bc2bc93fe4ae40c726402f4fd2f21ec2
-  data.tar.gz: d32540835f40aaaf11aa0180d9f49763c775ff7b55287dec5cd9db568b20f45f
+  metadata.gz: 5b333b357426d210ed69dfa18de2f7f77ae8088e9fc47819198118f22f7647fc
+  data.tar.gz: 96eb8a466eb413735de1e1ed4e80dbbc18402b356b5870d9b24b92826828b425
 SHA512:
-  metadata.gz: 2dee9dd00a22a4bebf1d692d926ce2dfafaf2730b3163ee384dda5038616fbef79812caba778280d7ed36523e5f0433dac5cbfc19667c8d038a79bf10fc6db0e
-  data.tar.gz: 8273e2806d3dfceca28214e461b0a6a7954d613e2fc9dfeebc4c754e1582121473a87817fdbc14498d534429163f3554f82ba46eb6b10c1a322aedbcffc558ae
+  metadata.gz: 7a9ff7817a67baf305cd391c855e7607b7adc4c756abadf8d11bba119ad137bd378e83841e80dacaa0abe8265cd3c6d432f58faa4029608fe783c3ab410b7b14
+  data.tar.gz: b71a70301fa255f1c52ae9472b6cce357b2d8f10313226398e74294af0a76179b04383d3d2c5fa52b82fa05dc5dd3581fe4da0330414c1394d8ab900dd4863e9

data/README.md

@@ -61,17 +61,10 @@ Order.joins(:items).where(items: { status: :shipped }).update_in_bulk({
 
 ### Rails configuration
 
-Railtie options are available at `config.active_record_update_in_bulk`:
+Railtie initializer 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
-```
+- `ignore_scope_order` (`Boolean`, default `true`): when true, ORDER BY scopes are ignored by `update_in_bulk`.
 
 ### Record timestamps
 

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/base.rb

@@ -18,6 +18,18 @@ module ActiveRecord
     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
 

data/lib/activerecord-updateinbulk/builder.rb

@@ -4,13 +4,31 @@ require "active_support/core_ext/enumerable"
 
 module ActiveRecord::UpdateInBulk
   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
 
+      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)
         conditions = []
@@ -48,39 +66,37 @@ module ActiveRecord::UpdateInBulk
       end
 
       def apply_formula(formula, lhs, rhs, model)
-        formula = formula.to_sym if formula.is_a?(String)
-        case formula
-        when :add
-          lhs + rhs
-        when :subtract
-          lhs - rhs
-        when :concat_append
-          lhs.concat(rhs)
-        when :concat_prepend
-          rhs.concat(lhs)
-        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
-          raise ArgumentError, "Unknown formula: #{formula.inspect}"
+          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
@@ -122,14 +138,14 @@ module ActiveRecord::UpdateInBulk
       @conditions = conditions
       @assigns = assigns
       @formulas = normalize_formulas(formulas)
+      @auto_locking_column = nil
 
       resolve_attribute_aliases!
       resolve_read_and_write_keys!
+      apply_optimistic_locking!
       verify_read_and_write_keys!
-      unless simple_update?
-        detect_constant_columns!
-        serialize_values!
-      end
+      serialize_values!
+      detect_constant_columns! unless simple_update?
     end
 
     def build_arel
@@ -160,26 +176,24 @@ module ActiveRecord::UpdateInBulk
       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]))
+          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], cast_for_column(row_assigns.fetch(key), table[key])]
+          [table[key], quoted_value(row_assigns.fetch(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 }
+          @constant_assigns[key] = first if @assigns.all? { |a| !Arel.arel_node?(v = a[key]) && v == first }
         end
       end
 
@@ -187,14 +201,14 @@ module ActiveRecord::UpdateInBulk
         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) || constant_assigns.key?(key)
+            next if Arel.arel_node?(value)
             row[key] = ActiveModel::Type::SerializeCastValue.serialize(type = types[key], type.cast(value))
           end
         end
@@ -210,7 +224,7 @@ module ActiveRecord::UpdateInBulk
 
       def build_values_table_rows
         bitmask_keys = Set.new
-        non_constant_write_keys = write_keys - constant_assigns.keys
+        non_constant_write_keys = write_keys.reject { |key| constant_assigns.key?(key) }
 
         rows = @conditions.map.with_index do |row_conditions, row_index|
           row_assigns = @assigns[row_index]
@@ -252,6 +266,10 @@ module ActiveRecord::UpdateInBulk
         else
           build_simple_assignments(table)
         end
+        if @auto_locking_column
+          lock = table[@auto_locking_column]
+          set_assignments << [lock, table.coalesce(lock, 0) + 1]
+        end
 
         if timestamp_keys.any?
           # Timestamp assignments precede data assignments to increase the
@@ -274,9 +292,10 @@ module ActiveRecord::UpdateInBulk
           lhs = table[key]
 
           if constant_assigns.key?(key)
-            rhs = Arel::Nodes::Casted.new(constant_assigns[key], lhs)
+            rhs = Arel::Nodes::Quoted.new(constant_assigns[key])
           else
-            rhs = values_table[column]
+            val = values_table[column]
+            rhs = val
             column += 1
             rhs = self.class.apply_formula(formula, lhs, rhs, model) if formula
           end
@@ -284,7 +303,11 @@ module ActiveRecord::UpdateInBulk
           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)
+            if formula
+              rhs = Arel::Nodes::Case.new.when(val.eq(nil)).then(lhs).else(rhs)
+            else
+              rhs = table.coalesce(rhs, lhs)
+            end
           end
           [lhs, rhs]
         end
@@ -327,15 +350,11 @@ module ActiveRecord::UpdateInBulk
       # 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)
-        Arel.arel_node?(value)
-      end
-
-      def cast_for_column(value, column)
-        opaque_value?(value) ? value : Arel::Nodes::Casted.new(value, column)
+      def quoted_value(value)
+        Arel.arel_node?(value) ? value : Arel::Nodes::Quoted.new(value)
       end
 
       def normalize_formulas(formulas)
@@ -344,13 +363,22 @@ module ActiveRecord::UpdateInBulk
         normalized = formulas.to_h do |key, value|
           [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
         normalized
       end
 
+      def apply_optimistic_locking!
+        return unless model.locking_enabled?
+
+        locking_column = model.locking_column
+        return if write_keys.include?(locking_column)
+
+        @auto_locking_column = locking_column
+      end
+
       def resolve_attribute_aliases!
         return if model.attribute_aliases.empty?
 

data/lib/activerecord-updateinbulk/railtie.rb

@@ -29,21 +29,25 @@ module ActiveRecord
       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", 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"
+      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
-        ActiveRecord::UpdateInBulk::Builder.ignore_scope_order = ignore_scope_order
       end
     end
   end

data/lib/activerecord-updateinbulk/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module UpdateInBulk
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-updateinbulk
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 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: