activerecord-oracle_enhanced-adapter 1.3.0 → 1.3.1

data/.gitignore

@@ -1,3 +1,5 @@
+.bundle
+.rvmrc
 .svn
 .DS_Store
 coverage
@@ -6,4 +8,4 @@ pkg
 log
 tmp
 sqlnet.log
-
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,37 @@
+source 'http://rubygems.org'
+
+gem 'jeweler'
+gem 'rspec', "~> 1.3.0"
+
+if ENV['RAILS_GEM_VERSION']
+  gem 'activerecord', "=#{ENV['RAILS_GEM_VERSION']}"
+  gem 'actionpack', "=#{ENV['RAILS_GEM_VERSION']}"
+  gem 'activesupport', "=#{ENV['RAILS_GEM_VERSION']}"
+  case ENV['RAILS_GEM_VERSION']
+  when /^2.0/
+    gem 'composite_primary_keys', '=0.9.93'
+  when /^2.1/
+    gem 'composite_primary_keys', '=1.0.8'
+  when /^2.2/
+    gem 'composite_primary_keys', '=2.2.2'
+  when /^2.3.3/
+    gem 'composite_primary_keys', '=2.3.2'
+  when /^3/
+    gem 'railties', "=#{ENV['RAILS_GEM_VERSION']}"
+  end
+else
+  # uses local copy of Rails 3 and Arel gems
+  ENV['RAILS_GEM_PATH'] ||= '../rails'
+  %w(activerecord activemodel activesupport actionpack railties).each do |gem_name|
+    gem gem_name, :path => File.join(ENV['RAILS_GEM_PATH'], gem_name)
+  end
+
+  ENV['AREL_GEM_PATH'] ||= '../arel'
+  gem 'arel', :path => ENV['AREL_GEM_PATH']
+end
+
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
+  gem 'ruby-oci8', '>=2.0.4'
+end
+
+gem 'ruby-plsql', '>=0.4.3'

data/History.txt

@@ -1,3 +1,20 @@
+== 1.3.1 2010-09-09
+
+* Enhancements:
+  * Tested with Rails 3.0.0 release
+  * Lexer options for context index creation
+  * Added Bundler for running adapter specs, added RUNNING_TESTS.rdoc with description how to run specs
+  * Connection to database using :host, :port and :database options
+  * Improved loading of adapter in Rails 3 using railtie
+* Bug fixes:
+  * Fix for custom context index procedure when indexing records with null values
+  * Quote table and column names in write_lobs callback
+  * Fix for incorrect column SQL types when two models use the same table and AR query cache is enabled
+  * Fixes for schema and scructure dump tasks
+  * Fix for handling of zero-length strings in BLOB and CLOB columns
+  * removed String.mb_chars upcase and downcase methods for Ruby 1.9 as Rails 3.0.0 already includes Unicode aware upcase and downcase methods for Ruby 1.9
+  * Fixes for latest ActiveRecord unit tests
+
 == 1.3.0 2010-06-21
 
 * Enhancements:

data/README.rdoc

@@ -11,16 +11,15 @@ See http://wiki.github.com/rsim/oracle-enhanced for usage information.
 
 For questions and feature discussion please use http://groups.google.com/group/oracle-enhanced
 
-Blog posts about oracle-enahnced can be found at http://blog.rayapps.com/category/oracle-enhanced
+Blog posts about oracle_enhanced can be found at http://blog.rayapps.com/category/oracle_enhanced
 
 == REQUIREMENTS:
 
 * 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 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)
+  * Ruby/YARV 1.9.2 - requires ruby-oci8 2.0 library to connect to Oracle
+  * JRuby 1.5 - 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)
 
 == INSTALL:
@@ -29,6 +28,10 @@ Blog posts about oracle-enahnced can be found at http://blog.rayapps.com/categor
 
 In addition install either ruby-oci8 (for MRI/YARV) or copy Oracle JDBC driver to $JRUBY_HOME/lib (for JRuby).
 
