activerecord-oracle_enhanced-adapter 1.2.3 → 1.2.4

data/History.txt

@@ -1,3 +1,20 @@
+== 1.2.4 2010-02-23
+
+* Enhancements:
+  * rake db:test:purge will drop all schema objects from test schema (including views, synonyms, packages, functions, procedures) -
+    they should be always reloaded before tests run if necessary
+  * added views, synonyms, packages, functions, procedures, indexes, triggers, types, primary, unique and foreign key constraints to structure dump
+  * added :temporary option for create_table to create temporary tables
+  * added :tablespace option for add_index
+  * support function based indexes in schema dump
+  * support JNDI database connections in JRuby
+  * check ruby-oci8 minimum version 2.0.3
+  * added savepoints support (nested ActiveRecord transactions)
+* Bug fixes:
+  * typecast returned BigDecimal integer values to Fixnum or Bignum
+    (to avoid issues with _before_type_cast values for id attributes because _before_type_cast is used in form helpers)
+  * clear table columns cache after columns definition change in migrations
+
 == 1.2.3 2009-12-09
 
 * Enhancements

data/License.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Graham Jenkins, Michael Schoen, Raimonds Simanovskis
+Copyright (c) 2008-2010 Graham Jenkins, Michael Schoen, Raimonds Simanovskis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -48,12 +48,14 @@ In addition install either ruby-oci8 (for MRI/YARV) or copy Oracle JDBC driver t
 * Anton Jenkins
 * Dave Smylie
 * Alex Rothenberg
+* Billy Reisinger
+* David Blain
 
 == LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2009 Graham Jenkins, Michael Schoen, Raimonds Simanovskis
+Copyright (c) 2008-2010 Graham Jenkins, Michael Schoen, Raimonds Simanovskis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/VERSION

@@ -1 +1 @@
-1.2.3
+1.2.4

data/lib/active_record/connection_adapters/oracle_enhanced.rake

