database_cleaner-active_record 1.8.0 → 2.0.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)}")
       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

data/lib/database_cleaner/active_record/truncation.rb

@@ -1,278 +1,249 @@
+require "delegate"
 require 'active_record/base'
 require 'database_cleaner/active_record/base'
-require 'active_record/connection_adapters/abstract_adapter'
-
-#Load available connection adapters
-%w(
-  abstract_mysql_adapter postgresql_adapter sqlite3_adapter mysql_adapter mysql2_adapter oracle_enhanced_adapter
-).each do |known_adapter|
-  begin
-    require "active_record/connection_adapters/#{known_adapter}"
-  rescue LoadError
-  end
-end
-
-require "database_cleaner/generic/truncation"
-require 'database_cleaner/active_record/base'
 
 module DatabaseCleaner
-  module ConnectionAdapters
-
-    module AbstractAdapter
-      # used to be called views but that can clash with gems like schema_plus
-      # this gem is not meant to be exposing such an extra interface any way
-      def database_cleaner_view_cache
-        @views ||= select_values("select table_name from information_schema.views where table_schema = '#{current_database}'") rescue []
-      end
-
-      def database_cleaner_table_cache
-        # the adapters don't do caching (#130) but we make the assumption that the list stays the same in tests
-        @database_cleaner_tables ||= database_tables
-      end
-
-      def database_tables
-        ::ActiveRecord::VERSION::MAJOR >= 5 ? data_sources : tables
-      end
-
-      def truncate_table(table_name)
-        raise NotImplementedError
-      end
-
-      def truncate_tables(tables)
-        tables.each do |table_name|
-          self.truncate_table(table_name)
+  module ActiveRecord
+    class Truncation < Base
+      def initialize(opts={})
+        if !opts.empty? && !(opts.keys - [:only, :except, :pre_count, :cache_tables]).empty?
+          raise ArgumentError, "The only valid options are :only, :except, :pre_count, and :cache_tables. You specified #{opts.keys.join(',')}."
         end
-      end
-    end
 
-    module AbstractMysqlAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
-      end
+        @only = Array(opts[:only]).dup
+        @except = Array(opts[:except]).dup
 
-      def truncate_tables(tables)
-        tables.each { |t| truncate_table(t) }
+        @pre_count = opts[:pre_count]
+        @cache_tables = opts.has_key?(:cache_tables) ? !!opts[:cache_tables] : true
       end
 
-      def pre_count_truncate_tables(tables, options = {:reset_ids => true})
-        filter = options[:reset_ids] ? method(:has_been_used?) : method(:has_rows?)
-        truncate_tables(tables.select(&filter))
+      def clean
+        connection.disable_referential_integrity do
+          if pre_count? && connection.respond_to?(:pre_count_truncate_tables)
+            connection.pre_count_truncate_tables(tables_to_truncate(connection))
+          else
+            connection.truncate_tables(tables_to_truncate(connection))
+          end
+        end
       end
 
       private
 
-      def row_count(table)
-        # Patch for MysqlAdapter with ActiveRecord 3.2.7 later
-        # select_value("SELECT 1") #=> "1"
-        select_value("SELECT EXISTS (SELECT 1 FROM #{quote_table_name(table)} LIMIT 1)").to_i
+      def connection
+        @connection ||= ConnectionWrapper.new(connection_class.connection)
       end
 
-      def auto_increment_value(table)
-        select_value(<<-SQL).to_i
-          SELECT auto_increment
-          FROM information_schema.tables
-          WHERE table_name = '#{table}'
-          AND table_schema = database()
-        SQL
+      def tables_to_truncate(connection)
+        if @only.none?
+          all_tables = cache_tables? ? connection.database_cleaner_table_cache : connection.database_tables
+          @only = all_tables.map { |table| table.split(".").last }
+        end
+        @except += connection.database_cleaner_view_cache + migration_storage_names
+        @only - @except
       end
 
