activerecord-oracle_enhanced-adapter 1.3.2 → 1.4.0

data/lib/active_record/connection_adapters/oracle_enhanced_schema_dumper.rb

@@ -105,6 +105,12 @@ module ActiveRecord #:nodoc:
       end
 
       def indexes_with_oracle_enhanced(table, stream)
+        # return original method if not using oracle_enhanced
+        if (rails_env = defined?(Rails.env) ? Rails.env : (defined?(RAILS_ENV) ? RAILS_ENV : nil)) &&
+              ActiveRecord::Base.configurations[rails_env] &&
+              ActiveRecord::Base.configurations[rails_env]['adapter'] != 'oracle_enhanced'
+          return indexes_without_oracle_enhanced(table, stream)
+        end
         if (indexes = @connection.indexes(table)).any?
           add_index_statements = indexes.map do |index|
             case index.type
@@ -169,12 +175,13 @@ module ActiveRecord #:nodoc:
             next if column.name == pk
             spec = {}
             spec[:name]      = column.name.inspect
-            spec[:type]      = column.type.to_s
+            spec[:type]      = column.virtual? ? 'virtual' : column.type.to_s
             spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && column.type != :decimal
             spec[:precision] = column.precision.inspect if !column.precision.nil?
             spec[:scale]     = column.scale.inspect if !column.scale.nil?
             spec[:null]      = 'false' if !column.null
-            spec[:default]   = default_string(column.default) if column.has_default?
+            spec[:default]   = column.virtual_column_data_default if column.virtual?
+            spec[:default] ||= default_string(column.default) if column.has_default?
             (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
             spec
           end.compact
@@ -228,7 +235,7 @@ module ActiveRecord #:nodoc:
         
         private
         def remove_prefix_and_suffix(table_name)
-          if table_name =~ /\A#{ActiveRecord::Base.table_name_prefix}(.*)#{ActiveRecord::Base.table_name_suffix}\Z/
+          if table_name =~ /\A#{ActiveRecord::Base.table_name_prefix.to_s.gsub('$','\$')}(.*)#{ActiveRecord::Base.table_name_suffix.to_s.gsub('$','\$')}\Z/
             "\"#{$1}\""
           else
             "\"#{table_name}\""

data/lib/active_record/connection_adapters/oracle_enhanced_schema_statements.rb

@@ -71,16 +71,21 @@ module ActiveRecord
         result = block.call(table_definition) if block
         create_sequence = create_sequence || table_definition.create_sequence
         column_comments = table_definition.column_comments if table_definition.column_comments
-        tablespace = options[:tablespace] ? " TABLESPACE #{options[:tablespace]}" : ""
+        tablespace = tablespace_for(:table, options[:tablespace])
 
         if options[:force] && table_exists?(name)
           drop_table(name, options)
         end
 
         create_sql = "CREATE#{' GLOBAL TEMPORARY' if options[:temporary]} TABLE "
-        create_sql << "#{quote_table_name(name)} ("
-        create_sql << table_definition.to_sql
-        create_sql << ")#{tablespace} #{options[:options]}"
+        create_sql << quote_table_name(name)
+        create_sql << " (#{table_definition.to_sql})"
+        unless options[:temporary]
+          create_sql << " ORGANIZATION #{options[:organization]}" if options[:organization]
+          create_sql << tablespace
+          table_definition.lob_columns.each{|cd| create_sql << tablespace_for(cd.sql_type.downcase.to_sym, nil, name, cd.name)}
+        end
+        create_sql << " #{options[:options]}"
         execute create_sql
         
         create_sequence_and_trigger(name, options) if create_sequence
@@ -113,7 +118,7 @@ module ActiveRecord
         if Hash === options # legacy support, since this param was a string
           index_type = options[:unique] ? "UNIQUE" : ""
           index_name = options[:name].to_s if options.key?(:name)
-          tablespace = options[:tablespace] ? " TABLESPACE #{options[:tablespace]}" : ""
+          tablespace = tablespace_for(:index, options[:tablespace])
         else
           index_type = options
         end
@@ -124,7 +129,7 @@ module ActiveRecord
         if index_name_exists?(table_name, index_name, false)
           raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists"
         end
-        quoted_column_names = column_names.map { |e| quote_column_name(e) }.join(", ")
+        quoted_column_names = column_names.map { |e| quote_column_name_or_expression(e) }.join(", ")
 
         execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})#{tablespace} #{options[:options]}"
       ensure
