activerecord_bulkoperation 0.0.2

data/lib/activerecord_bulkoperation/group_operations.rb

@@ -0,0 +1,296 @@
+module ActiveRecord
+  class Base
+
+    attr_reader :orginal_selected_record
+
+    def save_original      
+      @orginal_selected_record = @attributes.to_hash.clone unless @orginal_selected_record
+      self
+    end
+
+    def callbacks_closed_scheduled_operation
+      ( @callbacks_closed_scheduled_operation ||= Set.new)
+    end
+
+    def on_closed_scheduled_operation
+      @callbacks_closed_scheduled_operation && @callbacks_closed_scheduled_operation.each { |c| c.on_closed_scheduled_operation }
+    end
+
+    def unset_new_record
+      @new_record = false
+    end
+    class << self
+      # will insert or update the given array
+      #
+      # +group+ array of activerecord objects
+      def merge_group(group, options = {})
+        check_group(group)
+
+        to_insert = group.select { |i| i.new_record? }
+
+        to_update = group.select { |i| not i.new_record? }
+
+        affected_rows = 0
+
+        affected_rows += insert_group(to_insert, options) unless to_insert.empty?
+        affected_rows += update_group(to_update, options) unless to_update.empty?
+
+        affected_rows
+      end      
+
+      def to_type_symbol(column)
+        return :string  if  column.sql_type.index('CHAR')
+        return :date    if  column.sql_type.index('DATE') or column.sql_type.index('TIMESTAMP')
+        return :integer if  column.sql_type.index('NUMBER') and column.sql_type.count(',') == 0
+        return :float   if  column.sql_type.index('NUMBER') and column.sql_type.count(',') == 1
+        fail ArgumentError.new("type #{column.sql_type} of #{column.name} is unsupported")
+      end
+      
+      def foreign_detail_tables
+        @foreign_detail_tables ||= find_foreign_detail_tables(table_name)
+      end
+
+      def foreign_master_tables
+        @foreign_master_tables ||= find_foreign_master_tables(table_name)
+      end
+
+      def check_group(group)
+        fail ArgumentError.new("Array expected. Got #{group.class.name}.") unless group.is_a? Array or group.is_a? Set or group.is_a? ActiveRecord::Relation
+        fail ArgumentError.new("only records of #{name} expected. Unexpected #{group.select { |i| not i.is_a? self }.map { |i|i.class.name }.uniq.join(',') } found.") unless group.select { |i| not i.is_a? self }.empty?
+      end
+
+      def insert_group(group, options = {})
+        to_insert = group.select { |i| not i.new_record? }
+
+        sql = "INSERT INTO #{table_name} " \
+              '( ' +
+              "#{columns.map { |c| c.name }.join(', ') } " +
+              ') VALUES ( ' +
+              "#{(1..columns.count).map { |i| ":#{i}"  }.join(', ') } " +
+              ')'
+
+        types  = []
+
+        for c in columns
+          type = to_type_symbol(c)
+          types << type
+        end
+
+        values = []
+
+        for record in group
+
+          row = []
+
+          for c in columns
+            v = record.read_attribute(c.name)
+            row << v
+          end
+
+          values << row
+
+        end
+
+        result = execute_batch_update(sql, types, values)
+
+        group.each { |r| r.unset_new_record }
+
+        result
+      end
+
+      def update_group(group, options = {})
+        check_group(group)
+
+        optimistic = options[:optimistic]
+        optimistic = true if optimistic.nil?
+
+        fail NoOrginalRecordFound.new("#{name} ( #{table_name} )") if optimistic and not group.select { |i| not i.orginal_selected_record }.empty?
+
+        sql = optimistic ? build_optimistic_update_sql : build_update_by_primary_key_sql
+
+        types  = []
+
+        for c in columns
+          type = to_type_symbol(c)
+          types << type
+        end
+
+        if optimistic
+
+          for c in columns
+            type = to_type_symbol(c)
+            types << type
+            types << type if c.null
+          end
+
+        else
+
+          keys = primary_key_columns
+
+          for c in keys
+            type = to_type_symbol(c)
+            types << type
+          end
+
+        end
+
+        values = []
+
+        keys = primary_key_columns
+
+        for record in group
+          row = []
+
+          for c in columns
+            v = record.read_attribute(c.name)
+            row << v
+          end
+
+          if optimistic
+
+            orginal = record.orginal_selected_record            
+            for c in columns
+
+              v = orginal[ c.name]
+              row << v
+              row << v if c.null
+
+            end
+
+          else
+
+            keys.each { |c| row << record[ c.name] }
+
+          end
+
+          values << row
+
+        end
+
+        count = execute_batch_update(sql, types, values, optimistic)
+
+        count
+      end
+
+      public
+      def insert_on_missing_group( keys, group, options = {} )
+
+        #fail 'the give key array is empty' if keys.empty?
+
+        keys = Array( primary_key ) if keys.nil? || keys.empty?
+
+        sql ="  
+        merge into #{table_name} target 
+        using ( select #{columns.map{|c| ":#{columns.index(c)+1} #{c.name}" }.join(', ')} from dual ) source 
+        on ( #{keys.map{|c| "target.#{c} = source.#{c}" }.join(' and ')}  ) 
+        when not matched then 
+        insert ( #{columns.map{|c| c.name }.join(', ')} )  
+        values( #{columns.map{|c| "source.#{c.name}" }.join(', ')} )
+        "
+
+
+        types = columns.map{ |c| to_type_symbol(c) }
+
+        values = []
+
+        for record in group
+
+          row = []
+
+          for c in columns
+            v = record.read_attribute(c.name)
+            row << v
+          end
+
+          values << row
+
+        end
+
+        begin
+          result = execute_batch_update(sql, types, values,false)
+        rescue  => e
+          raise ActiveRecord::StatementInvalid.new( "#{e.message}\n#{sql}" )
+        end
+
+        group.each { |r| r.unset_new_record }
+
+        result
+
+      end
+      
+      def delete_group(group, options = {})
+        check_group(group)
+
+        optimistic = options[:optimistic]
+        optimistic = true if optimistic.nil?
+
+        to_delete = group.select { |i| not i.new_record? }
+
+        fail NoOrginalRecordFound.new if optimistic and not to_delete.select { |i| not i.orginal_selected_record }.empty?
+
+        sql = optimistic ? build_optimistic_delete_sql : build_delete_by_primary_key_sql
+
+        types  = []
+
+        if optimistic
+
+          for c in columns
+            type = to_type_symbol(c)
+            types << type
+            types << type if c.null
+          end
+
+        else
+
+          keys = primary_key_columns
+
+          for c in keys
+            type = to_type_symbol(c)
+            types << type
+          end
+
+        end
+
+        values = []
+
+        if optimistic
+
+          for record in to_delete
+            row = []
+            orginal = record.orginal_selected_record
+            for c in columns
+
+              v = orginal[  c.name]
+              row << v
+              row << v if c.null
+
+            end
+
+            values << row
+
+          end
+
+        else
+
+          keys = primary_key_columns
+
+          for record in to_delete
+            row = keys.map { |c| record[ c.name] }
+            values << row
+          end
+
+        end
+
+        count = execute_batch_update(sql, types, values, optimistic)
+
+        count
+
+      rescue ExternalDataChange => e
+        raise e
+      rescue Exception => e
+        raise StatementError.new("#{sql} #{e.message}")
+      end
+
+    end
+  end
+end

data/lib/activerecord_bulkoperation/group_operations_select.rb

@@ -0,0 +1,60 @@
+module ActiveRecord
+  class Base
+
+    class << self
+
+      # old style group find like PItem.find_group_by( :i_company => [45,45,45], :i_itemno => [1,2,3], :i_size => [0,0,0] )
+      # leads to a sql statement in the form of 'SELECT * FROM table WHERE ((i_company, i_itemno, i_size) IN ((45, 1, 0), (45, 2, 0), (45, 3, 0)))'
+
+      def find_group_by(args)
+        fail 'no hash given, use Table.all() instead' if args.nil? || args.empty? || (not args.is_a?(Hash))
+        fail 'args is not a hash of arrays' if args.select { |k,v| k.is_a?(Symbol) || v.is_a?(Array) }.size != args.size
+        
+        conditions = ( args.is_a?(Hash) && args[:conditions] ) || args  
+        tuple_size = conditions.size
+        array_size = 0
+        conditions.each do |k,v|
+          array_size = v.size unless array_size > 0
+          fail 'not all arrays are of the same size' unless v.size == array_size
+        end
+
+        symbols = conditions.keys
+        values = Array.new(array_size) { Array.new(tuple_size) }
+
+        # to recurse is golden, to transpose ... divine!
+        i = 0
+        (array_size*tuple_size).times do
+          values[i/tuple_size][i%tuple_size] = conditions.values[i%tuple_size][i/tuple_size]
+          i += 1
+        end
+
+        return where_tuple(symbols, values)
+      end
+
+      # not really compatible to the rest of ActiveRecord but it works
+      # provide parameters like this: symbols_tuple = [ :col1, :col2, :col3 ]
+      # and values_tuples = [ [1, 4, 7], [2, 5, 8], [3, 6, 9]]
+      def where_tuple(symbols_tuple, values_tuples)
+        if symbols_tuple.nil? || symbols_tuple.size == 0 || (not symbols_tuple.is_a?(Array)) || (not symbols_tuple.select { |s| not s.is_a?(Symbol) }.empty?)
+          fail 'no symbols given or not every entry is a symbol'
+        end
+
+        tuple_size = symbols_tuple.size
+        #fail "don't use this method if you're not looking for tuples." if tuple_size < 2
+
+        if values_tuples.nil? || values_tuples.size == 0 || (not values_tuples.is_a?(Array)) || (not values_tuples.select { |s| not s.is_a?(Array) }.empty?)
+          fail 'no values given or not every value is an array'
+        end
+
+        tuple_part = "(#{(['?']*tuple_size).join(',')})"
+        in_stmt = "(#{([tuple_part]*values_tuples.size).join(', ')})"
+        stmt = "(#{symbols_tuple.map { |sym| sym.to_s }.join(', ')}) IN #{in_stmt}"
+
+        res = where(stmt, *(values_tuples.flatten!))
+
+        return res
+      end
+
+    end # end of class << self
+  end # end of class Base
+end

data/lib/activerecord_bulkoperation/util/connection_object.rb

@@ -0,0 +1,22 @@
+# A ConnectionObject belongs to a connection. It's like a singleton for each connection.
+#
+# Author:: Andre Kullmann
+#
+class ConnectionObject
+  def self.get
+    result = ActiveRecord::Base.connection.connection_listeners.select { |l| l.class == self }.first
+    unless result
+      result = new
+      ActiveRecord::Base.connection.connection_listeners << result
+    end
+    result
+  end
+
+  def before_close
+    close
+    ActiveRecord::Base.connection.connection_listeners.delete(self)
+  end
+
+  def close
+  end
+end

data/lib/activerecord_bulkoperation/util/entity_hash.rb

@@ -0,0 +1,78 @@
+#  
+#
+# Author:: Andre Kullmann
+#
+module ActiveRecord
+  module Bulkoperation
+    module Util
+      class EntityHash < Hash  
+        
+        def each_pair_in_detail_hierarchy(&block)
+          visited = []
+
+          each_pair do |k, v|
+
+            next if visited.include?(k)
+
+            in_detail_hierarchy(k, visited, &block)
+
+          end
+        end
+        
+        def each_pair_in_master_hierarchy(&block)
+          visited = []
+
+          each_pair do |k, v|
+
+            next if visited.include?(k)
+
+            in_master_hierarchy(k, visited, &block)
+
+          end
+        end
+
+        private
+
+        def in_detail_hierarchy(record_class, visited, &block)
+          return if visited.include?(record_class)
+
+          visited << record_class
+
+          record_class.foreign_detail_tables.each do |table_name|
+
+            if key = find_key_by_table_name(table_name)
+
+              in_detail_hierarchy(key, visited, &block)
+            end
+          end
+
+          list = self[ record_class] and yield record_class, list
+        end
+
+        def in_master_hierarchy(record_class, visited, &block)
+          return if visited.include?(record_class)
+
+          visited << record_class
+
+          record_class.foreign_master_tables.each do |table_name|
+
+            if key = find_key_by_table_name(table_name)
+
+              in_master_hierarchy(key, visited, &block)
+            end
+          end
+
+          list = self[ record_class] and yield record_class, list
+        end
+      
+        def find_key_by_table_name(table_name)
+          name = table_name.upcase
+          result = keys.select { |k| k.table_name.upcase == name }
+          fail '' if result.size > 1
+          result.first
+        end
+
+      end
+    end
+  end
+end