-      # This method tells us if the given table has been inserted into since its
-      # last truncation. Note that the table might have been populated, which
-      # increased the auto-increment counter, but then cleaned again such that
-      # it appears empty now.
-      def has_been_used?(table)
-        has_rows?(table) || auto_increment_value(table) > 1
+      def migration_storage_names
+        [
+          DatabaseCleaner::ActiveRecord::Base.migration_table_name,
+          ::ActiveRecord::Base.internal_metadata_table_name,
+        ]
       end
 
-      def has_rows?(table)
-        row_count(table) > 0
+      def cache_tables?
+        !!@cache_tables
       end
-    end
 
-    module IBM_DBAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE #{quote_table_name(table_name)} IMMEDIATE")
+      def pre_count?
+        @pre_count == true
       end
     end
 
-    module SQLiteAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-        if uses_sequence
-          execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
+    class ConnectionWrapper < SimpleDelegator
+      def initialize(connection)
+        extend AbstractAdapter
+        case connection.adapter_name
+        when "Mysql2"
+          extend AbstractMysqlAdapter
+        when "SQLite"
+          extend AbstractMysqlAdapter
+          extend SQLiteAdapter
+        when "PostgreSQL"
+          extend AbstractMysqlAdapter
+          extend PostgreSQLAdapter
         end
+        super(connection)
       end
-      alias truncate_table delete_table
 
-      def truncate_tables(tables)
-        tables.each { |t| truncate_table(t) }
-      end
+      module AbstractAdapter
+        # used to be called views but that can clash with gems like schema_plus
+        # this gem is not meant to be exposing such an extra interface any way
+        def database_cleaner_view_cache
+          @views ||= select_values("select table_name from information_schema.views where table_schema = '#{current_database}'") rescue []
+        end
 
-      private
+        def database_cleaner_table_cache
+          # the adapters don't do caching (#130) but we make the assumption that the list stays the same in tests
+          @database_cleaner_tables ||= database_tables
+        end
 
-      # Returns a boolean indicating if the SQLite database is using the sqlite_sequence table.
-      def uses_sequence
-        select_value("SELECT name FROM sqlite_master WHERE type='table' AND name='sqlite_sequence';")
-      end
-    end
+        def database_tables
+          tables
+        end
 
-    module TruncateOrDelete
-      def truncate_table(table_name)
-        begin
-          execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
+        def truncate_table(table_name)
+          execute("TRUNCATE TABLE #{quote_table_name(table_name)}")
         rescue ::ActiveRecord::StatementInvalid
-          execute("DELETE FROM #{quote_table_name(table_name)};")
+          execute("DELETE FROM #{quote_table_name(table_name)}")
         end
-      end
-    end
 
-    module OracleAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)}")
+        def truncate_tables(tables)
+          tables.each { |t| truncate_table(t) }
+        end
       end
-    end
 
-    module PostgreSQLAdapter
-      def db_version
-        @db_version ||= postgresql_version
-      end
+      module AbstractMysqlAdapter
+        def pre_count_truncate_tables(tables)
+          truncate_tables(pre_count_tables(tables))
+        end
 
-      def cascade
-        @cascade ||= db_version >=  80200 ? 'CASCADE' : ''
-      end
+        def pre_count_tables(tables)
+          tables.select { |table| has_been_used?(table) }
+        end
 
-      def restart_identity
-        @restart_identity ||= db_version >=  80400 ? 'RESTART IDENTITY' : ''
-      end
+        private
 
-      def truncate_table(table_name)
-        truncate_tables([table_name])
-      end
+        def row_count(table)
+          select_value("SELECT EXISTS (SELECT 1 FROM #{quote_table_name(table)} LIMIT 1)")
+        end
 
-      def truncate_tables(table_names)
-        return if table_names.nil? || table_names.empty?
-        execute("TRUNCATE TABLE #{table_names.map{|name| quote_table_name(name)}.join(', ')} #{restart_identity} #{cascade};")
-      end
+        def auto_increment_value(table)
+          select_value(<<-SQL).to_i
+            SELECT auto_increment
+            FROM information_schema.tables
+            WHERE table_name = '#{table}'
+            AND table_schema = database()
+          SQL
+        end
 
-      def pre_count_truncate_tables(tables, options = {:reset_ids => true})
-        filter = options[:reset_ids] ? method(:has_been_used?) : method(:has_rows?)
-        truncate_tables(tables.select(&filter))
-      end
+        # This method tells us if the given table has been inserted into since its
+        # last truncation. Note that the table might have been populated, which
+        # increased the auto-increment counter, but then cleaned again such that
+        # it appears empty now.
+        def has_been_used?(table)
+          has_rows?(table) || auto_increment_value(table) > 1
+        end
 
-      def database_cleaner_table_cache
-        # AR returns a list of tables without schema but then returns a
-        # migrations table with the schema. There are other problems, too,
-        # with using the base list. If a table exists in multiple schemas
-        # within the search path, truncation without the schema name could
-        # result in confusing, if not unexpected results.
-        @database_cleaner_tables ||= tables_with_schema
+        def has_rows?(table)
+          row_count(table) > 0
+        end
       end
 
-      private
+      module SQLiteAdapter
+        def truncate_table(table_name)
+          super
+          if uses_sequence?
+            execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
+          end
+        end
 
-      # Returns a boolean indicating if the given table has an auto-inc number higher than 0.
-      # Note, this is different than an empty table since an table may populated, the index increased,
-      # but then the table is cleaned.  In other words, this function tells us if the given table
-      # was ever inserted into.
-      def has_been_used?(table)
-        return has_rows?(table) unless has_sequence?(table)
+        def truncate_tables(tables)
+          tables.each { |t| truncate_table(t) }
+        end
 
-        cur_val = select_value("SELECT currval('#{table}_id_seq');").to_i rescue 0
-        cur_val > 0
-      end
+        def pre_count_truncate_tables(tables)
+          truncate_tables(pre_count_tables(tables))
+        end
 
-      def has_sequence?(table)
-        select_value("SELECT true FROM pg_class WHERE relname = '#{table}_id_seq';")
-      end
+        def pre_count_tables(tables)
+          sequences = fetch_sequences
+          tables.select { |table| has_been_used?(table, sequences) }
+        end
 
-      def has_rows?(table)
-        select_value("SELECT true FROM #{table} LIMIT 1;")
-      end
+        private
 
-      def tables_with_schema
-        rows = select_rows <<-_SQL
-          SELECT schemaname || '.' || tablename
-          FROM pg_tables
-          WHERE
-            tablename !~ '_prt_' AND
-            #{::DatabaseCleaner::ActiveRecord::Base.exclusion_condition('tablename')} AND
-            schemaname = ANY (current_schemas(false))
-        _SQL
-        rows.collect { |result| result.first }
-      end
-    end
-  end
-end
+        def fetch_sequences
+          return {} unless uses_sequence?
+          results = select_all("SELECT * FROM sqlite_sequence")
+          Hash[results.rows]
+        end
+
+        def has_been_used?(table, sequences)
+          count = sequences.fetch(table) { row_count(table) }
+          count > 0
+        end
 
-module ActiveRecord
-  module ConnectionAdapters
-    #Apply adapter decoraters where applicable (adapter should be loaded)
-    AbstractAdapter.class_eval { include DatabaseCleaner::ConnectionAdapters::AbstractAdapter }
+        def row_count(table)
+          select_value("SELECT EXISTS (SELECT 1 FROM #{quote_table_name(table)} LIMIT 1)")
+        end
 
-    if defined?(JdbcAdapter)
-      if defined?(OracleJdbcConnection)
-        JdbcAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::OracleAdapter }
-      else
-        JdbcAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::TruncateOrDelete }
+        # Returns a boolean indicating if the SQLite database is using the sqlite_sequence table.
+        def uses_sequence?
+          select_value("SELECT name FROM sqlite_master WHERE type='table' AND name='sqlite_sequence';")
+        end
       end
-    end
-    AbstractMysqlAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::AbstractMysqlAdapter } if defined?(AbstractMysqlAdapter)
-    Mysql2Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::AbstractMysqlAdapter } if defined?(Mysql2Adapter)
-    MysqlAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::AbstractMysqlAdapter } if defined?(MysqlAdapter)
-    SQLiteAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::SQLiteAdapter } if defined?(SQLiteAdapter)
-    SQLite3Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::SQLiteAdapter } if defined?(SQLite3Adapter)
-    PostgreSQLAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::PostgreSQLAdapter } if defined?(PostgreSQLAdapter)
-    IBM_DBAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::IBM_DBAdapter } if defined?(IBM_DBAdapter)
-    SQLServerAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::TruncateOrDelete } if defined?(SQLServerAdapter)
-    OracleEnhancedAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::OracleAdapter } if defined?(OracleEnhancedAdapter)
-  end
-end
 
-module DatabaseCleaner::ActiveRecord
-  class Truncation
-    include ::DatabaseCleaner::ActiveRecord::Base
-    include ::DatabaseCleaner::Generic::Truncation
+      module PostgreSQLAdapter
+        def database_tables
+          tables_with_schema
+        end
 
-    def clean
-      connection = connection_class.connection
-      connection.disable_referential_integrity do
-        if pre_count? && connection.respond_to?(:pre_count_truncate_tables)
-          connection.pre_count_truncate_tables(tables_to_truncate(connection), {:reset_ids => reset_ids?})
-        else
-          connection.truncate_tables(tables_to_truncate(connection))
+        def truncate_tables(table_names)
+          return if table_names.nil? || table_names.empty?
+          execute("TRUNCATE TABLE #{table_names.map{|name| quote_table_name(name)}.join(', ')} RESTART IDENTITY CASCADE;")
         end
-      end
-    end
 
-    private
+        def pre_count_truncate_tables(tables)
+          truncate_tables(pre_count_tables(tables))
+        end
 
-    def tables_to_truncate(connection)
-      tables_in_db = cache_tables? ? connection.database_cleaner_table_cache : connection.database_tables
-      to_reject = (@tables_to_exclude + connection.database_cleaner_view_cache)
-      (@only || tables_in_db).reject do |table|
-        if ( m = table.match(/([^.]+)$/) )
-          to_reject.include?(m[1])
-        else
-          false
+        def pre_count_tables(tables)
+          tables.select { |table| has_been_used?(table) }
         end
-      end
-    end
 
-    # overwritten
-    def migration_storage_names
-      [::DatabaseCleaner::ActiveRecord::Base.migration_table_name]
-    end
+        def database_cleaner_table_cache
+          # AR returns a list of tables without schema but then returns a
+          # migrations table with the schema. There are other problems, too,
+          # with using the base list. If a table exists in multiple schemas
+          # within the search path, truncation without the schema name could
+          # result in confusing, if not unexpected results.
+          @database_cleaner_tables ||= tables_with_schema
+        end
 
-    def cache_tables?
-      !!@cache_tables
-    end
+        private
 
-    def pre_count?
-      @pre_count == true
-    end
+        # Returns a boolean indicating if the given table has an auto-inc number higher than 0.
+        # Note, this is different than an empty table since an table may populated, the index increased,
+        # but then the table is cleaned.  In other words, this function tells us if the given table
+        # was ever inserted into.
+        def has_been_used?(table)
+          return has_rows?(table) unless has_sequence?(table)
+
+          cur_val = select_value("SELECT currval('#{table}_id_seq');").to_i rescue 0
+          cur_val > 0
+        end
+
+        def has_sequence?(table)
+          select_value("SELECT true FROM pg_class WHERE relname = '#{table}_id_seq';")
+        end
 
-    def reset_ids?
-      @reset_ids != false
+        def has_rows?(table)
+          select_value("SELECT true FROM #{table} LIMIT 1;")
+        end
+
+        def tables_with_schema
+          rows = select_rows <<-_SQL
+            SELECT schemaname || '.' || tablename
+            FROM pg_tables
+            WHERE
+              tablename !~ '_prt_' AND
+              #{DatabaseCleaner::ActiveRecord::Base.exclusion_condition('tablename')} AND
+              schemaname = ANY (current_schemas(false))
+          _SQL
+          rows.collect { |result| result.first }
+        end
+      end
     end
+    private_constant :ConnectionWrapper
   end
 end
+