@@ -189,10 +194,19 @@ module ActiveRecord
         result == 1
       end
 
+      def rename_index(table_name, index_name, new_index_name) #:nodoc:
+        unless index_name_exists?(table_name, index_name, true)
+          raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
+        end
+        execute "ALTER INDEX #{quote_column_name(index_name)} rename to #{quote_column_name(new_index_name)}"
+      ensure
+        self.all_schema_indexes = nil
+      end
+
       def add_column(table_name, column_name, type, options = {}) #:nodoc:
         add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        options[:type] = type
-        add_column_options!(add_column_sql, options)
+        add_column_options!(add_column_sql, options.merge(:type=>type, :column_name=>column_name, :table_name=>table_name))
+        add_column_sql << tablespace_for((type_to_sql(type).downcase.to_sym), nil, table_name, column_name)
         execute(add_column_sql)
       ensure
         clear_table_columns_cache(table_name)
@@ -224,8 +238,8 @@ module ActiveRecord
         end
 
         change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        options[:type] = type
-        add_column_options!(change_column_sql, options)
+        add_column_options!(change_column_sql, options.merge(:type=>type, :column_name=>column_name, :table_name=>table_name))
+        change_column_sql << tablespace_for((type_to_sql(type).downcase.to_sym), nil, options[:table_name], options[:column_name])
         execute(change_column_sql)
       ensure
         clear_table_columns_cache(table_name)
@@ -280,8 +294,33 @@ module ActiveRecord
         super
       end
 
+      def tablespace(table_name)
+        select_value <<-SQL
+          SELECT tablespace_name
+          FROM user_tables
+          WHERE table_name='#{table_name.to_s.upcase}'
+        SQL
+      end
+
       private
 
+      def tablespace_for(obj_type, tablespace_option, table_name=nil, column_name=nil)
+        tablespace_sql = ''
+        if tablespace = (tablespace_option || default_tablespace_for(obj_type))
+          tablespace_sql << if [:blob, :clob].include?(obj_type.to_sym)
+           " LOB (#{column_name}) STORE AS #{column_name.to_s[0..10]}_#{table_name.to_s[0..14]}_ls (TABLESPACE #{tablespace})"
+          else
+           " TABLESPACE #{tablespace}"
+          end
+        end
+        tablespace_sql
+      end
+
+      def default_tablespace_for(type)
+        (default_tablespaces[type] || default_tablespaces[native_database_types[type][:name]]) rescue nil
+      end
+
+
       def column_for(table_name, column_name)
         unless column = columns(table_name).find { |c| c.name == column_name.to_s }
           raise "No such column: #{table_name}.#{column_name}"

data/lib/active_record/connection_adapters/oracle_enhanced_schema_statements_ext.rb

@@ -21,7 +21,7 @@ module ActiveRecord
       #     # ...
       #   end
       #
-      def add_primary_key_trigger(table_name, options)
+      def add_primary_key_trigger(table_name, options={})
         # call the same private method that is used for create_table :primary_key_trigger => true
         create_primary_key_trigger(table_name, options)
       end

data/lib/active_record/connection_adapters/oracle_enhanced_structure_dump.rb

@@ -6,21 +6,21 @@ module ActiveRecord #:nodoc:
       STATEMENT_TOKEN = "\n\n/\n\n"
 
       def structure_dump #:nodoc:
-        structure = select_values("select sequence_name from user_sequences order by 1").map do |seq|
+        structure = select_values("SELECT sequence_name FROM user_sequences ORDER BY 1").map do |seq|
           "CREATE SEQUENCE \"#{seq}\""
         end
