oracle_enhanced 1.3.0.pre → 1.3.0.pre2

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -107,31 +107,33 @@ module ActiveRecord
     end
     private :enhanced_write_lobs
     
-    class << self
-      # patch ORDER BY to work with LOBs
-      def add_order_with_lobs!(sql, order, scope = :auto)
-        if connection.is_a?(ConnectionAdapters::OracleEnhancedAdapter)
-          order = connection.lob_order_by_expression(self, order) if order
-          
-          orig_scope = scope
-          scope = scope(:find) if :auto == scope
-          if scope
-            new_scope_order = connection.lob_order_by_expression(self, scope[:order])
-            if new_scope_order != scope[:order]
-              scope = scope.merge(:order => new_scope_order)
-            else
-              scope = orig_scope
-            end
-          end
-        end
-        add_order_without_lobs!(sql, order, scope = :auto)
-      end
-      private :add_order_with_lobs!
-      #:stopdoc:
-      alias_method :add_order!, :add_order_with_lobs! #rails 3 issues
-      alias_method :add_order_without_lobs!, :add_order!   
-      #:startdoc:
-    end
+    # No such method in ActiveRecord 3.0
+    # and there is no real need to order by LOBs
+    # class << self
+    #   # patch ORDER BY to work with LOBs
+    #   def add_order_with_lobs!(sql, order, scope = :auto)
+    #     if connection.is_a?(ConnectionAdapters::OracleEnhancedAdapter)
+    #       order = connection.lob_order_by_expression(self, order) if order
+    #       
+    #       orig_scope = scope
+    #       scope = scope(:find) if :auto == scope
+    #       if scope
+    #         new_scope_order = connection.lob_order_by_expression(self, scope[:order])
+    #         if new_scope_order != scope[:order]
+    #           scope = scope.merge(:order => new_scope_order)
+    #         else
+    #           scope = orig_scope
+    #         end
+    #       end
+    #     end
+    #     add_order_without_lobs!(sql, order, scope = :auto)
+    #   end
+    #   private :add_order_with_lobs!
+    #   #:stopdoc:
+    #   alias_method :add_order_without_lobs!, :add_order!
+    #   alias_method :add_order!, :add_order_with_lobs!
+    #   #:startdoc:
+    # end
     
     # Get table comment from schema definition.
     def self.table_comment
@@ -236,7 +238,7 @@ module ActiveRecord
           if OracleEnhancedAdapter.string_to_time_format && dt=Date._strptime(string, OracleEnhancedAdapter.string_to_time_format)
             return Time.mktime(*dt.values_at(:year, :mon, :mday, :hour, :min, :sec, :zone, :wday))
           end
-          DateTime.strptime(string, OracleEnhancedAdapter.string_to_date_format)
+          DateTime.strptime(string, OracleEnhancedAdapter.string_to_date_format).to_date
         end
         
       end
@@ -460,7 +462,8 @@ module ActiveRecord
       def quote_column_name(name) #:nodoc:
         # camelCase column names need to be quoted; not that anyone using Oracle
         # would really do this, but handling this case means we pass the test...