@@ -17,6 +17,7 @@ namespace :db do
       abcs = ActiveRecord::Base.configurations
       ActiveRecord::Base.establish_connection(abcs[RAILS_ENV])
       File.open("db/#{RAILS_ENV}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
+      File.open("db/#{RAILS_ENV}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.structure_dump_fk_constraints }
       if ActiveRecord::Base.connection.supports_migrations?
         File.open("db/#{RAILS_ENV}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
       end
@@ -32,15 +33,17 @@ namespace :db do
       abcs = ActiveRecord::Base.configurations
       ActiveRecord::Base.establish_connection(:test)
       IO.readlines("db/#{RAILS_ENV}_structure.sql").join.split("\n\n").each do |ddl|
-        ActiveRecord::Base.connection.execute(ddl.chop)
+        ddl.chop! if ddl.last == ";"
+        ActiveRecord::Base.connection.execute(ddl) unless ddl.blank?
       end
     end
 
     redefine_task :purge => :environment do
       abcs = ActiveRecord::Base.configurations
       ActiveRecord::Base.establish_connection(:test)
-      ActiveRecord::Base.connection.structure_drop.split("\n\n").each do |ddl|
-        ActiveRecord::Base.connection.execute(ddl.chop)
+      ActiveRecord::Base.connection.full_drop.split("\n\n").each do |ddl|
+        ddl.chop! if ddl.last == ";"
+        ActiveRecord::Base.connection.execute(ddl) unless ddl.blank?
       end
     end
 

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # oracle_enhanced_adapter.rb -- ActiveRecord adapter for Oracle 8i, 9i, 10g, 11g
 #
 # Authors or original oracle_adapter: Graham Jenkins, Michael Schoen
@@ -214,7 +215,7 @@ module ActiveRecord
           Date.new(value.year, value.month, value.day) : value
       end
       
-      class <<self
+      class << self
         protected
 
         def fallback_string_to_date(string) #:nodoc:
@@ -404,33 +405,45 @@ module ActiveRecord
         @quoted_column_names, @quoted_table_names = {}, {}
       end
 
+      ADAPTER_NAME = 'OracleEnhanced'.freeze
+      
       def adapter_name #:nodoc:
-        'OracleEnhanced'
+        ADAPTER_NAME
       end
 
       def supports_migrations? #:nodoc:
         true
       end
 
+      def supports_savepoints? #:nodoc:
+        true
+      end
+
+      #:stopdoc:
+      NATIVE_DATABASE_TYPES = {
+        :primary_key => "NUMBER(38) NOT NULL PRIMARY KEY",
+        :string      => { :name => "VARCHAR2", :limit => 255 },
+        :text        => { :name => "CLOB" },
+        :integer     => { :name => "NUMBER", :limit => 38 },
+        :float       => { :name => "NUMBER" },
+        :decimal     => { :name => "DECIMAL" },
+        :datetime    => { :name => "DATE" },
+        # changed to native TIMESTAMP type
+        # :timestamp   => { :name => "DATE" },
+        :timestamp   => { :name => "TIMESTAMP" },
+        :time        => { :name => "DATE" },
+        :date        => { :name => "DATE" },
+        :binary      => { :name => "BLOB" },
+        :boolean     => { :name => "NUMBER", :limit => 1 }
+      }
+      # if emulate_booleans_from_strings then store booleans in VARCHAR2
+      NATIVE_DATABASE_TYPES_BOOLEAN_STRINGS = NATIVE_DATABASE_TYPES.dup.merge(
+        :boolean     => { :name => "VARCHAR2", :limit => 1 }
+      )
+      #:startdoc:
+
       def native_database_types #:nodoc:
-        {
-          :primary_key => "NUMBER(38) NOT NULL PRIMARY KEY",
-          :string      => { :name => "VARCHAR2", :limit => 255 },
-          :text        => { :name => "CLOB" },
-          :integer     => { :name => "NUMBER", :limit => 38 },
-          :float       => { :name => "NUMBER" },
-          :decimal     => { :name => "DECIMAL" },
-          :datetime    => { :name => "DATE" },
-          # changed to native TIMESTAMP type
-          # :timestamp   => { :name => "DATE" },
-          :timestamp   => { :name => "TIMESTAMP" },
-          :time        => { :name => "DATE" },
-          :date        => { :name => "DATE" },
-          :binary      => { :name => "BLOB" },
-          # if emulate_booleans_from_strings then store booleans in VARCHAR2
-          :boolean     => emulate_booleans_from_strings ?
-            { :name => "VARCHAR2", :limit => 1 } : { :name => "NUMBER", :limit => 1 }
-        }
+        emulate_booleans_from_strings ? NATIVE_DATABASE_TYPES_BOOLEAN_STRINGS : NATIVE_DATABASE_TYPES
       end
 
       # maximum length of Oracle identifiers
@@ -595,7 +608,8 @@ module ActiveRecord
       end
       protected :insert_sql
 
-      AUTOGENERATED_SEQUENCE_NAME = 'autogenerated'.freeze #:nodoc:
+      # use in set_sequence_name to avoid fetching primary key value from sequence
+      AUTOGENERATED_SEQUENCE_NAME = 'autogenerated'.freeze
 
       # Returns the next sequence value from a sequence generator. Not generally
       # called directly; used by ActiveRecord to get the next primary key value
@@ -622,6 +636,18 @@ module ActiveRecord
         @connection.autocommit = true
       end
 
+      def create_savepoint #:nodoc:
+        execute("SAVEPOINT #{current_savepoint_name}")
+      end
+
+      def rollback_to_savepoint #:nodoc:
+        execute("ROLLBACK TO #{current_savepoint_name}")
+      end
+
+      def release_savepoint #:nodoc:
+        # there is no RELEASE SAVEPOINT statement in Oracle
+      end
+
       def add_limit_offset!(sql, options) #:nodoc:
         # added to_i for limit and offset to protect from SQL injection
         offset = (options[:offset] || 0).to_i
@@ -713,14 +739,19 @@ module ActiveRecord
       #
       # see: abstract/schema_statements.rb
 
-      # current database name
+      # Current database name
       def current_database
-        select_one("select sys_context('userenv','db_name') db from dual")["db"]
+        select_value("select sys_context('userenv','db_name') from dual")
       end
 
-      # current database session user
+      # Current database session user
       def current_user
-        select_one("select sys_context('userenv','session_user') u from dual")['u']
+        select_value("select sys_context('userenv','session_user') from dual")
+      end
+
+      # Default tablespace name of current user
+      def default_tablespace
+        select_value("select lower(default_tablespace) from user_users where username = sys_context('userenv','session_user')")
       end
 
       def tables(name = nil) #:nodoc:
@@ -735,37 +766,38 @@ module ActiveRecord
       def indexes(table_name, name = nil) #:nodoc:
         (owner, table_name, db_link) = @connection.describe(table_name)
         unless all_schema_indexes
+          default_tablespace_name = default_tablespace
           result = select_all(<<-SQL)
-            SELECT lower(i.table_name) as table_name, lower(i.index_name) as index_name, i.uniqueness, lower(c.column_name) as column_name
-              FROM all_indexes#{db_link} i, all_ind_columns#{db_link} c
+            SELECT lower(i.table_name) as table_name, lower(i.index_name) as index_name, i.uniqueness, lower(i.tablespace_name) as tablespace_name, lower(c.column_name) as column_name, e.column_expression as column_expression
+              FROM all_indexes#{db_link} i
+              JOIN all_ind_columns#{db_link} c on c.index_name = i.index_name and c.index_owner = i.owner
+              LEFT OUTER JOIN all_ind_expressions#{db_link} e on e.index_name = i.index_name and e.index_owner = i.owner and e.column_position = c.column_position
              WHERE i.owner = '#{owner}'
                AND i.table_owner = '#{owner}'
-               AND c.index_name = i.index_name
-               AND c.index_owner = i.owner
                AND NOT EXISTS (SELECT uc.index_name FROM all_constraints uc WHERE uc.index_name = i.index_name AND uc.owner = i.owner AND uc.constraint_type = 'P')
               ORDER BY i.index_name, c.column_position
           SQL
-      
+
           current_index = nil
           self.all_schema_indexes = []
-      
+
           result.each do |row|
             # have to keep track of indexes because above query returns dups
             # there is probably a better query we could figure out
             if current_index != row['index_name']
-              self.all_schema_indexes << ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(row['table_name'], row['index_name'], row['uniqueness'] == "UNIQUE", [])
+              all_schema_indexes << OracleEnhancedIndexDefinition.new(row['table_name'], row['index_name'], row['uniqueness'] == "UNIQUE",
+                row['tablespace_name'] == default_tablespace_name ? nil : row['tablespace_name'], [])
               current_index = row['index_name']
             end
-      
-            self.all_schema_indexes.last.columns << row['column_name']
+            all_schema_indexes.last.columns << (row['column_expression'].nil? ? row['column_name'] : row['column_expression'].gsub('"','').downcase)
           end
         end
-      
+
         # Return the indexes just for the requested table, since AR is structured that way
         table_name = table_name.downcase
         all_schema_indexes.select{|i| i.table == table_name}
       end
-      
+
       @@ignore_table_columns = nil #:nodoc:
 
       # set ignored columns for table
@@ -899,6 +931,11 @@ module ActiveRecord
         @@columns_cache = nil
       end
 
+      # used in migrations to clear column cache for specified table
+      def clear_table_columns_cache(table_name)
+        @@columns_cache[table_name.to_s] = nil if @@cache_columns
+      end
+
       ##
       # :singleton-method:
       # Specify default sequence start with value (by default 10000 if not explicitly set), e.g.:
@@ -937,38 +974,52 @@ module ActiveRecord
       #     t.string      :first_name, :comment => “Given name”
       #     t.string      :last_name, :comment => “Surname”
       #   end
+      
       def create_table(name, options = {}, &block)
         create_sequence = options[:id] != false
         column_comments = {}
-        super(name, options) do |t|
-          # store that primary key was defined in create_table block
-          unless create_sequence
-            class <<t
-              attr_accessor :create_sequence
-              def primary_key(*args)
-                self.create_sequence = true
-                super(*args)
-              end
+        
+        table_definition = TableDefinition.new(self)
+        table_definition.primary_key(options[:primary_key] || Base.get_primary_key(name.to_s.singularize)) unless options[:id] == false
+
+        # store that primary key was defined in create_table block
+        unless create_sequence
+          class << table_definition
+            attr_accessor :create_sequence
+            def primary_key(*args)
+              self.create_sequence = true
+              super(*args)
             end
           end
+        end
 
-          # store column comments
-          class <<t
-            attr_accessor :column_comments
-            def column(name, type, options = {})
-              if options[:comment]
-                self.column_comments ||= {}
-                self.column_comments[name] = options[:comment]
-              end
-              super(name, type, options)
+        # store column comments
+        class << table_definition
+          attr_accessor :column_comments
+          def column(name, type, options = {})
+            if options[:comment]
+              self.column_comments ||= {}
+              self.column_comments[name] = options[:comment]
             end
+            super(name, type, options)
           end
+        end
 
-          result = block.call(t) if block
-          create_sequence = create_sequence || t.create_sequence
-          column_comments = t.column_comments if t.column_comments
+        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
+
+
+        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 << ") #{options[:options]}"
+        execute create_sql
+        
         create_sequence_and_trigger(name, options) if create_sequence
         
         add_table_comment name, options[:comment]
@@ -987,12 +1038,29 @@ module ActiveRecord
         super(name)
         seq_name = options[:sequence_name] || default_sequence_name(name)
         execute "DROP SEQUENCE #{quote_table_name(seq_name)}" rescue nil
+      ensure
+        clear_table_columns_cache(name)
       end
 
       # clear cached indexes when adding new index
       def add_index(table_name, column_name, options = {}) #:nodoc:
         self.all_schema_indexes = nil
-        super
+        column_names = Array(column_name)
+        index_name   = index_name(table_name, :column => column_names)
+
+        if Hash === options # legacy support, since this param was a string
+          index_type = options[:unique] ? "UNIQUE" : ""
+          index_name = options[:name] || index_name
+          tablespace = if options[:tablespace]
+                         " TABLESPACE #{options[:tablespace]}"
+                       else
+                         ""
+                       end
+        else
+          index_type = options
+        end
+        quoted_column_names = column_names.map { |e| quote_column_name(e) }.join(", ")
+        execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})#{tablespace}"
       end
 
       # clear cached indexes when removing index
@@ -1026,10 +1094,14 @@ module ActiveRecord
         options[:type] = type
         add_column_options!(add_column_sql, options)
         execute(add_column_sql)
+      ensure
+        clear_table_columns_cache(table_name)
       end
 
       def change_column_default(table_name, column_name, default) #:nodoc:
         execute "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{quote_column_name(column_name)} DEFAULT #{quote(default)}"
+      ensure
+        clear_table_columns_cache(table_name)
       end
 
       def change_column_null(table_name, column_name, null, default = nil) #:nodoc:
@@ -1055,14 +1127,20 @@ module ActiveRecord
         options[:type] = type
         add_column_options!(change_column_sql, options)
         execute(change_column_sql)
+      ensure
+        clear_table_columns_cache(table_name)
       end
 
       def rename_column(table_name, column_name, new_column_name) #:nodoc:
         execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} to #{quote_column_name(new_column_name)}"
