database_cleaner-active_record 1.99.0 → 2.1.0

data/lib/database_cleaner/active_record/deletion.rb

@@ -1,107 +1,70 @@
 require 'active_record'
-require 'active_record/connection_adapters/abstract_adapter'
-require "database_cleaner/generic/truncation"
 require 'database_cleaner/active_record/truncation'
 
 module DatabaseCleaner
-  module ConnectionAdapters
-    module AbstractDeleteAdapter
-      def delete_table(table_name)
-        raise NotImplementedError
+  module ActiveRecord
+    class Deletion < Truncation
+      def clean
+        connection.disable_referential_integrity do
+          if pre_count? && connection.respond_to?(:pre_count_tables)
+            delete_tables(connection, connection.pre_count_tables(tables_to_truncate(connection)))
+          else
+            delete_tables(connection, tables_to_truncate(connection))
+          end
+        end
       end
-    end
 
-    module GenericDeleteAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
+      private
 
-    module OracleDeleteAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)}")
+      def delete_tables(connection, table_names)
+        table_names.each do |table_name|
+          delete_table(connection, table_name)
+        end
       end
-    end
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    AbstractAdapter.class_eval { include DatabaseCleaner::ConnectionAdapters::AbstractDeleteAdapter }
-
-    JdbcAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(JdbcAdapter)
-    AbstractMysqlAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(AbstractMysqlAdapter)
-    Mysql2Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(Mysql2Adapter)
-    SQLiteAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(SQLiteAdapter)
-    SQLite3Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(SQLite3Adapter)
-    PostgreSQLAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(PostgreSQLAdapter)
-    IBM_DBAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(IBM_DBAdapter)
-    SQLServerAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(SQLServerAdapter)
-    OracleEnhancedAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::OracleDeleteAdapter } if defined?(OracleEnhancedAdapter)
-  end
-end
 
-module DatabaseCleaner::ActiveRecord
-  module SelectiveTruncation
-    def tables_to_truncate(connection)
-      if information_schema_exists?(connection)
-        (@only || tables_with_new_rows(connection)) - @tables_to_exclude
-      else
-        super
+      def delete_table connection, table_name
+        connection.execute("DELETE FROM #{connection.quote_table_name(table_name)} WHERE 1=1")
       end
-    end
 
-    def tables_with_new_rows(connection)
-      stats = table_stats_query(connection)
-      if stats != ''
-        connection.select_values(stats)
-      else
-        []
+      def tables_to_truncate(connection)
+        if information_schema_exists?(connection)
+          @except += connection.database_cleaner_view_cache + migration_storage_names
+          (@only.any? ? @only : tables_with_new_rows(connection)) - @except
+        else
+          super
+        end
       end
-    end
 
-    def table_stats_query(connection)
-      @table_stats_query ||= build_table_stats_query(connection)
-    ensure
-      @table_stats_query = nil unless @cache_tables
-    end
+      def tables_with_new_rows(connection)
+        stats = table_stats_query(connection)
+        if stats != ''
+          connection.select_values(stats)
+        else
+          []
+        end
+      end
 
-    def build_table_stats_query(connection)
-      tables = connection.select_values(<<-SQL)
-        SELECT table_name
-        FROM information_schema.tables
-        WHERE table_schema = database()
-        AND #{::DatabaseCleaner::ActiveRecord::Base.exclusion_condition('table_name')};
-      SQL
-      queries = tables.map do |table|
-        "(SELECT #{connection.quote(table)} FROM #{connection.quote_table_name(table)} LIMIT 1)"
+      def table_stats_query(connection)
+        @table_stats_query ||= build_table_stats_query(connection)
+      ensure
+        @table_stats_query = nil unless @cache_tables
       end
-      queries.join(' UNION ALL ')
-    end
 
-    def information_schema_exists? connection
-      return false unless connection.is_a? ActiveRecord::ConnectionAdapters::Mysql2Adapter
-      @information_schema_exists ||=
-        begin
-          connection.execute("SELECT 1 FROM information_schema.tables")
-          true
-        rescue
-          false
+      def build_table_stats_query(connection)
+        tables = connection.select_values(<<-SQL)
+          SELECT table_name
+          FROM information_schema.tables
+          WHERE table_schema = database()
+          AND #{self.class.exclusion_condition('table_name')};
+        SQL
+        queries = tables.map do |table|
+          "(SELECT #{connection.quote(table)} FROM #{connection.quote_table_name(table)} LIMIT 1)"
         end
-    end
-  end
-
-  class Deletion < Truncation
-    if defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
-      include SelectiveTruncation
-    end
+        queries.join(' UNION ALL ')
+      end
 
-    def clean
-      connection = connection_class.connection
-      connection.disable_referential_integrity do
-        tables_to_truncate(connection).each do |table_name|
-          connection.delete_table table_name
-        end
+      def information_schema_exists? connection
+        connection.adapter_name == "Mysql2"
       end
     end
   end

data/lib/database_cleaner/active_record/transaction.rb

@@ -1,59 +1,22 @@
 require 'database_cleaner/active_record/base'
-require 'database_cleaner/generic/transaction'
 
-module DatabaseCleaner::ActiveRecord
-  class Transaction
-    include ::DatabaseCleaner::ActiveRecord::Base
-    include ::DatabaseCleaner::Generic::Transaction
+module DatabaseCleaner
+  module ActiveRecord
+    class Transaction < Base
+      def start
+        # Hack to make sure that the connection is properly set up before cleaning
+        connection_class.connection.transaction {}
 
-    def start
-      # Hack to make sure that the connection is properly setup for
-      # the clean code.
-      connection_class.connection.transaction{ }
-
-      if connection_maintains_transaction_count?
-        if connection_class.connection.respond_to?(:increment_open_transactions)
-          connection_class.connection.increment_open_transactions
-        else
-          connection_class.__send__(:increment_open_transactions)
-        end
-      end
-      if connection_class.connection.respond_to?(:begin_transaction)
-        connection_class.connection.begin_transaction :joinable => false
-      else
-        connection_class.connection.begin_db_transaction
+        connection_class.connection.begin_transaction joinable: false
       end
-    end
-
 
-    def clean
-      connection_class.connection_pool.connections.each do |connection|
-        next unless connection.open_transactions > 0
 
-        if connection.respond_to?(:rollback_transaction)
+      def clean
+        connection_class.connection_pool.connections.each do |connection|
+          next unless connection.open_transactions > 0
           connection.rollback_transaction
-        else
-          connection.rollback_db_transaction
-        end
-
-        # The below is for handling after_commit hooks.. see https://github.com/bmabey/database_cleaner/issues/99
-        if connection.respond_to?(:rollback_transaction_records, true)
-          connection.send(:rollback_transaction_records, true)
-        end
-
-        if connection_maintains_transaction_count?
-          if connection.respond_to?(:decrement_open_transactions)
-            connection.decrement_open_transactions
-          else
-            connection_class.__send__(:decrement_open_transactions)
-          end
         end
       end
     end
-
-    def connection_maintains_transaction_count?
-      ActiveRecord::VERSION::MAJOR < 4
-    end
-
   end
 end