activerecord_bulkoperation 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f75f024004e8d891bd6c3723026f673dca6cf2085726f98971477ab65016516a
+  data.tar.gz: 629f7ed52ea5a51855766b0151bcfc3a77aed7239d6981a9a10b63f4c7f0ada6
+SHA512:
+  metadata.gz: d652595ee6fc44e055e52e3a53761388d07de4c05832344b993e1674e55574c795dc12c2805f5ea045191cd5d899e3072960d8e17aeae67d15dd4cb9c30eab52
+  data.tar.gz: b47a322b80820779c0b62c527ab572e0ede06c7a6c36a5ca195cc1b9ab22226a57b9d298639c738ce2e3ea0e21066e02def2d57b15d1c766fabacd65738e9055

data/.gitignore

@@ -0,0 +1 @@
+log

data/.ruby-version

@@ -0,0 +1 @@
+2.2.3

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+#gemspec
+
+version = ENV['AR_VERSION'] || "4.2"
+
+if version > "4.0"
+  gem "minitest"
+end
+
+gem 'mocha'
+
+eval_gemfile File.expand_path("../gemfiles/#{version}.gemfile", __FILE__)

data/README.md

@@ -0,0 +1 @@
+# activerecord_bulkoperation

data/Rakefile

@@ -0,0 +1,25 @@
+require "bundler"
+Bundler.setup
+
+require 'rake'
+require 'rake/testtask'
+
+namespace :display do
+  task :notice do
+    puts
+    puts "To run tests you must supply the adapter, see rake -T for more information."
+    puts
+  end
+end
+task :default => ["display:notice"]
+
+ADAPTERS = %w(oracle_enhanced)
+ADAPTERS.each do |adapter|
+  namespace :test do
+    desc "Runs #{adapter} database tests."
+    Rake::TestTask.new(adapter) do |t|
+      t.test_files = FileList["test/adapters/#{adapter}.rb", "test/*_test.rb", "test/active_record/*_test.rb", "test/#{adapter}/**/*_test.rb"]
+    end
+    task adapter
+  end
+end

data/activerecord_bulkoperation.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/activerecord_bulkoperation/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["OSP"]
+  gem.email         = [""]
+  gem.summary       = ""
+  gem.description   = ""
+  gem.homepage      = ""
+  gem.license       = "Ruby"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "activerecord_bulkoperation"
+  gem.require_paths = ["lib"]
+  gem.version       = ActiveRecord::Bulkoperation::VERSION
+
+  gem.required_ruby_version = ">= 1.9.2"
+
+  gem.add_runtime_dependency "activerecord", "~> 4.2"
+  gem.add_development_dependency "rake"
+end

data/gemfiles/4.2.gemfile

@@ -0,0 +1,14 @@
+gem 'activerecord-oracle_enhanced-adapter', '~> 1.6.0'
+
+# a warning will be emitted when the same gems are put in more than one platform
+# but it will still lead to errors if they are missing in either
+platforms :ruby do
+  #gem 'mysql',        '~> 2.9'
+  gem 'ruby-oci8', '~> 2.1'
+end
+
+platforms :jruby do
+  gem 'activerecord-jdbc-adapter' #, '~> 1.3.0'
+end
+
+gem 'activerecord', '~> 4.2'

data/lib/activerecord_bulkoperation.rb

@@ -0,0 +1,20 @@
+#
+#
+#
+class ActiveRecord::Base
+  class << self
+    def establish_connection_with_activerecord_bulkoperation(*args)
+      establish_connection_without_activerecord_bulkoperation(*args)
+      ActiveSupport.run_load_hooks(:active_record_connection_established, connection_pool)
+    end
+    alias_method_chain :establish_connection, :activerecord_bulkoperation
+  end
+end
+
+ActiveSupport.on_load(:active_record_connection_established) do |connection_pool|
+  if !ActiveRecord.const_defined?(:Bulkoperation, false) || !ActiveRecord::Bulkoperation.respond_to?(:load_from_connection_pool)
+    require 'activerecord_bulkoperation/base'
+  end
+
+  ActiveRecord::Bulkoperation.load_from_connection_pool connection_pool
+end

data/lib/activerecord_bulkoperation/active_record/adapters/abstract_adapter.rb