+== RUNNING TESTS:
+
+See RUNNING_TESTS.rdoc
+
 == LINKS
 
 * Source code: http://github.com/rsim/oracle-enhanced
@@ -54,6 +57,8 @@ In addition install either ruby-oci8 (for MRI/YARV) or copy Oracle JDBC driver t
 * Edvard Majakari
 * Beau Fabry
 * Simon Chiang
+* Peter Nyberg
+* Dwayne Litzenberger
 
 == LICENSE:
 

data/RUNNING_TESTS.rdoc

@@ -0,0 +1,28 @@
+== Creating the test database
+
+You need Oracle database (version 10.2 or later) with SYS and SYSTEM use access.
+
+If you are on a Mac OS X 10.6 then use these instructions http://blog.rayapps.com/2009/09/14/how-to-install-oracle-database-10g-on-mac-os-x-snow-leopard to install local Oracle DB 10.2.0.4. Other option is to use Linux VM and install Oracle DB on it.
+
+If you are on Linux (or will use Linux virtual machine) and need Oracle DB just for running tests then Oracle DB XE edition is enough. See http://www.oracle.com/technetwork/database/express-edition/downloads/index.html for download links and instructions.
+
+If you are getting ORA-12520 errors when running tests then it means that Oracle cannot create enough processes to handle many connections (as during tests many connections are created and destroyed). In this case you need to log in as SYSTEM user and execute e.g.
+    alter system set processes=200 scope=spfile;
+to increase process limit and then restart the database (this will be necessary if Oracle XE will be used as default processes limit is 40).
+
+== Ruby versions
+
+It is recommended to use RVM (http://rvm.beginrescueend.com) to run tests with different Ruby implementations. oracle_enhanced is mainly tested with MRI 1.8.7 (all Rails versions) and 1.9.2 (Rails 3) and JRuby 1.5.
+
+== Running tests
+
+* Create Oracle database schema for test purposes. Review spec/spec_helper.rb to see default schema/user names and database names (use environment variables to override defaults)
+* If you use RVM then switch to corresponding Ruby (1.8.7, 1.9.2 or JRuby) and it is recommended to create isolated gemset for test purposes (e.g. rvm create gemset oracle_enhanced)
+* Install bundler with
+    gem install bundler
+* Set RAILS_GEM_VERSION to Rails version that you would like to use in oracle_enhanced tests, e.g.
+    export RAILS_GEM_VERSION=3.0.0
+* Install necessary gems with
+    bundle install
+* Run tests with
+    rake spec

data/VERSION

@@ -1 +1 @@
-1.3.0
+1.3.1

data/activerecord-oracle_enhanced-adapter.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{activerecord-oracle_enhanced-adapter}
-  s.version = "1.3.0"
+  s.version = "1.3.1"
 
   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.date = %q{2010-09-09}
   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.
 }
@@ -19,9 +19,11 @@ This adapter is superset of original ActiveRecord Oracle adapter.
   ]
   s.files = [
     ".gitignore",
+     "Gemfile",
      "History.txt",
      "License.txt",
      "README.rdoc",
+     "RUNNING_TESTS.rdoc",
      "Rakefile",
      "VERSION",
      "activerecord-oracle_enhanced-adapter.gemspec",
@@ -29,6 +31,8 @@ This adapter is superset of original ActiveRecord Oracle adapter.
      "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_base_ext.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_column.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",
@@ -39,11 +43,13 @@ This adapter is superset of original ActiveRecord Oracle adapter.
      "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.rb",
      "lib/active_record/connection_adapters/oracle_enhanced_schema_statements_ext.rb",
+     "lib/active_record/connection_adapters/oracle_enhanced_structure_dump.rb",
      "lib/active_record/connection_adapters/oracle_enhanced_tasks.rb",
      "lib/active_record/connection_adapters/oracle_enhanced_version.rb",
+     "lib/activerecord-oracle_enhanced-adapter.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",
@@ -54,7 +60,8 @@ This adapter is superset of original ActiveRecord Oracle adapter.
      "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/active_record/connection_adapters/oracle_enhanced_schema_statements_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_structure_dump_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb"
   ]