+      ensure
+        clear_table_columns_cache(table_name)
       end
 
       def remove_column(table_name, column_name) #:nodoc:
         execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
+      ensure
+        clear_table_columns_cache(table_name)
       end
 
       def add_comment(table_name, column_name, comment) #:nodoc:
@@ -1124,78 +1202,179 @@ module ActiveRecord
 
       def structure_dump #:nodoc:
         s = select_all("select sequence_name from user_sequences order by 1").inject("") do |structure, seq|
-          structure << "create sequence #{seq.to_a.first.last};\n\n"
+          structure << "create sequence #{seq.to_a.first.last}#{STATEMENT_TOKEN}"
         end
 
         # changed select from user_tables to all_tables - much faster in large data dictionaries
         select_all("select table_name from all_tables where owner = sys_context('userenv','session_user') order by 1").inject(s) do |structure, table|
-          ddl = "create table #{table.to_a.first.last} (\n "
+          table_name = table['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.to_a.first.last}'
+            where table_name = '#{table_name}'
             order by column_id
           }).map do |row|
-            col = "#{row['column_name'].downcase} #{row['data_type'].downcase}"
-            if row['data_type'] =='NUMBER' and !row['data_precision'].nil?
-              col << "(#{row['data_precision'].to_i}"
-              col << ",#{row['data_scale'].to_i}" if !row['data_scale'].nil?
-              col << ')'
-            elsif row['data_type'].include?('CHAR')
-              length = row['char_used'] == 'C' ? row['char_length'].to_i : row['data_length'].to_i
-              col <<  "(#{length})"
+            if(v = virtual_columns.find {|col| col['column_name'] == row['column_name']})
+              structure_dump_virtual_column(row, v['data_default'])
+            else
+              structure_dump_column(row)
             end
