activerecord-updateinbulk 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25ba0ab087a02a9c275429d50daa9b31bc2bc93fe4ae40c726402f4fd2f21ec2
-  data.tar.gz: d32540835f40aaaf11aa0180d9f49763c775ff7b55287dec5cd9db568b20f45f
+  metadata.gz: 1a844813b98d092d304542eb4f8c3ffc6b99a50f7510d430bef229e47c969415
+  data.tar.gz: e83aa71485ad9255b977b96afe9a8ec55820eda485d489d16e30629c1a79a971
 SHA512:
-  metadata.gz: 2dee9dd00a22a4bebf1d692d926ce2dfafaf2730b3163ee384dda5038616fbef79812caba778280d7ed36523e5f0433dac5cbfc19667c8d038a79bf10fc6db0e
-  data.tar.gz: 8273e2806d3dfceca28214e461b0a6a7954d613e2fc9dfeebc4c754e1582121473a87817fdbc14498d534429163f3554f82ba46eb6b10c1a322aedbcffc558ae
+  metadata.gz: 45d04870ea3981cc5bb3533572f8fd412cc442bfbde77163d2d78bb47af3e3234658db990afdea09fc754f6d492ed400bc50f7f23508f01a82614f1803fae05e
+  data.tar.gz: 33dfb33a7963b357eb8da64afc3353e671fa33cab926e8bf3b9380ccecd47dbae1360f776159e35dc02a44c0c8f98721d7ed58306eebc456bf89673b0fc14900

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
@@ -126,10 +142,8 @@ 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
+      serialize_values!
+      detect_constant_columns! unless simple_update?
     end
 
     def build_arel
@@ -160,26 +174,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 +199,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
@@ -274,7 +286,7 @@ 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]
             column += 1
@@ -327,15 +339,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)
-      end
-
-      def opaque_value?(value)
-        Arel.arel_node?(value)
+        value.nil? || 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,7 +352,7 @@ 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

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.2.1"
   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.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: