activerecord-oracle_enhanced-adapter 1.2.4 → 1.3.0

data/.gitignore

@@ -6,5 +6,4 @@ pkg
 log
 tmp
 sqlnet.log
-activerecord-oracle_enhanced-adapter.gemspec
 

data/History.txt

@@ -1,3 +1,23 @@
+== 1.3.0 2010-06-21
+
+* Enhancements:
+  * Rails 3.0.0.beta4 and Rails 2.3.x compatible
+  * When used with Rails 3 then works together with Oracle SQL compiler included in Arel gem (http://github.com/rails/arel)
+  * Rails 3: Better support for limit and offset (when possible adds just ROWNUM condition in WHERE clause without using subqueries)
+  * Table and column names are always quoted and in uppercase to avoid the need for checking Oracle reserved words
+  * Full text search index creation (add_context_index and remove_context_index methods in migrations and #contains method in ActiveRecord models)
+  * add_index and remove_index give just warnings on wrong index names (new expected behavior in Rails 2.3.8 and 3.0.0)
+  * :tablespace and :options options for create_table and add_index
+* Workarounds:
+  * Rails 3: set ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.cache_columns = true in initializer file for all environments
+    (to avoid too many data dictionary queries from Arel)
+  * Rails 2.3: patch several ActiveRecord methods to work correctly with quoted table names in uppercase (see oracle_enhanced_activerecord_patches.rb).
+    These patches are already included in Rails 3.0.0.beta4.
+* Bug fixes:
+  * Fixes for schema purge (drop correctly materialized views)
+  * Fixes for schema dump and structure dump (use correct statement separator)
+  * Only use Oracle specific schema dump for Oracle connections
+
 == 1.2.4 2010-02-23
 
 * Enhancements:

data/README.rdoc

@@ -15,10 +15,10 @@ Blog posts about oracle-enahnced can be found at http://blog.rayapps.com/categor
 
 == REQUIREMENTS:
 
-* Works (has been tested) with ActiveRecord version 2.0, 2.1, 2.2 and 2.3 (these are the same as Rails versions)
+* Latest version works (has been tested) with ActiveRecord version 2.3 and 3.0 (these are the same as Rails versions)
 * Can be used on the following Ruby platforms:
-  * MRI - requires ruby-oci8 1.x or 2.x gem to connect to Oracle (2.0.3 or later recommended)
-  * Ruby/YARV 1.9.1 - requires ruby-oci8 2.x library to connect to Oracle
+  * MRI - requires ruby-oci8 2.0 gem to connect to Oracle (2.0.4 or later recommended)
+  * Ruby/YARV 1.9.1 or 1.9.2 - requires ruby-oci8 2.0 library to connect to Oracle
     unicode_utils gem is recommended for Unicode aware string upcase and downcase
   * JRuby - uses JDBC driver ojdbc14.jar to connect to Oracle (should be in JRUBY_HOME/lib or in Java class path)
 * Requires ruby-plsql gem to support custom create, update and delete methods (but can be used without ruby-plsql if this functionality is not needed)
@@ -50,6 +50,10 @@ In addition install either ruby-oci8 (for MRI/YARV) or copy Oracle JDBC driver t
 * Alex Rothenberg
 * Billy Reisinger
 * David Blain
+* Joe Khoobyar
+* Edvard Majakari
+* Beau Fabry
+* Simon Chiang
 
 == LICENSE:
 

data/Rakefile

@@ -13,8 +13,7 @@ EOS
     gem.email = "raimonds.simanovskis@gmail.com"
     gem.homepage = "http://github.com/rsim/oracle-enhanced"
     gem.authors = ["Raimonds Simanovskis"]
-    gem.add_dependency "activerecord", ">= 2.0.0"
-    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "rspec", ">= 1.3.0"
     gem.extra_rdoc_files = ['README.rdoc']
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-1.2.4
+1.3.0

data/activerecord-oracle_enhanced-adapter.gemspec

@@ -0,0 +1,96 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{activerecord-oracle_enhanced-adapter}
+  s.version = "1.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Raimonds Simanovskis"]
+  s.date = %q{2010-06-21}
+  s.description = %q{Oracle "enhanced" ActiveRecord adapter contains useful additional methods for working with new and legacy Oracle databases.
+This adapter is superset of original ActiveRecord Oracle adapter.
+}
+  s.email = %q{raimonds.simanovskis@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "History.txt",
+     "License.txt",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "activerecord-oracle_enhanced-adapter.gemspec",
+     "lib/active_record/connection_adapters/emulation/oracle_adapter.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced.rake",
+     "lib/active_record/connection_adapters/oracle_enhanced_activerecord_patches.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_adapter.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_connection.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_context_index.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_core_ext.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_cpk.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_dirty.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_procedures.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_schema_definitions.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_schema_dumper.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_schema_statements_ext.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_tasks.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_version.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_adapter_structure_dumper_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_connection_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_context_index_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_core_ext_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_cpk_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_data_types_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_dbms_output_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_dirty_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_emulate_oracle_adapter_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_procedures_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_schema_dump_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_schema_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/rsim/oracle-enhanced}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Oracle enhanced adapter for ActiveRecord}
+  s.test_files = [
+    "spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_adapter_structure_dumper_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_connection_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_context_index_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_core_ext_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_cpk_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_data_types_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_dbms_output_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_dirty_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_emulate_oracle_adapter_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_procedures_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_schema_dump_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_schema_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.3.0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.3.0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.3.0"])
+  end
+end
+

data/lib/active_record/connection_adapters/oracle_enhanced.rake

@@ -15,14 +15,14 @@ namespace :db do
   namespace :structure do
     redefine_task :dump => :environment 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 }