@@ -65,7 +72,6 @@ This adapter is superset of original ActiveRecord Oracle adapter.
   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",
@@ -76,7 +82,8 @@ This adapter is superset of original ActiveRecord Oracle adapter.
      "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/active_record/connection_adapters/oracle_enhanced_schema_statements_spec.rb",
+     "spec/active_record/connection_adapters/oracle_enhanced_structure_dump_spec.rb",
      "spec/spec_helper.rb"
   ]
 

data/lib/active_record/connection_adapters/oracle_enhanced.rake

@@ -1,52 +1,60 @@
-# RSI: implementation idea taken from JDBC adapter
+# implementation idea taken from JDBC adapter
+# added possibility to execute previously defined task (passed as argument to task block)
 def redefine_task(*args, &block)
   task_name = Hash === args.first ? args.first.keys[0] : args.first
   existing_task = Rake.application.lookup task_name
+  existing_actions = nil
   if existing_task
-    class << existing_task; public :instance_variable_set; end
+    class << existing_task; public :instance_variable_set, :instance_variable_get; end
     existing_task.instance_variable_set "@prerequisites", FileList[]
+    existing_actions = existing_task.instance_variable_get "@actions"
     existing_task.instance_variable_set "@actions", []
   end
-  task(*args, &block)
+  task(*args) do
+    block.call(existing_actions)
+  end
 end
 
 namespace :db do
 
   namespace :structure do
-    redefine_task :dump => :environment do
+    redefine_task :dump => :environment do |existing_actions|
       abcs = ActiveRecord::Base.configurations
       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 }
-      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]['adapter'] == 'oracle_enhanced'
+        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 }
+        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 }
+        end
+      else
+        Array(existing_actions).each{|action| action.call}
       end
-
     end
   end
 
   namespace :test do
-    redefine_task :clone_structure => [ "db:structure:dump", "db:test:purge" ] do
+    redefine_task :clone_structure => [ "db:structure:dump", "db:test:purge" ] do |existing_actions|
       abcs = ActiveRecord::Base.configurations
       rails_env = defined?(Rails.env) ? Rails.env : RAILS_ENV
-      ActiveRecord::Base.establish_connection(:test)
-      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?
+      if abcs[rails_env]['adapter'] == 'oracle_enhanced' && abcs['test']['adapter'] == 'oracle_enhanced'
+        ActiveRecord::Base.establish_connection(:test)
+        ActiveRecord::Base.connection.execute_structure_dump(File.read("db/#{rails_env}_structure.sql"))
+      else
+        Array(existing_actions).each{|action| action.call}
       end
     end
 
-    redefine_task :purge => :environment do
+    redefine_task :purge => :environment do |existing_actions|
       abcs = ActiveRecord::Base.configurations
-      ActiveRecord::Base.establish_connection(:test)
-      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?
+      if abcs['test']['adapter'] == 'oracle_enhanced'
+        ActiveRecord::Base.establish_connection(:test)
+        ActiveRecord::Base.connection.execute_structure_dump(ActiveRecord::Base.connection.full_drop)
+      else
+        Array(existing_actions).each{|action| action.call}
       end
     end
 

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -35,189 +35,13 @@ require 'active_record/version' unless defined?(ActiveRecord::VERSION)
 require 'active_record/connection_adapters/abstract_adapter'
 require 'active_record/connection_adapters/oracle_enhanced_connection'
 
+require 'active_record/connection_adapters/oracle_enhanced_base_ext'
+require 'active_record/connection_adapters/oracle_enhanced_column'
+
 require 'digest/sha1'
 
 module ActiveRecord