-        @quoted_column_names[name] = name.to_s =~ /[A-Z]/ ? "\"#{name}\"" : quote_oracle_reserved_words(name)
+        name = name.to_s
+        @quoted_column_names[name] ||= name =~ /^[a-z][a-z_0-9\$#]*$/ ? "\"#{name.upcase}\"" : "\"#{name}\""
       end
 
       # unescaped table name should start with letter and
@@ -474,12 +477,8 @@ module ActiveRecord
       end
 
       def quote_table_name(name) #:nodoc:
-        # abstract_adapter calls quote_column_name from quote_table_name, so prevent that
-        @quoted_table_names[name] ||= if self.class.valid_table_name?(name)
-          name
-        else
-          "\"#{name}\""
-        end
+        name = name.to_s
+        @quoted_table_names[name] ||= name.split('.').map{|n| n.split('@').map{|m| quote_column_name(m)}.join('@')}.join('.')
       end
       
       def quote_string(s) #:nodoc:
@@ -603,7 +602,6 @@ module ActiveRecord
         sql_with_returning = sql.dup << @connection.returning_clause(quote_column_name(pk))
         # hack to pass additional "with_returning" option without changing argument list
         sql_with_returning.instance_variable_set(:@with_returning, true)
-        clear_query_cache
         execute(sql_with_returning, name)
       end
       protected :insert_sql
@@ -651,10 +649,12 @@ module ActiveRecord
       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
-
-        if limit = options[:limit]
-          limit = limit.to_i
+        limit = options[:limit]
+        limit = limit.is_a?(String) && limit.blank? ? nil : limit && limit.to_i
+        if limit && offset > 0
           sql.replace "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_ where rownum <= #{offset+limit}) where raw_rnum_ > #{offset}"
+        elsif limit
+          sql.replace "select * from (#{sql}) where rownum <= #{limit}"
         elsif offset > 0
           sql.replace "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_) where raw_rnum_ > #{offset}"
         end
@@ -755,8 +755,13 @@ module ActiveRecord
       end
 
       def tables(name = nil) #:nodoc:
-        # changed select from user_tables to all_tables - much faster in large data dictionaries
-        select_all("select decode(table_name,upper(table_name),lower(table_name),table_name) name from all_tables where owner = sys_context('userenv','session_user')").map {|t| t['name']}
+        select_values(
+        "select decode(table_name,upper(table_name),lower(table_name),table_name) from all_tables where owner = sys_context('userenv','session_user') and secondary='N'",
+        name)
+      end
+
+      def materialized_views #:nodoc:
+        select_values("select lower(mview_name) from all_mviews where owner = sys_context('userenv','session_user')")
       end
 
       cattr_accessor :all_schema_indexes #:nodoc:
@@ -768,14 +773,19 @@ module ActiveRecord
         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(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}'
+            SELECT LOWER(i.table_name) AS table_name, LOWER(i.index_name) AS index_name, i.uniqueness,
+              i.index_type, i.ityp_owner, i.ityp_name, i.parameters,
+              LOWER(i.tablespace_name) AS tablespace_name,
+              LOWER(c.column_name) AS column_name, e.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 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
+               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
@@ -785,11 +795,25 @@ module ActiveRecord
             # 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']
-              all_schema_indexes << OracleEnhancedIndexDefinition.new(row['table_name'], row['index_name'], row['uniqueness'] == "UNIQUE",
+              statement_parameters = nil
+              if row['index_type'] == 'DOMAIN' && row['ityp_owner'] == 'CTXSYS' && row['ityp_name'] == 'CONTEXT'
+                procedure_name = default_datastore_procedure(row['index_name'])
+                statement_parameters = select_value(<<-SQL)
+                  SELECT SUBSTR(text,LENGTH('-- add_context_index_parameters ')+1)
+                  FROM all_source#{db_link}
+                  WHERE owner = '#{owner}'
+                    AND name = '#{procedure_name.upcase}'
+                    AND text LIKE '-- add_context_index_parameters %'
+                SQL
+              end
+              all_schema_indexes << OracleEnhancedIndexDefinition.new(row['table_name'], row['index_name'],
+                row['uniqueness'] == "UNIQUE", row['index_type'] == 'DOMAIN' ? "#{row['ityp_owner']}.#{row['ityp_name']}" : nil,
+                row['parameters'], statement_parameters,
                 row['tablespace_name'] == default_tablespace_name ? nil : row['tablespace_name'], [])
               current_index = row['index_name']
             end
-            all_schema_indexes.last.columns << (row['column_expression'].nil? ? row['column_name'] : row['column_expression'].gsub('"','').downcase)
+            all_schema_indexes.last.columns << (row['column_expression'].nil? ? row['column_name'] :
+              row['column_expression'].gsub('"','').downcase)
           end
         end
 
@@ -852,7 +876,7 @@ module ActiveRecord
             AND table_name = '#{desc_table_name}'
             AND status = 'ENABLED'
         SQL
-        select_value(pkt_sql) ? true : false
+        select_value(pkt_sql, 'Primary Key Trigger') ? true : false
       end
 
       ##
@@ -866,8 +890,7 @@ module ActiveRecord
       self.cache_columns = false
 
       def columns(table_name, name = nil) #:nodoc:
-        # Don't double cache if config.cache_classes is turned on
-        if @@cache_columns && !(defined?(Rails) && Rails.configuration.cache_classes)
+        if @@cache_columns
           @@columns_cache ||= {}
           @@columns_cache[table_name] ||= columns_without_cache(table_name, name)
         else
@@ -876,14 +899,15 @@ module ActiveRecord
       end
 
       def columns_without_cache(table_name, name = nil) #:nodoc:
+        table_name = table_name.to_s
         # get ignored_columns by original table name
         ignored_columns = ignored_table_columns(table_name)
 
         (owner, desc_table_name, db_link) = @connection.describe(table_name)
 
-        if has_primary_key_trigger?(table_name, owner, desc_table_name, db_link)
-          @@do_not_prefetch_primary_key[table_name] = true
-        end
+        @@do_not_prefetch_primary_key[table_name] =
+          !has_primary_key?(table_name, owner, desc_table_name, db_link) ||
+          has_primary_key_trigger?(table_name, owner, desc_table_name, db_link)
 
         table_cols = <<-SQL
           select column_name as name, data_type as sql_type, data_default, nullable,
@@ -929,11 +953,15 @@ module ActiveRecord
       # used just in tests to clear column cache
       def clear_columns_cache #:nodoc:
         @@columns_cache = nil
+        @@pk_and_sequence_for_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
+        if @@cache_columns
+          @@columns_cache ||= {}
+          @@columns_cache[table_name.to_s] = nil
+        end
       end
 
       ##
@@ -1051,11 +1079,7 @@ module ActiveRecord
         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
+          tablespace = options[:tablespace] ? " TABLESPACE #{options[:tablespace]}" : ""
         else
           index_type = options
         end
@@ -1072,18 +1096,21 @@ module ActiveRecord
       # returned shortened index name if default is too large
       def index_name(table_name, options) #:nodoc:
         default_name = super(table_name, options)
-        return default_name if default_name.length <= IDENTIFIER_MAX_LENGTH
+        # sometimes options can be String or Array with column names
+        options = {} unless options.is_a?(Hash)
+        identifier_max_length = options[:identifier_max_length] || IDENTIFIER_MAX_LENGTH
+        return default_name if default_name.length <= identifier_max_length
         
         # remove 'index', 'on' and 'and' keywords
         shortened_name = "i_#{table_name}_#{Array(options[:column]) * '_'}"
         
         # leave just first three letters from each word
-        if shortened_name.length > IDENTIFIER_MAX_LENGTH
+        if shortened_name.length > identifier_max_length
           shortened_name = shortened_name.split('_').map{|w| w[0,3]}.join('_')
         end
         # generate unique name using hash function
-        if shortened_name.length > OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH
-          shortened_name = 'i'+Digest::SHA1.hexdigest(default_name)[0,OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH-1]
+        if shortened_name.length > identifier_max_length
+          shortened_name = 'i'+Digest::SHA1.hexdigest(default_name)[0,identifier_max_length-1]
         end
         @logger.warn "#{adapter_name} shortened default index name #{default_name} to #{shortened_name}" if @logger
         shortened_name
@@ -1182,15 +1209,24 @@ module ActiveRecord
 
       # Find a table's primary key and sequence. 
       # *Note*: Only primary key is implemented - sequence will be nil.
-      def pk_and_sequence_for(table_name) #:nodoc:
-        (owner, table_name, db_link) = @connection.describe(table_name)
+      def pk_and_sequence_for(table_name, owner=nil, desc_table_name=nil, db_link=nil) #:nodoc:
+        if @@cache_columns
+          @@pk_and_sequence_for_cache ||= {}
+          @@pk_and_sequence_for_cache[table_name] ||= pk_and_sequence_for_without_cache(table_name, owner, desc_table_name, db_link)
+        else
+          pk_and_sequence_for_without_cache(table_name, owner, desc_table_name, db_link)
+        end
+      end
+
+      def pk_and_sequence_for_without_cache(table_name, owner=nil, desc_table_name=nil, db_link=nil) #:nodoc:
+        (owner, desc_table_name, db_link) = @connection.describe(table_name) unless owner
 
-        # changed select from all_constraints to user_constraints - much faster in large data dictionaries
+        # changed back from user_constraints to all_constraints for consistency
         pks = select_values(<<-SQL, 'Primary Key')
           select cc.column_name
-            from user_constraints#{db_link} c, user_cons_columns#{db_link} cc
+            from all_constraints#{db_link} c, all_cons_columns#{db_link} cc
            where c.owner = '#{owner}'
-             and c.table_name = '#{table_name}'
+             and c.table_name = '#{desc_table_name}'
              and c.constraint_type = 'P'
              and cc.owner = c.owner
              and cc.constraint_name = c.constraint_name
@@ -1200,16 +1236,29 @@ module ActiveRecord
         pks.size == 1 ? [oracle_downcase(pks.first), nil] : nil
       end
 
+      # Returns just a table's primary key
+      def primary_key(table_name)
+        pk_and_sequence = pk_and_sequence_for(table_name)
+        pk_and_sequence && pk_and_sequence.first
+      end
+
+      def has_primary_key?(table_name, owner=nil, desc_table_name=nil, db_link=nil) #:nodoc:
+        !pk_and_sequence_for(table_name, owner, desc_table_name, db_link).nil?
+      end
+
+      # Statements separator used in structure dump to allow loading of structure dump also with SQL*Plus
+      STATEMENT_TOKEN = "\n\n/\n\n"
+
       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}#{STATEMENT_TOKEN}"
+        structure = select_values("select sequence_name from user_sequences order by 1").map do |seq|
+          "CREATE SEQUENCE \"#{seq}\""
         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|
-          table_name = table['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)
+                    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 "
+          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
@@ -1224,15 +1273,16 @@ module ActiveRecord
           end
           ddl << cols.join(",\n ")
           ddl << structure_dump_constraints(table_name)
-          ddl << "\n)#{STATEMENT_TOKEN}"
+          ddl << "\n)"
           structure << ddl
           structure << structure_dump_indexes(table_name)
         end
+
+        join_with_statement_token(structure) << structure_dump_fk_constraints
       end
-      
-      def structure_dump_virtual_column(column, data_default) #:nodoc:
-        data_default = data_default.gsub(/"/, '')
-        col = "#{column['column_name'].downcase} #{column['data_type'].downcase}"
+
+      def structure_dump_column(column) #:nodoc:
+        col = "\"#{column['column_name']}\" #{column['data_type']}"
         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?
@@ -1241,11 +1291,14 @@ module ActiveRecord
           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"
+        col << " DEFAULT #{column['data_default']}" if !column['data_default'].nil?
+        col << ' NOT NULL' if column['nullable'] == 'N'
+        col
       end
-      
-      def structure_dump_column(column) #:nodoc:
-        col = "#{column['column_name'].downcase} #{column['data_type'].downcase}"
+
+      def structure_dump_virtual_column(column, data_default) #:nodoc:
+        data_default = data_default.gsub(/"/, '')
+        col = "\"#{column['column_name']}\" #{column['data_type']}"
         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?
@@ -1254,16 +1307,14 @@ module ActiveRecord
           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  
+        col << " GENERATED ALWAYS AS (#{data_default}) VIRTUAL"
       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") 
@@ -1281,7 +1332,7 @@ module ActiveRecord
         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") 
@@ -1301,7 +1352,23 @@ module ActiveRecord
           " CONSTRAINT #{k} UNIQUE (#{v.join(',')})"
         end
       end
-      
+
+      def structure_dump_indexes(table_name) #:nodoc:
+        indexes(table_name).map do |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
+      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?
@@ -1312,18 +1379,24 @@ module ActiveRecord
               sql << "#{foreign_key_definition(fk.to_table, fk.options)}"
             end
           end
-        end.flatten.compact.join(STATEMENT_TOKEN)
-        fks.length > 1 ? "#{fks}#{STATEMENT_TOKEN}" : ''
+        end.flatten.compact
+        join_with_statement_token(fks)
       end
-      
+
+      def dump_schema_information #:nodoc:
+        sm_table = ActiveRecord::Migrator.schema_migrations_table_name
+        migrated = select_values("SELECT version FROM #{sm_table}")
+        join_with_statement_token(migrated.map{|v| "INSERT INTO #{sm_table} (version) VALUES ('#{v}')" })
+      end
+
       # 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') 
+        structure = []
+        select_all("select distinct name, type
+                     from all_source
+                    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 "
+          ddl = "CREATE OR REPLACE   \n"
           lines = select_all(%Q{
                   select text
                     from all_source
@@ -1332,79 +1405,62 @@ module ActiveRecord
                      and owner = sys_context('userenv','session_user')
                    order by line 
                 }).map do |row|
-            ddl << row['text'] if row['text'].size > 1
+            ddl << row['text']
           end
-          ddl << ";" unless ddl.strip.last == ";"
-          structure << ddl << STATEMENT_TOKEN
+          ddl << ";" unless ddl.strip[-1,1] == ";"
+          structure << ddl
         end
 
         # export views 
         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/, '') 
-          structure << ddl << STATEMENT_TOKEN
+          structure << "CREATE OR REPLACE VIEW #{view['view_name']} AS\n #{view['text']}"
         end
 
-        # export synonyms 
+        # 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|
-          ddl = "create or replace #{synonym['owner'] == 'PUBLIC' ? 'PUBLIC' : '' } SYNONYM #{synonym['synonym_name']} for #{synonym['table_owner']}.#{synonym['table_name']}"
-          structure << ddl << STATEMENT_TOKEN
+          structure << "CREATE OR REPLACE #{synonym['owner'] == 'PUBLIC' ? 'PUBLIC' : '' } SYNONYM #{synonym['synonym_name']}"
+          structure << " FOR #{synonym['table_owner']}.#{synonym['table_name']}"
         end
 
-        structure
+        join_with_statement_token(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"
+        statements = select_values("select sequence_name from user_sequences order by 1").map do |seq|
+          "DROP SEQUENCE \"#{seq}\""
         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 |drop, table|
-          drop << "drop table #{table.to_a.first.last} cascade constraints;\n\n"
+        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)
+                    order by 1").each do |table|
+          statements << "DROP TABLE \"#{table}\" CASCADE CONSTRAINTS"
         end
+        join_with_statement_token(statements)
       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
+        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|
+          "DROP TABLE \"#{table}\" CASCADE CONSTRAINTS"
+        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("materialized 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")
+        s.join
       end
-      
+
       def add_column_options!(sql, options) #:nodoc:
         type = options[:type] || ((column = options[:column]) && column.type)
         type = type && type.to_sym
@@ -1452,9 +1508,6 @@ module ActiveRecord
         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.
@@ -1530,8 +1583,8 @@ module ActiveRecord
         "#{table_name.to_s[0,IDENTIFIER_MAX_LENGTH-4]}_pkt"
       end
 
-      def compress_lines(string, spaced = true)
-        string.split($/).map { |line| line.strip }.join(spaced ? ' ' : '')
+      def compress_lines(string, join_with = "\n")
+        string.split($/).map { |line| line.strip }.join(join_with)
       end
 
       # virtual columns are an 11g feature.  This returns [] if feature is not 
@@ -1550,15 +1603,28 @@ module ActiveRecord
           []
         end
       end
-      
+
       def drop_sql_for_feature(type)
-        select_values("select 'DROP #{type.upcase} \"' || #{type}_name || '\";' from user_#{type.tableize}").join("\n\n")
+        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|
+          "DROP #{type.upcase} \"#{name}\""
+        end)
       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")
+        join_with_statement_token(
+        select_values("select object_name from user_objects where object_type = '#{type.upcase}'").map do |name|
+          "DROP #{type.upcase} \"#{name}\""
+        end)
       end
-      
+
+      def join_with_statement_token(array)
+        string = array.join(STATEMENT_TOKEN)
+        string << STATEMENT_TOKEN unless string.blank?
+        string
+      end
+
       public
       # DBMS_OUTPUT =============================================
       #
@@ -1641,7 +1707,7 @@ require 'active_record/connection_adapters/oracle_enhanced_dirty'
 begin
   require 'active_record/connection_adapters/oracle_enhanced_tasks'
 rescue LoadError
-end if defined?(Rails.root)
+end if defined?(RAILS_ROOT)
 
 # Handles quoting of oracle reserved words
 require 'active_record/connection_adapters/oracle_enhanced_reserved_words'
@@ -1655,6 +1721,9 @@ require 'active_record/connection_adapters/oracle_enhanced_schema_statements_ext
 # Extensions for schema definition
 require 'active_record/connection_adapters/oracle_enhanced_schema_definitions'
 
+# Extensions for context index definition
+require 'active_record/connection_adapters/oracle_enhanced_context_index'
+
 # Add BigDecimal#to_d, Fixnum#to_d and Bignum#to_d methods if not already present
 require 'active_record/connection_adapters/oracle_enhanced_core_ext'