+      rails_env = defined?(Rails.env) ? Rails.env : RAILS_ENV
+      ActiveRecord::Base.establish_connection(abcs[rails_env])
+      File.open("db/#{rails_env}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
       if ActiveRecord::Base.connection.supports_migrations?
-        File.open("db/#{RAILS_ENV}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+        File.open("db/#{rails_env}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
       end
-      if abcs[RAILS_ENV]['structure_dump'] == "db_stored_code"
-         File.open("db/#{RAILS_ENV}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.structure_dump_db_stored_code }
+      if abcs[rails_env]['structure_dump'] == "db_stored_code"
+         File.open("db/#{rails_env}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.structure_dump_db_stored_code }
       end
 
     end
@@ -31,8 +31,10 @@ namespace :db do
   namespace :test do
     redefine_task :clone_structure => [ "db:structure:dump", "db:test:purge" ] do
       abcs = ActiveRecord::Base.configurations
+      rails_env = defined?(Rails.env) ? Rails.env : RAILS_ENV
       ActiveRecord::Base.establish_connection(:test)
-      IO.readlines("db/#{RAILS_ENV}_structure.sql").join.split("\n\n").each do |ddl|
+      File.read("db/#{rails_env}_structure.sql").
+            split(ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter::STATEMENT_TOKEN).each do |ddl|
         ddl.chop! if ddl.last == ";"
         ActiveRecord::Base.connection.execute(ddl) unless ddl.blank?
       end
@@ -41,7 +43,8 @@ namespace :db do
     redefine_task :purge => :environment do
       abcs = ActiveRecord::Base.configurations
       ActiveRecord::Base.establish_connection(:test)
-      ActiveRecord::Base.connection.full_drop.split("\n\n").each do |ddl|
+      ActiveRecord::Base.connection.full_drop.
+            split(ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter::STATEMENT_TOKEN).each do |ddl|
         ddl.chop! if ddl.last == ";"
         ActiveRecord::Base.connection.execute(ddl) unless ddl.blank?
       end

data/lib/active_record/connection_adapters/oracle_enhanced_activerecord_patches.rb

@@ -0,0 +1,37 @@
+# ActiveRecord 2.3 patches
+if ActiveRecord::VERSION::MAJOR == 2 && ActiveRecord::VERSION::MINOR == 3
+  require "active_record/associations"
+
+  ActiveRecord::Associations::ClassMethods.module_eval do
+    private
+    def tables_in_string(string)
+      return [] if string.blank?
+      # always convert table names to downcase as in Oracle quoted table names are in uppercase
+      # ignore raw_sql_ that is used by Oracle adapter as alias for limit/offset subqueries
+      string.scan(/([a-zA-Z_][\.\w]+).?\./).flatten.map(&:downcase).uniq - ['raw_sql_']
+    end
+  end
+
+  ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.class_eval do
+    protected
+    def aliased_table_name_for(name, suffix = nil)
+      # always downcase quoted table name as Oracle quoted table names are in uppercase
+      if !parent.table_joins.blank? && parent.table_joins.to_s.downcase =~ %r{join(\s+\w+)?\s+#{active_record.connection.quote_table_name(name).downcase}\son}
+        @join_dependency.table_aliases[name] += 1
+      end
+
+      unless @join_dependency.table_aliases[name].zero?
+        # if the table name has been used, then use an alias
+        name = active_record.connection.table_alias_for "#{pluralize(reflection.name)}_#{parent_table_name}#{suffix}"
+        table_index = @join_dependency.table_aliases[name]
+        @join_dependency.table_aliases[name] += 1
+        name = name[0..active_record.connection.table_alias_length-3] + "_#{table_index+1}" if table_index > 0
+      else
+        @join_dependency.table_aliases[name] += 1
+      end
+
+      name
+    end
+  end
+
+end

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -29,8 +29,10 @@
 # contribution.
 # portions Copyright 2005 Graham Jenkins
 
-require 'active_record/connection_adapters/abstract_adapter'
+# ActiveRecord 2.2 does not load version file automatically
+require 'active_record/version' unless defined?(ActiveRecord::VERSION)
 
+require 'active_record/connection_adapters/abstract_adapter'
 require 'active_record/connection_adapters/oracle_enhanced_connection'
 
 require 'digest/sha1'
@@ -91,7 +93,7 @@ module ActiveRecord
     # Specify which table columns should be typecasted to string values.
     # Might be useful to specify that columns should be string even if its name matches boolean column criteria.
     # 
-    #   set_integer_columns :active_flag
+    #   set_string_columns :active_flag
     def self.set_string_columns(*args)
       connection.set_type_for_columns(table_name,:string,*args)
     end
@@ -106,33 +108,7 @@ module ActiveRecord
       end
     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_without_lobs!, :add_order!
-      alias_method :add_order!, :add_order_with_lobs!
-      #:startdoc:
-    end
-    
+
     # Get table comment from schema definition.
     def self.table_comment
       connection.table_comment(self.table_name)
@@ -236,7 +212,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
@@ -403,6 +379,7 @@ module ActiveRecord
       def initialize(connection, logger = nil) #:nodoc:
         super
         @quoted_column_names, @quoted_table_names = {}, {}
+        @enable_dbms_output = false
       end
 
       ADAPTER_NAME = 'OracleEnhanced'.freeze
@@ -415,6 +392,10 @@ module ActiveRecord
         true
       end
 
+      def supports_primary_key? #:nodoc:
+        true
+      end
+
       def supports_savepoints? #:nodoc:
         true
       end
@@ -453,6 +434,21 @@ module ActiveRecord
         IDENTIFIER_MAX_LENGTH
       end
 
+      # the maximum length of a table name
+      def table_name_length
+        IDENTIFIER_MAX_LENGTH
+      end
+
+      # the maximum length of a column name
+      def column_name_length
+        IDENTIFIER_MAX_LENGTH
+      end
+
+      # the maximum length of an index name
+      def index_name_length
+        IDENTIFIER_MAX_LENGTH
+      end
+
       # QUOTING ==================================================
       #
       # see: abstract/quoting.rb
@@ -460,26 +456,52 @@ 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] ||= begin
+          case name
+          # if only valid column characters in name
+          when /^[a-z][a-z_0-9\$#]*$/
+            "\"#{name.upcase}\""
+          when /^[a-z][a-z_0-9\$#\-]*$/i
+            "\"#{name}\""
+          # if other characters present then assume that it is expression
+          # which should not be quoted
+          else
+            name
+          end
+        end
       end
 
+      # Names must be from 1 to 30 bytes long with these exceptions:
+      # * Names of databases are limited to 8 bytes.
+      # * Names of database links can be as long as 128 bytes.
+      #  
+      # Nonquoted identifiers cannot be Oracle Database reserved words
+      #  
+      # Nonquoted identifiers must begin with an alphabetic character from
+      # your database character set
+      #  
+      # Nonquoted identifiers can contain only alphanumeric characters from
+      # your database character set and the underscore (_), dollar sign ($),
+      # and pound sign (#). Database links can also contain periods (.) and
+      # "at" signs (@). Oracle strongly discourages you from using $ and # in
+      # nonquoted identifiers.
+      NONQUOTED_OBJECT_NAME   = /[A-Za-z][A-z0-9$#]{0,29}/
+      NONQUOTED_DATABASE_LINK = /[A-Za-z][A-z0-9$#\.@]{0,127}/
+      VALID_TABLE_NAME = /\A(?:#{NONQUOTED_OBJECT_NAME}\.)?#{NONQUOTED_OBJECT_NAME}(?:@#{NONQUOTED_DATABASE_LINK})?\Z/
+
       # unescaped table name should start with letter and
       # contain letters, digits, _, $ or #
       # can be prefixed with schema name
       # CamelCase table names should be quoted
       def self.valid_table_name?(name) #:nodoc:
-        name = name.to_s
-        name =~ /\A([A-Za-z_0-9]+\.)?[a-z][a-z_0-9\$#]*(@[A-Za-z_0-9\.]+)?\Z/ ||
-        name =~ /\A([A-Za-z_0-9]+\.)?[A-Z][A-Z_0-9\$#]*(@[A-Za-z_0-9\.]+)?\Z/ ? true : false
+        name = name.to_s 
+        name =~ VALID_TABLE_NAME && !(name =~ /[A-Z]/ && name =~ /[a-z]/) ? true : false
       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:
@@ -580,7 +602,8 @@ module ActiveRecord
       # Executes a SQL statement
       def execute(sql, name = nil)
         # hack to pass additional "with_returning" option without changing argument list
-        log(sql, name) { sql.instance_variable_get(:@with_returning) ? @connection.exec_with_returning(sql) : @connection.exec(sql) }
+        log(sql, name) { sql.instance_variable_defined?(:@with_returning) && sql.instance_variable_get(:@with_returning) ?
+          @connection.exec_with_returning(sql) : @connection.exec(sql) }
       end
 
       # Returns an array of arrays containing the field values.
@@ -603,7 +626,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 +673,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
@@ -706,13 +730,12 @@ module ActiveRecord
           next if value.nil?  || (value == '')
           value = value.to_yaml if col.text? && klass.serialized_attributes[col.name]
           uncached do
-            if is_with_cpk
-              lob = select_one("SELECT #{col.name} FROM #{table_name} WHERE #{klass.composite_where_clause(id)} FOR UPDATE",
-                                'Writable Large Object')[col.name]
-            else
-              lob = select_one("SELECT #{col.name} FROM #{table_name} WHERE #{klass.primary_key} = #{id} FOR UPDATE",
-                               'Writable Large Object')[col.name]
+            sql = is_with_cpk ? "SELECT #{col.name} FROM #{table_name} WHERE #{klass.composite_where_clause(id)} FOR UPDATE" :
+              "SELECT #{col.name} FROM #{table_name} WHERE #{klass.primary_key} = #{id} FOR UPDATE"
+            unless lob_record = select_one(sql, 'Writable Large Object')
+              raise ActiveRecord::RecordNotFound, "statement #{sql} returned no rows"
             end
+            lob = lob_record[col.name]
             @connection.write_lob(lob, value.to_s, col.type == :binary)
           end
         end
@@ -755,8 +778,21 @@ 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
+
+      # Will return true if database object exists (to be able to use also views and synonyms for ActiveRecord models)
+      def table_exists?(table_name)
+        (owner, table_name, db_link) = @connection.describe(table_name)
+        true
+      rescue
+        false
+      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 +804,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 +826,24 @@ 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'] || row['column_name'].downcase)
           end
         end
 
@@ -852,7 +906,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 +920,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 +929,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,
@@ -911,7 +965,10 @@ module ActiveRecord
           # clean up odd default spacing from Oracle
           if row['data_default']
             row['data_default'].sub!(/^(.*?)\s*$/, '\1')
-            row['data_default'].sub!(/^'(.*)'$/, '\1')
+
+            # If a default contains a newline these cleanup regexes need to 
+            # match newlines.
+            row['data_default'].sub!(/^'(.*)'$/m, '\1')
             row['data_default'] = nil if row['data_default'] =~ /^(null|empty_[bc]lob\(\))$/i
           end
 
@@ -929,11 +986,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
 
       ##
@@ -1008,7 +1069,7 @@ 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]}" : ""
 
         if options[:force] && table_exists?(name)
           drop_table(name, options)
@@ -1017,7 +1078,7 @@ module ActiveRecord
         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]}"
+        create_sql << ")#{tablespace} #{options[:options]}"
         execute create_sql
         
         create_sequence_and_trigger(name, options) if create_sequence
@@ -1044,51 +1105,86 @@ module ActiveRecord
 
       # clear cached indexes when adding new index
       def add_index(table_name, column_name, options = {}) #:nodoc:
-        self.all_schema_indexes = nil
         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
+          tablespace = options[:tablespace] ? " TABLESPACE #{options[:tablespace]}" : ""
         else
           index_type = options
         end
+
+        if index_name.to_s.length > index_name_length
+          @logger.warn("Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters. Skipping.") if @logger
+          return
+        end
+        if index_exists?(table_name, index_name, false)
+          @logger.warn("Index name '#{index_name}' on table '#{table_name}' already exists. Skipping.") if @logger
+          return
+        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}"
+
+        execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})#{tablespace} #{options[:options]}"
+      ensure
+        self.all_schema_indexes = nil
       end
 
-      # clear cached indexes when removing index
+      # Remove the given index from the table.
+      # Gives warning if index does not exist
       def remove_index(table_name, options = {}) #:nodoc:
+        index_name = index_name(table_name, options)
+        unless index_exists?(table_name, index_name, true)
+          @logger.warn("Index name '#{index_name}' on table '#{table_name}' does not exist. Skipping.") if @logger
+          return
+        end
+        remove_index!(table_name, index_name)
+      end
+
+      # clear cached indexes when removing index
+      def remove_index!(table_name, index_name) #:nodoc:
+        execute "DROP INDEX #{quote_column_name(index_name)}"
+      ensure
         self.all_schema_indexes = nil
-        execute "DROP INDEX #{index_name(table_name, options)}"
       end
-      
+
       # 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
       end
 
+      # Verify the existence of an index (always query database).
+      def index_exists?(table_name, index_name, default) #:nodoc:
+        (owner, table_name, db_link) = @connection.describe(table_name)
+        result = select_value(<<-SQL)
+          SELECT 1 FROM all_indexes#{db_link} i
+          WHERE i.owner = '#{owner}'
+             AND i.table_owner = '#{owner}'
+             AND i.table_name = '#{table_name}'
+             AND i.index_name = '#{index_name.to_s.upcase}'
+        SQL
+        result == 1 ? true : false
+      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
@@ -1182,15 +1278,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
 
-        # changed select from all_constraints to user_constraints - much faster in large data dictionaries
+      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 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 +1305,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 +1342,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 +1360,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 +1376,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 +1401,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 +1421,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 +1448,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 +1474,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 +1577,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 +1652,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 +1672,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 =============================================
       #
@@ -1607,7 +1742,7 @@ module ActiveRecord
         while true do
           result = plsql(:dbms_output).sys.dbms_output.get_line(:line => '', :status => 0)
           break unless result[:status] == 0
-          @logger.debug "DBMS_OUTPUT: #{result[:line]}"
+          @logger.debug "DBMS_OUTPUT: #{result[:line]}" if @logger
         end
       end
 
@@ -1641,10 +1776,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)
-
-# Handles quoting of oracle reserved words
-require 'active_record/connection_adapters/oracle_enhanced_reserved_words'
+end if defined?(Rails.root) || defined?(RAILS_ROOT)
 
 # Patches and enhancements for schema dumper
 require 'active_record/connection_adapters/oracle_enhanced_schema_dumper'
@@ -1655,7 +1787,12 @@ 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'
 
+require 'active_record/connection_adapters/oracle_enhanced_activerecord_patches'
+
 require 'active_record/connection_adapters/oracle_enhanced_version'