-  class Base
-    # Establishes a connection to the database that's used by all Active Record objects.
-    def self.oracle_enhanced_connection(config) #:nodoc:
-      if config[:emulate_oracle_adapter] == true
-        # allows the enhanced adapter to look like the OracleAdapter. Useful to pick up
-        # conditionals in the rails activerecord test suite
-        require 'active_record/connection_adapters/emulation/oracle_adapter'
-        ConnectionAdapters::OracleAdapter.new(
-          ConnectionAdapters::OracleEnhancedConnection.create(config), logger)
-      else
-        ConnectionAdapters::OracleEnhancedAdapter.new(
-          ConnectionAdapters::OracleEnhancedConnection.create(config), logger)
-      end
-    end
-
-    # Specify table columns which should be ignored by ActiveRecord, e.g.:
-    # 
-    #   ignore_table_columns :attribute1, :attribute2
-    def self.ignore_table_columns(*args)
-      connection.ignore_table_columns(table_name,*args)
-    end
-
-    # Specify which table columns should be typecasted to Date (without time), e.g.:
-    # 
-    #   set_date_columns :created_on, :updated_on
-    def self.set_date_columns(*args)
-      connection.set_type_for_columns(table_name,:date,*args)
-    end
-
-    # Specify which table columns should be typecasted to Time (or DateTime), e.g.:
-    # 
-    #   set_datetime_columns :created_date, :updated_date
-    def self.set_datetime_columns(*args)
-      connection.set_type_for_columns(table_name,:datetime,*args)
-    end
-
-    # Specify which table columns should be typecasted to boolean values +true+ or +false+, e.g.:
-    # 
-    #   set_boolean_columns :is_valid, :is_completed
-    def self.set_boolean_columns(*args)
-      connection.set_type_for_columns(table_name,:boolean,*args)
-    end
-
-    # Specify which table columns should be typecasted to integer values.
-    # Might be useful to force NUMBER(1) column to be integer and not boolean, or force NUMBER column without
-    # scale to be retrieved as integer and not decimal. Example:
-    # 
-    #   set_integer_columns :version_number, :object_identifier
-    def self.set_integer_columns(*args)
-      connection.set_type_for_columns(table_name,:integer,*args)
-    end
-
-    # 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_string_columns :active_flag
-    def self.set_string_columns(*args)
-      connection.set_type_for_columns(table_name,:string,*args)
-    end
-
-    # After setting large objects to empty, select the OCI8::LOB
-    # and write back the data.
-    after_save :enhanced_write_lobs
-    def enhanced_write_lobs #:nodoc:
-      if connection.is_a?(ConnectionAdapters::OracleEnhancedAdapter) &&
-          !(self.class.custom_create_method || self.class.custom_update_method)
-        connection.write_lobs(self.class.table_name, self.class, attributes)
-      end
-    end
-    private :enhanced_write_lobs
-
-    # Get table comment from schema definition.
-    def self.table_comment
-      connection.table_comment(self.table_name)
-    end
-  end
-
-
   module ConnectionAdapters #:nodoc:
-    class OracleEnhancedColumn < Column
-
-      attr_reader :table_name, :forced_column_type #:nodoc:
-      
-      def initialize(name, default, sql_type = nil, null = true, table_name = nil, forced_column_type = nil) #:nodoc:
-        @table_name = table_name
-        @forced_column_type = forced_column_type
-        super(name, default, sql_type, null)
-      end
-
-      def type_cast(value) #:nodoc:
-        return guess_date_or_time(value) if type == :datetime && OracleEnhancedAdapter.emulate_dates
-        super
-      end
-
-      # convert something to a boolean
-      # added y as boolean value
-      def self.value_to_boolean(value) #:nodoc:
-        if value == true || value == false
-          value
-        elsif value.is_a?(String) && value.blank?
-          nil
-        else
-          %w(true t 1 y +).include?(value.to_s.downcase)
-        end
-      end
-
-      # convert Time or DateTime value to Date for :date columns
-      def self.string_to_date(string) #:nodoc:
-        return string.to_date if string.is_a?(Time) || string.is_a?(DateTime)
-        super
-      end
-
-      # convert Date value to Time for :datetime columns
-      def self.string_to_time(string) #:nodoc:
-        return string.to_time if string.is_a?(Date) && !OracleEnhancedAdapter.emulate_dates
-        super
-      end
-
-      # Get column comment from schema definition.
-      # Will work only if using default ActiveRecord connection.
-      def comment
-        ActiveRecord::Base.connection.column_comment(@table_name, name)
-      end
-      
-      private
-      def simplified_type(field_type)
-        forced_column_type ||
-        case field_type
-          when /decimal|numeric|number/i
-            return :boolean if OracleEnhancedAdapter.emulate_booleans && field_type == 'NUMBER(1)'
-            return :integer if extract_scale(field_type) == 0
-            # if column name is ID or ends with _ID
-            return :integer if OracleEnhancedAdapter.emulate_integers_by_column_name && OracleEnhancedAdapter.is_integer_column?(name, table_name)
-            :decimal
-          when /char/i
-            return :boolean if OracleEnhancedAdapter.emulate_booleans_from_strings &&
-                               OracleEnhancedAdapter.is_boolean_column?(name, field_type, table_name)
-            :string
-          when /date/i
-            forced_column_type ||
-            (:date if OracleEnhancedAdapter.emulate_dates_by_column_name && OracleEnhancedAdapter.is_date_column?(name, table_name)) ||
-            :datetime
-          when /timestamp/i then :timestamp
-          when /time/i then :datetime
-          else super
-        end
-      end
-
-      def guess_date_or_time(value)
-        value.respond_to?(:hour) && (value.hour == 0 and value.min == 0 and value.sec == 0) ?
-          Date.new(value.year, value.month, value.day) : value
-      end
-      
-      class << self
-        protected
-
-        def fallback_string_to_date(string) #:nodoc:
-          if OracleEnhancedAdapter.string_to_date_format || OracleEnhancedAdapter.string_to_time_format
-            return (string_to_date_or_time_using_format(string).to_date rescue super)
-          end
-          super
-        end
-
-        def fallback_string_to_time(string) #:nodoc:
-          if OracleEnhancedAdapter.string_to_time_format || OracleEnhancedAdapter.string_to_date_format
-            return (string_to_date_or_time_using_format(string).to_time rescue super)
-          end
-          super
-        end
-
-        def string_to_date_or_time_using_format(string) #:nodoc:
-          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).to_date
-        end
-        
-      end
-    end
-
 
     # Oracle enhanced adapter will work with both
     # Ruby 1.8/1.9 ruby-oci8 gem (which provides interface to Oracle OCI client)
@@ -730,8 +554,8 @@ module ActiveRecord
           next if value.nil?  || (value == '')
           value = value.to_yaml if col.text? && klass.serialized_attributes[col.name]
           uncached do
-            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"
+            sql = is_with_cpk ? "SELECT #{quote_column_name(col.name)} FROM #{quote_table_name(table_name)} WHERE #{klass.composite_where_clause(id)} FOR UPDATE" :
+              "SELECT #{quote_column_name(col.name)} FROM #{quote_table_name(table_name)} WHERE #{quote_column_name(klass.primary_key)} = #{id} FOR UPDATE"
             unless lob_record = select_one(sql, 'Writable Large Object')
               raise ActiveRecord::RecordNotFound, "statement #{sql} returned no rows"
             end
@@ -741,27 +565,6 @@ module ActiveRecord
         end
       end
 
-      # change LOB column for ORDER BY clause
-      # just first 100 characters are taken for ordering
-      def lob_order_by_expression(klass, order) #:nodoc:
-        return order if order.nil?
-        changed = false
-        new_order = order.to_s.strip.split(/, */).map do |order_by_col|
-          column_name, asc_desc = order_by_col.split(/ +/)
-          if column = klass.columns.detect { |col| col.name == column_name && col.sql_type =~ /LOB$/i}
-            changed = true
-            "DBMS_LOB.SUBSTR(#{column_name},100,1) #{asc_desc}"
-          else
-            order_by_col
-          end
-        end.join(', ')
-        changed ? new_order : order
-      end
-
-      # SCHEMA STATEMENTS ========================================
-      #
-      # see: abstract/schema_statements.rb
-
       # Current database name
       def current_database
         select_value("select sys_context('userenv','db_name') from dual")