@@ -0,0 +1,49 @@
+require "activerecord_bulkoperation/adapters/abstract_adapter"
+
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+
+    class ConnectionPool
+
+      alias_method :super_initialize, :initialize
+      def initialize(spec)
+        super_initialize(spec)
+        @timeout = 5
+      end
+
+      def log
+        ActiveRecord::Base.logger
+      end
+
+      def set_connection(connection)
+        id   = ActiveRecord::Base.connection_pool.send :current_connection_id
+        hash = ActiveRecord::Base.connection_pool.instance_variable_get('@reserved_connections')
+        hash[id] = connection
+      end
+
+      def get_connection
+        id   = ActiveRecord::Base.connection_pool.send :current_connection_id
+        hash = ActiveRecord::Base.connection_pool.instance_variable_get('@reserved_connections')
+        hash[id]
+      end
+
+      # after checkout clear the scheduled operation if necessary
+      alias_method :super_checkout, :checkout
+      def checkout
+        @timeout = 5
+        connection = super_checkout
+        connection.clear_scheduled_operations if connection.respond_to?('clear_scheduled_operations')
+        connection
+      end
+
+      # before checkout clear the scheduled operation if necessary
+      alias_method :super_checkin, :checkin
+      def checkin(connection)
+        connection.clear_scheduled_operations if connection.respond_to?('clear_scheduled_operations')
+        connection.connection_listeners.each { |l| l.before_close if l.respond_to?('before_close') } if connection.respond_to?('connection_listeners')
+        super_checkin(connection)
+      end
+
+    end
+  end
+end

data/lib/activerecord_bulkoperation/active_record/adapters/oracle_enhanced_adapter.rb

@@ -0,0 +1,10 @@
+require 'activerecord_bulkoperation/adapters/oracle_enhanced_adapter'
+
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    class OracleEnhancedAdapter # :nodoc:
+      include ActiveRecord::Bulkoperation::OracleEnhancedAdapter
+      include ActiveRecord::Bulkoperation::AbstractAdapter::InstanceMethods
+    end
+  end
+end

data/lib/activerecord_bulkoperation/active_record/associations/associations.rb