-            col << " default #{row['data_default']}" if !row['data_default'].nil?
-            col << ' not null' if row['nullable'] == 'N'
-            col
           end
           ddl << cols.join(",\n ")
-          ddl << ");\n\n"
+          ddl << structure_dump_constraints(table_name)
+          ddl << "\n)#{STATEMENT_TOKEN}"
           structure << ddl
+          structure << structure_dump_indexes(table_name)
         end
       end
-
+      
+      def structure_dump_virtual_column(column, data_default) #:nodoc:
+        data_default = data_default.gsub(/"/, '')
+        col = "#{column['column_name'].downcase} #{column['data_type'].downcase}"
+        if column['data_type'] =='NUMBER' and !column['data_precision'].nil?
+          col << "(#{column['data_precision'].to_i}"
+          col << ",#{column['data_scale'].to_i}" if !column['data_scale'].nil?
+          col << ')'
+        elsif column['data_type'].include?('CHAR')
+          length = column['char_used'] == 'C' ? column['char_length'].to_i : column['data_length'].to_i
+          col <<  "(#{length})"
+        end
+        col << " GENERATED ALWAYS AS (#{data_default}) VIRTUAL"
+      end
+      
+      def structure_dump_column(column) #:nodoc:
+        col = "#{column['column_name'].downcase} #{column['data_type'].downcase}"
+        if column['data_type'] =='NUMBER' and !column['data_precision'].nil?
+          col << "(#{column['data_precision'].to_i}"
+          col << ",#{column['data_scale'].to_i}" if !column['data_scale'].nil?
+          col << ')'
+        elsif column['data_type'].include?('CHAR')
+          length = column['char_used'] == 'C' ? column['char_length'].to_i : column['data_length'].to_i
+          col <<  "(#{length})"
+        end
+        col << " default #{column['data_default']}" if !column['data_default'].nil?
+        col << ' not null' if column['nullable'] == 'N'
+        col  
+      end
+      
+      def structure_dump_constraints(table) #:nodoc:
+        out = [structure_dump_primary_key(table), structure_dump_unique_keys(table)].flatten.compact
+        out.length > 0 ? ",\n#{out.join(",\n")}" : ''
+      end
+      
+      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')
+        SQL
+        pks.each do |row|
+          opts[:name] = row['constraint_name']
+          opts[:cols][row['position']-1] = row['column_name']
+        end
+        opts[:cols].length > 0 ? " CONSTRAINT #{opts[:name]} PRIMARY KEY (#{opts[:cols].join(',')})" : nil
+      end
+      
+      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')
+        SQL
+        uks.each do |uk|
+          keys[uk['constraint_name']] ||= []
+          keys[uk['constraint_name']][uk['position']-1] = uk['column_name']
+        end
+        keys.map do |k,v|
+          " CONSTRAINT #{k} UNIQUE (#{v.join(',')})"
+        end
+      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|
+          if respond_to?(:foreign_keys) && (foreign_keys = foreign_keys(table["table_name"])).any?
+            foreign_keys.map do |fk|
+              column = fk.options[:column] || "#{fk.to_table.to_s.singularize}_id"
+              constraint_name = foreign_key_constraint_name(fk.from_table, column, fk.options)
+              sql = "ALTER TABLE #{quote_table_name(fk.from_table)} ADD CONSTRAINT #{quote_column_name(constraint_name)} "
+              sql << "#{foreign_key_definition(fk.to_table, fk.options)}"
+            end
+          end
+        end.flatten.compact.join(STATEMENT_TOKEN)
+        fks.length > 1 ? "#{fks}#{STATEMENT_TOKEN}" : ''
+      end
+      
       # Extract all stored procedures, packages, synonyms and views.
       def structure_dump_db_stored_code #:nodoc:
-        structure = "\n"
+        structure = ""
         select_all("select distinct name, type 
                      from all_source 
-                    where type in ('PROCEDURE', 'PACKAGE', 'PACKAGE BODY', 'FUNCTION') 
-                      and  owner = sys_context('userenv','session_user')").inject("\n\n") do |structure, 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 
-                  }).map do |row|
-              ddl << row['text'] if row['text'].size > 1
-            end
-            ddl << ";"
-            structure << ddl << "\n"
+                    where type in ('PROCEDURE', 'PACKAGE', 'PACKAGE BODY', 'FUNCTION', 'TRIGGER', 'TYPE') 
+                      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 
+                }).map do |row|
+            ddl << row['text'] if row['text'].size > 1
+          end
+          ddl << ";" unless ddl.strip.last == ";"
+          structure << ddl << STATEMENT_TOKEN
         end
 
         # export views 