-        select_values("select table_name from all_tables t
-                    where owner = sys_context('userenv','session_user') and secondary='N'
-                      and not exists (select mv.mview_name from all_mviews mv where mv.owner = t.owner and mv.mview_name = t.table_name)
-                      and not exists (select mvl.log_table from all_mview_logs mvl where mvl.log_owner = t.owner and mvl.log_table = t.table_name)
-                    order by 1").each do |table_name|
+        select_values("SELECT table_name FROM all_tables t
+                    WHERE owner = SYS_CONTEXT('userenv', 'session_user') AND secondary = 'N'
+                      AND NOT EXISTS (SELECT mv.mview_name FROM all_mviews mv WHERE mv.owner = t.owner AND mv.mview_name = t.table_name)
+                      AND NOT EXISTS (SELECT mvl.log_table FROM all_mview_logs mvl WHERE mvl.log_owner = t.owner AND mvl.log_table = t.table_name)
+                    ORDER BY 1").each do |table_name|
           virtual_columns = virtual_columns_for(table_name)
           ddl = "CREATE#{ ' GLOBAL TEMPORARY' if temporary_table?(table_name)} TABLE \"#{table_name}\" (\n"
           cols = select_all(%Q{
-            select column_name, data_type, data_length, char_used, char_length, data_precision, data_scale, data_default, nullable
-            from user_tab_columns
-            where table_name = '#{table_name}'
-            order by column_id
+            SELECT column_name, data_type, data_length, char_used, char_length, data_precision, data_scale, data_default, nullable
+            FROM user_tab_columns
+            WHERE table_name = '#{table_name}'
+            ORDER BY column_id
           }).map do |row|
             if(v = virtual_columns.find {|col| col['column_name'] == row['column_name']})
               structure_dump_virtual_column(row, v['data_default'])
@@ -71,13 +71,13 @@ module ActiveRecord #:nodoc:
       def structure_dump_primary_key(table) #:nodoc:
         opts = {:name => '', :cols => []}
         pks = select_all(<<-SQL, "Primary Keys") 
-          select a.constraint_name, a.column_name, a.position
-            from user_cons_columns a 
-            join user_constraints c  
-              on a.constraint_name = c.constraint_name 
-           where c.table_name = '#{table.upcase}' 
-             and c.constraint_type = 'P'
-             and c.owner = sys_context('userenv', 'session_user')
+          SELECT a.constraint_name, a.column_name, a.position
+            FROM user_cons_columns a
+            JOIN user_constraints c
+              ON a.constraint_name = c.constraint_name
+           WHERE c.table_name = '#{table.upcase}'
+             AND c.constraint_type = 'P'
+             AND c.owner = SYS_CONTEXT('userenv', 'session_user')
         SQL
         pks.each do |row|
           opts[:name] = row['constraint_name']
@@ -89,13 +89,13 @@ module ActiveRecord #:nodoc:
       def structure_dump_unique_keys(table) #:nodoc:
         keys = {}
         uks = select_all(<<-SQL, "Primary Keys") 
-          select a.constraint_name, a.column_name, a.position
-            from user_cons_columns a 
-            join user_constraints c  
-              on a.constraint_name = c.constraint_name 
-           where c.table_name = '#{table.upcase}' 
-             and c.constraint_type = 'U'
-             and c.owner = sys_context('userenv', 'session_user')
+          SELECT a.constraint_name, a.column_name, a.position
+            FROM user_cons_columns a
+            JOIN user_constraints c
+              ON a.constraint_name = c.constraint_name
+           WHERE c.table_name = '#{table.upcase}'
+             AND c.constraint_type = 'U'
+             AND c.owner = SYS_CONTEXT('userenv', 'session_user')
         SQL
         uks.each do |uk|
           keys[uk['constraint_name']] ||= []
@@ -123,7 +123,7 @@ module ActiveRecord #:nodoc:
       end
 
       def structure_dump_fk_constraints #:nodoc:
-        fks = select_all("select table_name from all_tables where owner = sys_context('userenv','session_user') order by 1").map do |table|
+        fks = select_all("SELECT table_name FROM all_tables WHERE owner = SYS_CONTEXT('userenv', 'session_user') ORDER BY 1").map do |table|
           if respond_to?(:foreign_keys) && (foreign_keys = foreign_keys(table["table_name"])).any?
             foreign_keys.map do |fk|
               sql = "ALTER TABLE #{quote_table_name(fk.from_table)} ADD CONSTRAINT #{quote_column_name(fk.options[:name])} "
@@ -143,19 +143,19 @@ module ActiveRecord #:nodoc:
       # Extract all stored procedures, packages, synonyms and views.
       def structure_dump_db_stored_code #:nodoc:
         structure = []
-        select_all("select distinct name, type
-                     from all_source
-                    where type in ('PROCEDURE', 'PACKAGE', 'PACKAGE BODY', 'FUNCTION', 'TRIGGER', 'TYPE')
-                      and name not like 'BIN$%'
-                      and  owner = sys_context('userenv','session_user') order by type").each do |source|
+        select_all("SELECT DISTINCT name, type
+                     FROM all_source
+                    WHERE type IN ('PROCEDURE', 'PACKAGE', 'PACKAGE BODY', 'FUNCTION', 'TRIGGER', 'TYPE')
+                      AND name NOT LIKE 'BIN$%'
+                      AND owner = SYS_CONTEXT('userenv', 'session_user') ORDER BY type").each do |source|
           ddl = "CREATE OR REPLACE   \n"
           lines = select_all(%Q{
-                  select text
-                    from all_source
-                   where name = '#{source['name']}'
-                     and type = '#{source['type']}'
-                     and owner = sys_context('userenv','session_user')
-                   order by line 
+                  SELECT text
+                    FROM all_source
+                   WHERE name = '#{source['name']}'
+                     AND type = '#{source['type']}'
+                     AND owner = SYS_CONTEXT('userenv', 'session_user')
+                   ORDER BY line
                 }).map do |row|
             ddl << row['text']
           end
@@ -164,14 +164,14 @@ module ActiveRecord #:nodoc:
         end
 
         # export views 
-        select_all("select view_name, text from user_views").each do |view|
+        select_all("SELECT view_name, text FROM user_views").each do |view|
           structure << "CREATE OR REPLACE VIEW #{view['view_name']} AS\n #{view['text']}"
         end
 
         # export synonyms
-        select_all("select owner, synonym_name, table_name, table_owner 
-                      from all_synonyms  
-                     where owner = sys_context('userenv','session_user') ").each do |synonym|
+        select_all("SELECT owner, synonym_name, table_name, table_owner
+                      FROM all_synonyms
+                     WHERE owner = SYS_CONTEXT('userenv', 'session_user') ").each do |synonym|
           structure << "CREATE OR REPLACE #{synonym['owner'] == 'PUBLIC' ? 'PUBLIC' : '' } SYNONYM #{synonym['synonym_name']}"
           structure << " FOR #{synonym['table_owner']}.#{synonym['table_name']}"
         end
@@ -180,14 +180,14 @@ module ActiveRecord #:nodoc:
       end
 
       def structure_drop #:nodoc:
-        statements = select_values("select sequence_name from user_sequences order by 1").map do |seq|
+        statements = select_values("SELECT sequence_name FROM user_sequences ORDER BY 1").map do |seq|
           "DROP SEQUENCE \"#{seq}\""
         end
-        select_values("select table_name from all_tables t
-                    where owner = sys_context('userenv','session_user') and secondary='N'
-                      and not exists (select mv.mview_name from all_mviews mv where mv.owner = t.owner and mv.mview_name = t.table_name)
-                      and not exists (select mvl.log_table from all_mview_logs mvl where mvl.log_owner = t.owner and mvl.log_table = t.table_name)
-                    order by 1").each do |table|
+        select_values("SELECT table_name from all_tables t
+                    WHERE owner = SYS_CONTEXT('userenv', 'session_user') AND secondary = 'N'
+                      AND NOT EXISTS (SELECT mv.mview_name FROM all_mviews mv WHERE mv.owner = t.owner AND mv.mview_name = t.table_name)
+                      AND NOT EXISTS (SELECT mvl.log_table FROM all_mview_logs mvl WHERE mvl.log_owner = t.owner AND mvl.log_table = t.table_name)
+                    ORDER BY 1").each do |table|
           statements << "DROP TABLE \"#{table}\" CASCADE CONSTRAINTS"
         end
         join_with_statement_token(statements)
@@ -195,8 +195,8 @@ module ActiveRecord #:nodoc:
 
       def temp_table_drop #:nodoc:
         join_with_statement_token(select_values(
-                  "select table_name from all_tables
-                    where owner = sys_context('userenv','session_user') and secondary='N' and temporary = 'Y' order by 1").map do |table|
+                  "SELECT table_name FROM all_tables
+                    WHERE owner = SYS_CONTEXT('userenv', 'session_user') AND secondary = 'N' AND temporary = 'Y' ORDER BY 1").map do |table|
           "DROP TABLE \"#{table}\" CASCADE CONSTRAINTS"
         end)
       end
@@ -249,10 +249,10 @@ module ActiveRecord #:nodoc:
       def virtual_columns_for(table)
         begin
           select_all <<-SQL
-            select column_name, data_default 
-              from user_tab_cols 
-             where virtual_column='YES' 
-               and table_name='#{table.upcase}'
+            SELECT column_name, data_default
+              FROM user_tab_cols
+             WHERE virtual_column = 'YES'
+               AND table_name = '#{table.upcase}'
           SQL
         # feature not supported previous to 11g
         rescue ActiveRecord::StatementInvalid => e
@@ -263,14 +263,14 @@ module ActiveRecord #:nodoc:
       def drop_sql_for_feature(type)
         short_type = type == 'materialized view' ? 'mview' : type
         join_with_statement_token(
-        select_values("select #{short_type}_name from user_#{short_type.tableize}").map do |name|
+        select_values("SELECT #{short_type}_name FROM user_#{short_type.tableize}").map do |name|
           "DROP #{type.upcase} \"#{name}\""
         end)
       end
 
       def drop_sql_for_object(type)
         join_with_statement_token(
-        select_values("select object_name from user_objects where object_type = '#{type.upcase}'").map do |name|
+        select_values("SELECT object_name FROM user_objects WHERE object_type = '#{type.upcase}'").map do |name|
           "DROP #{type.upcase} \"#{name}\""
         end)
       end

data/spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb

@@ -43,6 +43,8 @@ describe "OracleEnhancedAdapter" do
   
   describe "database session store" do
     before(:all) do
+      @conn.execute "DROP TABLE sessions" rescue nil
+      @conn.execute "DROP SEQUENCE sessions_seq" rescue nil
       @conn = ActiveRecord::Base.connection
       @conn.execute <<-SQL
         CREATE TABLE sessions (
@@ -112,6 +114,7 @@ describe "OracleEnhancedAdapter" do
   describe "ignore specified table columns" do
     before(:all) do
       @conn = ActiveRecord::Base.connection
+      @conn.execute "DROP TABLE test_employees" rescue nil
       @conn.execute <<-SQL
         CREATE TABLE test_employees (
           id            NUMBER PRIMARY KEY,
@@ -128,6 +131,7 @@ describe "OracleEnhancedAdapter" do
           created_at    DATE
         )
       SQL
+      @conn.execute "DROP SEQUENCE test_employees_seq" rescue nil
       @conn.execute <<-SQL
         CREATE SEQUENCE test_employees_seq  MINVALUE 1
           INCREMENT BY 1 START WITH 1 CACHE 20 NOORDER NOCYCLE
@@ -142,6 +146,7 @@ describe "OracleEnhancedAdapter" do
     after(:each) do
       Object.send(:remove_const, "TestEmployee")
       ActiveRecord::Base.connection.clear_ignored_table_columns
+      ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
     end
 
     it "should ignore specified table columns" do
@@ -181,16 +186,18 @@ describe "OracleEnhancedAdapter" do
     before(:all) do
       @conn = ActiveRecord::Base.connection
       @conn.execute "DROP TABLE test_employees" rescue nil
+      @oracle11g = !! @conn.select_value("SELECT * FROM v$version WHERE banner LIKE 'Oracle%11g%'")
       @conn.execute <<-SQL
         CREATE TABLE test_employees (
           id            NUMBER PRIMARY KEY,
           first_name    VARCHAR2(20),
           last_name     VARCHAR2(25),
+          #{ @oracle11g ? "full_name AS (first_name || ' ' || last_name)," : "full_name VARCHAR2(46),"}
           hire_date     DATE
         )
       SQL
-      @column_names = ['id', 'first_name', 'last_name', 'hire_date']
-      @column_sql_types = ["NUMBER", "VARCHAR2(20)", "VARCHAR2(25)", "DATE"]
+      @column_names = ['id', 'first_name', 'last_name', 'full_name', 'hire_date']
+      @column_sql_types = ["NUMBER", "VARCHAR2(20)", "VARCHAR2(25)", "VARCHAR2(46)", "DATE"]
       class ::TestEmployee < ActiveRecord::Base
       end
       # Another class using the same table
@@ -205,6 +212,7 @@ describe "OracleEnhancedAdapter" do
       Object.send(:remove_const, "TestEmployee2")
       @conn.execute "DROP TABLE test_employees"
       ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.cache_columns = nil
+      ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
     end
 
     before(:each) do
@@ -223,16 +231,22 @@ describe "OracleEnhancedAdapter" do
         ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.cache_columns = false
       end
 
+      it 'should identify virtual columns as such' do
+        pending "Not supported in this database version" unless @oracle11g
+        te = TestEmployee.connection.columns('test_employees').detect(&:virtual?)
+        te.name.should == 'full_name'
+      end
+
       it "should get columns from database at first time" do
         TestEmployee.connection.columns('test_employees').map(&:name).should == @column_names
-        @logger.logged(:debug).last.should =~ /select .* from all_tab_columns/im
+        @logger.logged(:debug).last.should =~ /select .* from all_tab_cols/im
       end
 
       it "should get columns from database at second time" do
         TestEmployee.connection.columns('test_employees')
         @logger.clear(:debug)
         TestEmployee.connection.columns('test_employees').map(&:name).should == @column_names
-        @logger.logged(:debug).last.should =~ /select .* from all_tab_columns/im
+        @logger.logged(:debug).last.should =~ /select .* from all_tab_cols/im
       end
 
       it "should get primary key from database at first time" do
@@ -264,7 +278,7 @@ describe "OracleEnhancedAdapter" do
 
       it "should get columns from database at first time" do
         TestEmployee.connection.columns('test_employees').map(&:name).should == @column_names
-        @logger.logged(:debug).last.should =~ /select .* from all_tab_columns/im
+        @logger.logged(:debug).last.should =~ /select .* from all_tab_cols/im
       end
 
       it "should get columns from cache at second time" do
@@ -310,6 +324,7 @@ describe "OracleEnhancedAdapter" do
     after(:all) do
       Object.send(:remove_const, "TestEmployee")
       @conn.execute "DROP TABLE test_employees"
+      ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
     end
 
     it "should tell ActiveRecord that count distinct is supported" do
@@ -342,6 +357,7 @@ describe "OracleEnhancedAdapter" do
       end
       Object.send(:remove_const, "TestReservedWord")
       ActiveRecord::Base.table_name_prefix = nil
+      ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
     end
 
     before(:each) do
@@ -371,6 +387,10 @@ describe "OracleEnhancedAdapter" do
       end
     end
 
+    it "should remove double quotes in column quoting" do
+      ActiveRecord::Base.connection.quote_column_name('aaa "bbb" ccc').should == '"aaa bbb ccc"'
+    end
+
   end
 
   describe "valid table names" do
@@ -527,6 +547,7 @@ describe "OracleEnhancedAdapter" do
       @conn.execute "DROP DATABASE LINK #{@db_link}" rescue nil
       @sys_conn.drop_table :test_posts rescue nil
       Object.send(:remove_const, "TestPost") rescue nil
+      ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
     end
 
     it "should verify database link" do
@@ -563,8 +584,13 @@ describe "OracleEnhancedAdapter" do
 
   describe "temporary tables" do
     before(:all) do
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_tablespaces[:table] = 'UNUSED'
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_tablespaces[:clob] = 'UNUSED'
       @conn = ActiveRecord::Base.connection
     end
+    after(:all) do
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_tablespaces={}
+    end
 
     after(:each) do
       @conn.drop_table :foos rescue nil
@@ -572,6 +598,7 @@ describe "OracleEnhancedAdapter" do
     it "should create ok" do
       @conn.create_table :foos, :temporary => true, :id => false do |t|
         t.integer :id
+        t.text :bar
       end
     end
     it "should show up as temporary" do
@@ -616,6 +643,7 @@ describe "OracleEnhancedAdapter" do
       end
       Object.send(:remove_const, "TestPost")
       Object.send(:remove_const, "TestComment")
+      ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
     end
 
     it "should load included association with more than 1000 records" do