@@ -0,0 +1,169 @@
+require 'active_record/associations'
+
+module ActiveRecord
+
+  module Persistence
+    module ClassMethods
+
+        alias_method :instantiate_without_save_original, :instantiate
+
+        def instantiate(attributes, column_types = {})
+          record = instantiate_without_save_original(attributes, column_types)
+          record.save_original
+          record
+        end
+    end
+  end
+
+  module Associations
+
+    module ManyToManyTables
+    end
+
+    class CollectionProxy       
+      
+      def schedule_merge(record)        
+        options = proxy_association.reflection.options
+        macro = proxy_association.reflection.macro
+        if(proxy_association.is_a?(ActiveRecord::Associations::HasManyThroughAssociation))
+          handle_has_many_through_schedule_merge(record)
+          return
+        end  
+        if(macro == :has_many)
+          handle_has_many_schedule_merge(record)
+          return
+        end      
+      end
+
+      def handle_has_many_schedule_merge(record)
+        pk = proxy_association.reflection.options[:primary_key] || proxy_association.owner.class.primary_key
+        fk = proxy_association.reflection.options[:foreign_key] || "#{proxy_association.owner.class.to_s.underscore.downcase}_id"
+        if(pk.is_a?(Array))
+          #puts "is a array"
+          pk.each do |pk_item|
+            pk_item_val = proxy_association.owner[pk_item.to_s]
+            record.send("#{pk_item.to_s}=",pk_item_val)
+          end
+        else
+          pk_val = proxy_association.owner[pk.to_s]        
+          record.send("#{fk}=",pk_val) 
+        end
+        
+        record.schedule_merge
+        self << record
+      end
+
+      def parent_reflection
+        proxy_association.reflection.parent_reflection[1]
+      end
+
+      def get_m_t_m_table_name
+        parent_reflection.options[:join_table] || [proxy_association.owner.class.table_name,proxy_association.klass.table_name].sort.join('_')
+      end
+
+      def parent_pk
+        parent_reflection.options[:primary_key] || proxy_association.owner.class.primary_key
+      end
+
+      def parent_association_pk
+        parent_reflection.options[:association_primary_key] || "#{proxy_association.owner.class.to_s.underscore.downcase}_id"
+      end
+
+      def child_pk
+        parent_reflection.options[:foreign_key] || proxy_association.klass.primary_key
+      end
+
+      def child_association_pk
+        parent_reflection.options[:association_foreign_key] || "#{proxy_association.klass.to_s.underscore.downcase}_id"
+      end
+      
+      #TODO remove
+      alias_method :count_without_merges, :count
+      def count
+        count_without_merges + ( @internal_new_count.to_i)
+      end
+      
+      def handle_has_many_through_schedule_merge(record)        
+     # TODO AK doesn't work well 
+        self << record 
+        
+=begin
+        join_model = Class.new(ActiveRecord::Base) do
+          class << self;           
+            attr_accessor :table_info
+          end
+          def self.table_name
+            table_info.table_name
+          end
+        end
+        join_model.table_info = OpenStruct.new(:table_name => get_m_t_m_table_name)        
+        unless(ManyToManyTables.const_defined?(get_m_t_m_table_name.camelize))
+          ManyToManyTables.const_set get_m_t_m_table_name.camelize,join_model
+        end
+        #puts "RP DEBUG child_pk: #{child_pk} parent_pk: #{parent_pk}"
+        #puts "RP DEBUG child_association_pk: #{child_association_pk} parent_association_pk: #{parent_association_pk}"
+        #puts "RP DEBUG table_name: #{get_m_t_m_table_name}"
+        c = ManyToManyTables.const_get get_m_t_m_table_name.camelize
+        record.schedule_merge
+        obj = c.new
+        puts "AK: #{obj.class.name}"
+        puts "AK: #{obj.class.name}.#{child_association_pk} = #{proxy_association.owner.class.name}.#{parent_pk} #{proxy_association.owner.send(parent_pk)}" 
+        puts "AK: #{obj.class.name}.#{child_association_pk} = #{record.class.name}.#{parent_association_pk} #{record.send(parent_association_pk)}" 
+        obj.send("#{parent_association_pk}=", proxy_association.owner.send(parent_pk))
+        obj.send("#{child_association_pk}=" , record.send(parent_association_pk))
+        obj.schedule_merge
+        pp obj
+        @internal_new_count ||= 0 
+        @internal_new_count += 1
+=end
+      end
+
+    end
+
+    class JoinDependency # :nodoc:
+
+        def instantiate_each(row, &block)
+          if row
+            primary_id = join_base.record_id(row)
+            unless @base_records_hash[primary_id]
+              if @base_records_in_order.size > 0
+                yield @base_records_in_order.first
+                # Die Theorie ist hier ein primary_key der Haupttabelle
+                # ist verarbeitet und nun kann der Satz entsorgt werden.
+                @base_records_in_order.pop
+                # instatiate_each nicht das gesamte Ergebnis durchsucht,
+                # wird @base_record_hash nur fuer den Gruppenwechsel
+                # verwendet.
+                # Bei einem neuen primary_key wird der Hash geleert.
+                @base_records_hash = {}
+                # record cache leeren
+                # join_base.cached_record = {}
+                @joins.each { |j| j.cached_record = {} }
+              end
+              #RP TODO check if instantiate call is correct with an empty hash or where to get the 2nd parameter
+              @base_records_in_order << (@base_records_hash[primary_id] = join_base.instantiate(row,{}))
+            end
+            construct(@base_records_hash[primary_id], @associations, join_associations.dup, row)
+          else
+            yield @base_records_in_order.first
+          end
+        end
+
+      class JoinBase 
+        attr_accessor :cached_record
+        def extract_record(row,column_names_with_alias)
+          # if the :select option is set, only the selected field should be extracted
+          # column_names_with_alias.inject({}){|record, (cn, an)| record[cn] = row[an] if row.has_key?(an); record}
+          record = {}
+          column_names_with_alias.each { |(cn, an)| record[cn] = row[an] if row.key?(an) }
+          record
+        end
+        alias_method :instantiate_without_save_original, :instantiate        
+        def instantiate(row, aliases)          
+          instantiate_without_save_original(row, aliases)
+        end
+      end
+    end
+  end
+end
+

data/lib/activerecord_bulkoperation/adapters/abstract_adapter.rb

@@ -0,0 +1,43 @@
+module ActiveRecord
+  module Bulkoperation
+    module AbstractAdapter
+      module InstanceMethods
+
+        def self.included(base)
+          base.class_eval do
+            alias_method :commit_db_transaction_without_callback, :commit_db_transaction
+            alias_method :rollback_db_transaction_without_callback, :rollback_db_transaction
+            alias_method :rollback_to_savepoint_without_callback, :rollback_to_savepoint
+            alias_method :create_savepoint_without_callback, :create_savepoint
+
+            def commit_db_transaction
+              connection_listeners.each { |l| l.before_commit if l.respond_to?('before_commit') }          
+              commit_db_transaction_without_callback
+              connection_listeners.each { |l| l.after_commit if l.respond_to?('after_commit') }
+            end
+            
+            def rollback_db_transaction
+              rollback_db_transaction_without_callback
+              connection_listeners.each { |l| l.after_rollback if l.respond_to?('after_rollback') }
+            end
+                    
+            def rollback_to_savepoint(name = current_savepoint_name)
+              rollback_to_savepoint_without_callback(name)
+              connection_listeners.each { |l| l.after_rollback_to_savepoint if l.respond_to?('after_rollback_to_savepoint') }
+            end
+                    
+            def create_savepoint(name = current_savepoint_name)
+              connection_listeners.each { |l| l.before_create_savepoint if l.respond_to?('before_create_savepoint') }
+              create_savepoint_without_callback(name)
+            end
+          end
+        end
+
+        def connection_listeners
+          @connection_listeners ||= []
+        end
+         
+      end
+    end
+  end  
+end