-        select_all("select view_name, text from user_views").inject(structure) do |structure, view|
+        select_all("select view_name, text from user_views").each do |view|
           ddl = "create or replace view #{view['view_name']} AS\n "
           # any views with empty lines will cause OCI to barf when loading. remove blank lines =/ 
           ddl << view['text'].gsub(/^\n/, '') 
-          ddl << ";\n\n"
-          structure << ddl
+          structure << ddl << STATEMENT_TOKEN
         end
 
         # export synonyms 
         select_all("select owner, synonym_name, table_name, table_owner 
                       from all_synonyms  
-                     where table_owner = sys_context('userenv','session_user') ").inject(structure) do |structure, synonym|
-          ddl = "create or replace #{synonym['owner'] == 'PUBLIC' ? 'PUBLIC' : '' } SYNONYM #{synonym['synonym_name']} for #{synonym['table_owner']}.#{synonym['table_name']};\n\n"
-          structure << ddl;
+                     where owner = sys_context('userenv','session_user') ").each do |synonym|
+          ddl = "create or replace #{synonym['owner'] == 'PUBLIC' ? 'PUBLIC' : '' } SYNONYM #{synonym['synonym_name']} for #{synonym['table_owner']}.#{synonym['table_name']}"
+          structure << ddl << STATEMENT_TOKEN
         end
-      end
 
+        structure
+      end
 
+      def structure_dump_indexes(table_name) #:nodoc:
+        statements = indexes(table_name).map do |options|
+        #def add_index(table_name, column_name, options = {})
+          column_names = options[:columns]
+          options = {:name => options[:name], :unique => options[:unique]}
+          index_name   = index_name(table_name, :column => column_names)
+          if Hash === options # legacy support, since this param was a string
+            index_type = options[:unique] ? "UNIQUE" : ""
+            index_name = options[:name] || index_name
+          else
+            index_type = options
+          end
+          quoted_column_names = column_names.map { |e| quote_column_name(e) }.join(", ")
+          "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})"
+        end
+        statements.length > 0 ? "#{statements.join(STATEMENT_TOKEN)}#{STATEMENT_TOKEN}" : ''
+      end
+      
       def structure_drop #:nodoc:
         s = select_all("select sequence_name from user_sequences order by 1").inject("") do |drop, seq|
           drop << "drop sequence #{seq.to_a.first.last};\n\n"
@@ -1206,8 +1385,26 @@ module ActiveRecord
           drop << "drop table #{table.to_a.first.last} cascade constraints;\n\n"
         end
       end
-
-
+      
+      def temp_table_drop #:nodoc:
+        # changed select from user_tables to all_tables - much faster in large data dictionaries
+        select_all("select table_name from all_tables where owner = sys_context('userenv','session_user') and temporary = 'Y' order by 1").inject('') do |drop, table|
+          drop << "drop table #{table.to_a.first.last} cascade constraints;\n\n"
+        end
+      end
+      
+      def full_drop(preserve_tables=false) #:nodoc:
+        s = preserve_tables ? [] : [structure_drop]
+        s << temp_table_drop if preserve_tables
+        s << drop_sql_for_feature("view")
+        s << drop_sql_for_feature("synonym")
+        s << drop_sql_for_feature("type")
+        s << drop_sql_for_object("package")
+        s << drop_sql_for_object("function")
+        s << drop_sql_for_object("procedure")
+        s.join("\n\n")
+      end
+      
       def add_column_options!(sql, options) #:nodoc:
         type = options[:type] || ((column = options[:column]) && column.type)
         type = type && type.to_sym
@@ -1251,6 +1448,13 @@ module ActiveRecord
         sql << order_columns * ", "
       end
 
+      def temporary_table?(table_name) #:nodoc:
+        select_value("select temporary from user_tables where table_name = '#{table_name.upcase}'") == 'Y'
+      end
+      
+      # statements separator used in structure dump
+      STATEMENT_TOKEN = "\n\n--@@@--\n\n"
+      
       # ORDER BY clause for the passed order option.
       # 
       # Uses column aliases as defined by #distinct.
@@ -1330,13 +1534,41 @@ module ActiveRecord
         string.split($/).map { |line| line.strip }.join(spaced ? ' ' : '')
       end
 
+      # virtual columns are an 11g feature.  This returns [] if feature is not 
+      # present or none are found.
+      # return [{'column_name' => 'FOOS', 'data_default' => '...'}, ...]
+      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}'
+          SQL
+        # feature not supported previous to 11g
+        rescue ActiveRecord::StatementInvalid => e
+          []
+        end
+      end
+      
+      def drop_sql_for_feature(type)
+        select_values("select 'DROP #{type.upcase} \"' || #{type}_name || '\";' from user_#{type.tableize}").join("\n\n")
+      end
+      
+      def drop_sql_for_object(type)
+        select_values("select 'DROP #{type.upcase} ' || object_name || ';' from user_objects where object_type = '#{type.upcase}'").join("\n\n")
+      end
+      
       public
       # DBMS_OUTPUT =============================================
       #
       # PL/SQL in Oracle uses dbms_output for logging print statements
       # These methods stick that output into the Rails log so Ruby and PL/SQL
       # code can can be debugged together in a single application 
-      DBMS_OUTPUT_BUFFER_SIZE = 10000  #can be 1-1000000
+
+      # Maximum DBMS_OUTPUT buffer size
+      DBMS_OUTPUT_BUFFER_SIZE = 10000  # can be 1-1000000
+
       # Turn DBMS_Output logging on
       def enable_dbms_output
         set_dbms_output_plsql_connection
@@ -1397,15 +1629,7 @@ if defined?(CGI::Session::ActiveRecordStore::Session)
 end
 
 # Load custom create, update, delete methods functionality
-# rescue LoadError if ruby-plsql gem cannot be loaded
-begin
-  require 'active_record/connection_adapters/oracle_enhanced_procedures'
-rescue LoadError
-  if defined?(RAILS_DEFAULT_LOGGER)
-    RAILS_DEFAULT_LOGGER.info "INFO: ActiveRecord oracle_enhanced adapter could not load ruby-plsql gem. "+
-                              "Custom create, update and delete methods will not be available."
-  end
-end
+require 'active_record/connection_adapters/oracle_enhanced_procedures'
 
 # Load additional methods for composite_primary_keys support
 require 'active_record/connection_adapters/oracle_enhanced_cpk'