@@ -959,7 +762,7 @@ module ActiveRecord
         end.map do |row|
           limit, scale = row['limit'], row['scale']
           if limit || scale
-            row['sql_type'] << "(#{(limit || 38).to_i}" + ((scale = scale.to_i) > 0 ? ",#{scale})" : ")")
+            row['sql_type'] += "(#{(limit || 38).to_i}" + ((scale = scale.to_i) > 0 ? ",#{scale})" : ")")
           end
 
           # clean up odd default spacing from Oracle
@@ -1005,277 +808,6 @@ module ActiveRecord
       cattr_accessor :default_sequence_start_value
       self.default_sequence_start_value = 10000
 
-      # Additional options for +create_table+ method in migration files.
-      #
-      # You can specify individual starting value in table creation migration file, e.g.:
-      #
-      #   create_table :users, :sequence_start_value => 100 do |t|
-      #     # ...
-      #   end
-      #
-      # You can also specify other sequence definition additional parameters, e.g.:
-      #
-      #   create_table :users, :sequence_start_value => “100 NOCACHE INCREMENT BY 10” do |t|
-      #     # ...
-      #   end
-      #
-      # Create primary key trigger (so that you can skip primary key value in INSERT statement).
-      # By default trigger name will be "table_name_pkt", you can override the name with 
-      # :trigger_name option (but it is not recommended to override it as then this trigger will
-      # not be detected by ActiveRecord model and it will still do prefetching of sequence value).
-      # Example:
-      # 
-      #   create_table :users, :primary_key_trigger => true do |t|
-      #     # ...
-      #   end
-      #
-      # It is possible to add table and column comments in table creation migration files:
-      #
-      #   create_table :employees, :comment => “Employees and contractors” do |t|
-      #     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 = {}
-        
-        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 << 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(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)
-        end
-
-        create_sql = "CREATE#{' GLOBAL TEMPORARY' if options[:temporary]} TABLE "
-        create_sql << "#{quote_table_name(name)} ("
-        create_sql << table_definition.to_sql
-        create_sql << ")#{tablespace} #{options[:options]}"
-        execute create_sql
-        
-        create_sequence_and_trigger(name, options) if create_sequence
-        
-        add_table_comment name, options[:comment]
-        column_comments.each do |column_name, comment|
-          add_comment name, column_name, comment
-        end
-        
-      end
-
-      def rename_table(name, new_name) #:nodoc:
-        execute "RENAME #{quote_table_name(name)} TO #{quote_table_name(new_name)}"
-        execute "RENAME #{quote_table_name("#{name}_seq")} TO #{quote_table_name("#{new_name}_seq")}" rescue nil
-      end
-
-      def drop_table(name, options = {}) #:nodoc:
-        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:
-        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 = 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} #{options[:options]}"
-      ensure
-        self.all_schema_indexes = nil
-      end
-
-      # 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
-      end
-
-      # returned shortened index name if default is too large
-      def index_name(table_name, options) #:nodoc:
-        default_name = super(table_name, options)
-        # 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
-          shortened_name = shortened_name.split('_').map{|w| w[0,3]}.join('_')
-        end
-        # generate unique name using hash function
-        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
-        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:
-        column = column_for(table_name, column_name)
-
-        unless null || default.nil?
-          execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
-        end
-
-        change_column table_name, column_name, column.sql_type, :null => null
-      end
-
-      def change_column(table_name, column_name, type, options = {}) #:nodoc:
-        column = column_for(table_name, column_name)
-
-        # remove :null option if its value is the same as current column definition
-        # otherwise Oracle will raise error
-        if options.has_key?(:null) && options[:null] == column.null
-          options[:null] = nil
-        end
-
-        change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        options[:type] = type
-        add_column_options!(change_column_sql, options)
-        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:
-        return if comment.blank?
-        execute "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{column_name} IS '#{comment}'"
-      end
-
-      def add_table_comment(table_name, comment) #:nodoc:
-        return if comment.blank?
-        execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS '#{comment}'"
-      end
-
-      def table_comment(table_name) #:nodoc:
-        (owner, table_name, db_link) = @connection.describe(table_name)
-        select_value <<-SQL
-          SELECT comments FROM all_tab_comments#{db_link}
-          WHERE owner = '#{owner}'
-            AND table_name = '#{table_name}'
-        SQL
-      end
-
-      def column_comment(table_name, column_name) #:nodoc:
-        (owner, table_name, db_link) = @connection.describe(table_name)
-        select_value <<-SQL
-          SELECT comments FROM all_col_comments#{db_link}
-          WHERE owner = '#{owner}'
-            AND table_name = '#{table_name}'
-            AND column_name = '#{column_name.upcase}'
-        SQL
-      end
-
-      # Maps logical Rails types to Oracle-specific data types.
-      def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
-        # Ignore options for :text and :binary columns
-        return super(type, nil, nil, nil) if ['text', 'binary'].include?(type.to_s)
-
-        super
-      end
-
       # 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, owner=nil, desc_table_name=nil, db_link=nil) #:nodoc:
@@ -1315,241 +847,6 @@ module ActiveRecord
         !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:
-        structure = select_values("select sequence_name from user_sequences order by 1").map do |seq|
-          "CREATE SEQUENCE \"#{seq}\""
-        end
-        select_values("select table_name from all_tables t
-                    where owner = sys_context('userenv','session_user') and secondary='N'
-                      and not exists (select mv.mview_name from all_mviews mv where mv.owner = t.owner and mv.mview_name = t.table_name)
-                    order by 1").each do |table_name|
-          virtual_columns = virtual_columns_for(table_name)
-          ddl = "CREATE#{ ' GLOBAL TEMPORARY' if temporary_table?(table_name)} TABLE \"#{table_name}\" (\n"
-          cols = select_all(%Q{
-            select column_name, data_type, data_length, char_used, char_length, data_precision, data_scale, data_default, nullable
-            from user_tab_columns
-            where table_name = '#{table_name}'
-            order by column_id
-          }).map do |row|
-            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
-          end
-          ddl << cols.join(",\n ")
-          ddl << structure_dump_constraints(table_name)
-          ddl << "\n)"
-          structure << ddl
-          structure << structure_dump_indexes(table_name)
-        end
-
-        join_with_statement_token(structure) << structure_dump_fk_constraints
-      end
-
-      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?
-          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_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?
-          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_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_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?
-            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_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')
-                      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']
-          end
-          ddl << ";" unless ddl.strip[-1,1] == ";"
-          structure << ddl
-        end
-
-        # export views 
-        select_all("select view_name, text from user_views").each do |view|
-          structure << "CREATE OR REPLACE VIEW #{view['view_name']} AS\n #{view['text']}"
-        end
-
-        # export synonyms
-        select_all("select owner, synonym_name, table_name, table_owner 
-                      from all_synonyms  
-                     where owner = sys_context('userenv','session_user') ").each do |synonym|
-          structure << "CREATE OR REPLACE #{synonym['owner'] == 'PUBLIC' ? 'PUBLIC' : '' } SYNONYM #{synonym['synonym_name']}"
-          structure << " FOR #{synonym['table_owner']}.#{synonym['table_name']}"
-        end
-
-        join_with_statement_token(structure)
-      end
-
-      def structure_drop #:nodoc:
-        statements = select_values("select sequence_name from user_sequences order by 1").map do |seq|
-          "DROP SEQUENCE \"#{seq}\""
-        end
-        select_values("select table_name from all_tables t
-                    where owner = sys_context('userenv','session_user') and secondary='N'
-                      and not exists (select mv.mview_name from all_mviews mv where mv.owner = t.owner and mv.mview_name = t.table_name)
-                    order by 1").each do |table|
-          statements << "DROP TABLE \"#{table}\" CASCADE CONSTRAINTS"
-        end
-        join_with_statement_token(statements)
-      end
-
-      def temp_table_drop #:nodoc:
-        join_with_statement_token(select_values(
-                  "select table_name from all_tables
-                    where owner = sys_context('userenv','session_user') and secondary='N' and temporary = 'Y' order by 1").map do |table|
-          "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
-      end
-
-      def add_column_options!(sql, options) #:nodoc:
-        type = options[:type] || ((column = options[:column]) && column.type)
-        type = type && type.to_sym
-        # handle case of defaults for CLOB columns, which would otherwise get "quoted" incorrectly
-        if options_include_default?(options)
-          if type == :text
-            sql << " DEFAULT #{quote(options[:default])}"
-          else
-            # from abstract adapter
-            sql << " DEFAULT #{quote(options[:default], options[:column])}"
-          end
-        end
-        # must explicitly add NULL or NOT NULL to allow change_column to work on migrations
-        if options[:null] == false
-          sql << " NOT NULL"
-        elsif options[:null] == true
-          sql << " NULL" unless type == :primary_key
-        end
-      end
-
       # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
       #
       # Oracle requires the ORDER BY columns to be in the SELECT list for DISTINCT
@@ -1615,85 +912,10 @@ module ActiveRecord
         @connection.oracle_downcase(column_name)
       end
 
-      def column_for(table_name, column_name)
-        unless column = columns(table_name).find { |c| c.name == column_name.to_s }
-          raise "No such column: #{table_name}.#{column_name}"
-        end
-        column
-      end
-
-      def create_sequence_and_trigger(table_name, options)
-        seq_name = options[:sequence_name] || default_sequence_name(table_name)
-        seq_start_value = options[:sequence_start_value] || default_sequence_start_value
-        execute "CREATE SEQUENCE #{quote_table_name(seq_name)} START WITH #{seq_start_value}"
-
-        create_primary_key_trigger(table_name, options) if options[:primary_key_trigger]
-      end
-      
-      def create_primary_key_trigger(table_name, options)
-        seq_name = options[:sequence_name] || default_sequence_name(table_name)
-        trigger_name = options[:trigger_name] || default_trigger_name(table_name)
-        primary_key = options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)
-        execute compress_lines(<<-SQL)
-          CREATE OR REPLACE TRIGGER #{quote_table_name(trigger_name)}
-          BEFORE INSERT ON #{quote_table_name(table_name)} FOR EACH ROW
-          BEGIN
-            IF inserting THEN
-              IF :new.#{quote_column_name(primary_key)} IS NULL THEN
-                SELECT #{quote_table_name(seq_name)}.NEXTVAL INTO :new.#{quote_column_name(primary_key)} FROM dual;
-              END IF;
-            END IF;
-          END;
-        SQL
-      end
-
-      def default_trigger_name(table_name)
-        # truncate table name if necessary to fit in max length of identifier
-        "#{table_name.to_s[0,IDENTIFIER_MAX_LENGTH-4]}_pkt"
-      end
-
       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 
-      # 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)
-        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)
-        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 =============================================
       #
@@ -1763,6 +985,16 @@ if defined?(CGI::Session::ActiveRecordStore::Session)
   end
 end
 
+# Implementation of standard schema definition statements and extensions for schema definition
+require 'active_record/connection_adapters/oracle_enhanced_schema_statements'
+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'
+
 # Load custom create, update, delete methods functionality
 require 'active_record/connection_adapters/oracle_enhanced_procedures'
 
@@ -1776,19 +1008,13 @@ require 'active_record/connection_adapters/oracle_enhanced_dirty'
 begin
   require 'active_record/connection_adapters/oracle_enhanced_tasks'
 rescue LoadError
-end if defined?(Rails.root) || defined?(RAILS_ROOT)
+end if defined?(Rails) || defined?(RAILS_ROOT)
 
 # Patches and enhancements for schema dumper
 require 'active_record/connection_adapters/oracle_enhanced_schema_dumper'
 
-# Extensions for schema definition statements
-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'
+# Implementation of structure dump
+require 'active_record/connection_adapters/oracle_enhanced_structure_dump'
 
 # 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'