data/lib/activerecord_bulkoperation/adapters/oracle_enhanced_adapter.rb

@@ -0,0 +1,44 @@
+module ActiveRecord
+  module Bulkoperation
+    module OracleEnhancedAdapter
+  
+      def find_foreign_master_tables_sql_array(table_name)
+        sql = "select
+                 m.table_name
+               from
+                 user_constraints m join user_constraints d on (m.constraint_name = d.r_constraint_name)
+               where
+                 d.table_name = ?"
+        [sql, table_name.upcase]
+      end
+
+      def find_foreign_detail_tables_sql_array(table_name)
+        sql = "select
+                 d.table_name
+               from
+                 user_constraints m join user_constraints d on (m.constraint_name = d.r_constraint_name)
+               where
+             m.table_name = ?"
+        [sql, table_name.upcase]
+      end
+
+      def find_detail_references_sql_array(table_name)
+        sql = "select
+          m.table_name master_table,
+          ( select listagg( column_name, ',' ) within group (order by position) from user_cons_columns where constraint_name = m.constraint_name ) master_columns,
+          d.table_name detail_table,
+          ( select listagg( column_name, ',' ) within group (order by position) from user_cons_columns where constraint_name = d.constraint_name ) detail_columns
+          from
+          user_constraints m join user_constraints d on( m.constraint_name = d.r_constraint_name )
+          where m.table_name = ?"
+        [sql, table_name.upcase]
+      end
+
+      def find_by_sequence_name_sql_array(name)
+        sql = 'select * from user_sequences where sequence_name = ?'
+        [sql, name.upcase]
+      end
+
+    end
+  end
+end

data/lib/activerecord_bulkoperation/base.rb

@@ -0,0 +1,53 @@
+module ActiveRecord
+  module Bulkoperation
+    AdapterPath = 'activerecord_bulkoperation/active_record/adapters'
+
+    def self.base_adapter(adapter)
+      case adapter
+      when 'mysqlspatial' then 'mysql'
+      when 'mysql2spatial' then 'mysql2'
+      when 'spatialite' then 'sqlite3'
+      when 'oracle_enhanced' then 'oracle_enhanced'
+      else adapter
+      end
+    end
+
+    # Loads the import functionality for a specific database adapter
+    def self.require_adapter(adapter)
+      require File.join(AdapterPath,'/abstract_adapter')
+      begin
+        require File.join(AdapterPath,"/#{base_adapter(adapter)}_adapter")
+      rescue LoadError
+        # fallback
+      end
+    end
+
+    # Loads the import functionality for the passed in ActiveRecord connection
+    def self.load_from_connection_pool(connection_pool)
+      require_adapter connection_pool.spec.config[:adapter]
+    end
+  end
+end
+
+# if MRI or YARV
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
+  ORACLE_ENHANCED_CONNECTION = :oci if ORACLE_ENHANCED_CONNECTION != :oci
+  require 'activerecord_bulkoperation/connection_adapters/oracle_enhanced/oci_connection'
+# if JRuby
+elsif RUBY_ENGINE == 'jruby'
+  ORACLE_ENHANCED_CONNECTION = :jdbc if ORACLE_ENHANCED_CONNECTION != :jdbc
+  require 'activerecord_bulkoperation/connection_adapters/oracle_enhanced/jdbc_connection'
+else
+  raise "Unsupported Ruby engine #{RUBY_ENGINE}"
+end
+
+require 'activerecord_bulkoperation/bulkoperation'
+require 'activerecord_bulkoperation/active_record/associations/associations'
+require 'activerecord_bulkoperation/group_operations'
+require 'activerecord_bulkoperation/group_operations_select'
+require 'activerecord_bulkoperation/util/sequence_cache'
+require 'activerecord_bulkoperation/util/entity_hash'
+require 'activerecord_bulkoperation/util/transaction_object'
+require 'activerecord_bulkoperation/util/connection_object'
+require 'activerecord_bulkoperation/util/flush_dirty_objects'
+