ctreatma-activerecord-oracle_enhanced-adapter 1.4.1.1

data/lib/active_record/connection_adapters/oracle_enhanced_schema_dumper.rb

@@ -0,0 +1,252 @@
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhancedSchemaDumper #:nodoc:
+
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          private
+          alias_method_chain :tables, :oracle_enhanced
+          alias_method_chain :indexes, :oracle_enhanced
+        end
+      end
+
+      private
+
+      def ignore_table?(table)
+        [ActiveRecord::Migrator.proper_table_name('schema_migrations'), ignore_tables].flatten.any? do |ignored|
+          case ignored
+          when String; table == ignored
+          when Regexp; table =~ ignored
+          else
+            raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
+          end
+        end
+      end
+
+      def tables_with_oracle_enhanced(stream)
+        return tables_without_oracle_enhanced(stream) unless @connection.respond_to?(:materialized_views)
+        # do not include materialized views in schema dump - they should be created separately after schema creation
+        sorted_tables = (@connection.tables - @connection.materialized_views).sort
+        sorted_tables.each do |tbl|
+          # add table prefix or suffix for schema_migrations
+          next if ignore_table? tbl
+          # change table name inspect method
+          tbl.extend TableInspect
+          oracle_enhanced_table(tbl, stream)
+          # add primary key trigger if table has it
+          primary_key_trigger(tbl, stream)
+        end
+        # following table definitions
+        # add foreign keys if table has them
+        sorted_tables.each do |tbl|
+          next if ignore_table? tbl
+          foreign_keys(tbl, stream)
+        end
+
+        # add synonyms in local schema
+        synonyms(stream)
+      end
+
+      def primary_key_trigger(table_name, stream)
+        if @connection.respond_to?(:has_primary_key_trigger?) && @connection.has_primary_key_trigger?(table_name)
+          pk, pk_seq = @connection.pk_and_sequence_for(table_name)
+          stream.print "  add_primary_key_trigger #{table_name.inspect}"
+          stream.print ", :primary_key => \"#{pk}\"" if pk != 'id'
+          stream.print "\n\n"
+        end
+      end
+
+      def foreign_keys(table_name, stream)
+        if @connection.respond_to?(:foreign_keys) && (foreign_keys = @connection.foreign_keys(table_name)).any?
+          add_foreign_key_statements = foreign_keys.map do |foreign_key|
+            statement_parts = [ ('add_foreign_key ' + foreign_key.from_table.inspect) ]
+            statement_parts << foreign_key.to_table.inspect
+            
+            if foreign_key.options[:columns].size == 1
+              column = foreign_key.options[:columns].first
+              if column != "#{foreign_key.to_table.singularize}_id"
+                statement_parts << (':column => ' + column.inspect)
+              end
+              
+              if foreign_key.options[:references].first != 'id'
+                statement_parts << (':primary_key => ' + foreign_key.options[:primary_key].inspect)
+              end
+            else
+              statement_parts << (':columns => ' + foreign_key.options[:columns].inspect)
+            end
+
+            statement_parts << (':name => ' + foreign_key.options[:name].inspect)
+            
+            unless foreign_key.options[:dependent].blank?
+              statement_parts << (':dependent => ' + foreign_key.options[:dependent].inspect)
+            end
+
+            '  ' + statement_parts.join(', ')
+          end
+
+          stream.puts add_foreign_key_statements.sort.join("\n")
+          stream.puts
+        end
+      end
+
+      def synonyms(stream)
+        if @connection.respond_to?(:synonyms)
+          syns = @connection.synonyms
+          syns.each do |syn|
+		        next if ignore_table? syn.name
+            table_name = syn.table_name
+            table_name = "#{syn.table_owner}.#{table_name}" if syn.table_owner
+            table_name = "#{table_name}@#{syn.db_link}" if syn.db_link
+            stream.print "  add_synonym #{syn.name.inspect}, #{table_name.inspect}, :force => true"
+            stream.puts
+          end
+          stream.puts unless syns.empty?
+        end
+      end
+
+      def indexes_with_oracle_enhanced(table, stream)
+        # return original method if not using oracle_enhanced
+        if (rails_env = defined?(Rails.env) ? Rails.env : (defined?(RAILS_ENV) ? RAILS_ENV : nil)) &&
+              ActiveRecord::Base.configurations[rails_env] &&
+              ActiveRecord::Base.configurations[rails_env]['adapter'] != 'oracle_enhanced'
+          return indexes_without_oracle_enhanced(table, stream)
+        end
+        if (indexes = @connection.indexes(table)).any?
+          add_index_statements = indexes.map do |index|
+            case index.type
+            when nil
+              # use table.inspect as it will remove prefix and suffix
+              statement_parts = [ ('add_index ' + table.inspect) ]
+              statement_parts << index.columns.inspect
+              statement_parts << (':name => ' + index.name.inspect)
+              statement_parts << ':unique => true' if index.unique
+              statement_parts << ':tablespace => ' + index.tablespace.inspect if index.tablespace
+            when 'CTXSYS.CONTEXT'
+              if index.statement_parameters
+                statement_parts = [ ('add_context_index ' + table.inspect) ]
+                statement_parts << index.statement_parameters
+              else
+                statement_parts = [ ('add_context_index ' + table.inspect) ]
+                statement_parts << index.columns.inspect
+                statement_parts << (':name => ' + index.name.inspect)
+              end
+            else
+              # unrecognized index type
+              statement_parts = ["# unrecognized index #{index.name.inspect} with type #{index.type.inspect}"]
+            end
+            '  ' + statement_parts.join(', ')
+          end
+
+          stream.puts add_index_statements.sort.join("\n")
+          stream.puts
+        end
+      end
+
+      def oracle_enhanced_table(table, stream)
+        columns = @connection.columns(table)
+        begin
+          tbl = StringIO.new
+
+          # first dump primary key column
+          if @connection.respond_to?(:pk_and_sequence_for)
+            pk, pk_seq = @connection.pk_and_sequence_for(table)
+          elsif @connection.respond_to?(:primary_key)
+            pk = @connection.primary_key(table)
+          end
+          
+          tbl.print "  create_table #{table.inspect}"
+          
+          # addition to make temporary option work
+          tbl.print ", :temporary => true" if @connection.temporary_table?(table)
+          
+          if columns.detect { |c| c.name == pk }
+            if pk != 'id'
+              tbl.print %Q(, :primary_key => "#{pk}")
+            end
+          else
+            tbl.print ", :id => false"
+          end
+          tbl.print ", :force => true"
+          tbl.puts " do |t|"
+
+          # then dump all non-primary key columns
+          column_specs = columns.map do |column|
+            raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
+            next if column.name == pk
+            spec = {}
+            spec[:name]      = column.name.inspect
+            spec[:type]      = column.virtual? ? 'virtual' : column.type.to_s
+            spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && column.type != :decimal
+            spec[:precision] = column.precision.inspect if !column.precision.nil?
+            spec[:scale]     = column.scale.inspect if !column.scale.nil?
+            spec[:null]      = 'false' if !column.null
+            spec[:default]   = column.virtual_column_data_default if column.virtual?
+            spec[:default] ||= default_string(column.default) if column.has_default?
+            (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
+            spec
+          end.compact
+
+          # find all migration keys used in this table
+          keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map(&:keys).flatten
+
+          # figure out the lengths for each column based on above keys
+          lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
+
+          # the string we're going to sprintf our values against, with standardized column widths
+          format_string = lengths.map{ |len| "%-#{len}s" }
+
+          # find the max length for the 'type' column, which is special
+          type_length = column_specs.map{ |column| column[:type].length }.max
+
+          # add column type definition to our format string
+          format_string.unshift "    t.%-#{type_length}s "
+
+          format_string *= ''
+
+          column_specs.each do |colspec|
+            values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
+            values.unshift colspec[:type]
+            tbl.print((format_string % values).gsub(/,\s*$/, ''))
+            tbl.puts
+          end
+
+          tbl.puts "  end"
+          tbl.puts
+          
+          indexes(table, tbl)
+
+          tbl.rewind
+          stream.print tbl.read
+        rescue => e
+          stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
+          stream.puts "#   #{e.message}"
+          stream.puts
+        end
+        
+        stream
+      end
+      
+      
+      # remove table name prefix and suffix when doing #inspect (which is used in tables method)
+      module TableInspect #:nodoc:
+        def inspect
+          remove_prefix_and_suffix(self)
+        end
+        
+        private
+        def remove_prefix_and_suffix(table_name)
+          if table_name =~ /\A#{ActiveRecord::Base.table_name_prefix.to_s.gsub('$','\$')}(.*)#{ActiveRecord::Base.table_name_suffix.to_s.gsub('$','\$')}\Z/
+            "\"#{$1}\""
+          else
+            "\"#{table_name}\""
+          end
+        end
+      end
+
+    end
+  end
+end
+
+ActiveRecord::SchemaDumper.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedSchemaDumper
+end

data/lib/active_record/connection_adapters/oracle_enhanced_schema_statements.rb

@@ -0,0 +1,373 @@
+require 'digest/sha1'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhancedSchemaStatements
+      # SCHEMA STATEMENTS ========================================
+      #
+      # see: abstract/schema_statements.rb
+
+      # 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 = tablespace_for(:table, options[:tablespace])
+
+        if options[:force] && table_exists?(name)
+          drop_table(name, options)
+        end
+
+        create_sql = "CREATE#{' GLOBAL TEMPORARY' if options[:temporary]} TABLE "
+        create_sql << quote_table_name(name)
+        create_sql << " (#{table_definition.to_sql})"
+        unless options[:temporary]
+          create_sql << " ORGANIZATION #{options[:organization]}" if options[:organization]
+          create_sql << tablespace
+          table_definition.lob_columns.each{|cd| create_sql << tablespace_for(cd.sql_type.downcase.to_sym, nil, name, cd.name)}
+        end
+        create_sql << " #{options[:options]}"
+        execute create_sql
+        
+        create_sequence_and_trigger(name, options) if create_sequence
+        
+        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:
+        if new_name.to_s.length > table_name_length
+          raise ArgumentError, "New table name '#{new_name}' is too long; the limit is #{table_name_length} characters"
+        end
+        if "#{new_name}_seq".to_s.length > sequence_name_length
+          raise ArgumentError, "New sequence name '#{new_name}_seq' is too long; the limit is #{sequence_name_length} characters"
+        end
+        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")}"
+      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].to_s if options.key?(:name)
+          tablespace = tablespace_for(:index, options[:tablespace])
+        else
+          index_type = options
+        end
+
+        if index_name.to_s.length > index_name_length
+          raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters"
+        end
+        if index_name_exists?(table_name, index_name, false)
+          raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists"
+        end
+        quoted_column_names = column_names.map { |e| quote_column_name_or_expression(e) }.join(", ")
+
+        execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})#{tablespace} #{options[:options]}"
+      ensure
+        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_name_exists?(table_name, index_name, true)
+          raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
+        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).to_s
+        # sometimes options can be String or Array with column names
+        options = {} unless options.is_a?(Hash)
+        identifier_max_length = options[:identifier_max_length] || index_name_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 with a given name.
+      #
+      # The default argument is returned if the underlying implementation does not define the indexes method,
+      # as there's no way to determine the correct answer in that case.
+      #
+      # Will always query database and not index cache.
+      def index_name_exists?(table_name, index_name, default)
+        (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
+      end
+
+      def rename_index(table_name, index_name, new_index_name) #:nodoc:
+        unless index_name_exists?(table_name, index_name, true)
+          raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
+        end
+        execute "ALTER INDEX #{quote_column_name(index_name)} rename to #{quote_column_name(new_index_name)}"
+      ensure
+        self.all_schema_indexes = nil
+      end
+
+      def add_column(table_name, column_name, type, options = {}) #:nodoc:
+        add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        add_column_options!(add_column_sql, options.merge(:type=>type, :column_name=>column_name, :table_name=>table_name))
+        add_column_sql << tablespace_for((type_to_sql(type).downcase.to_sym), nil, table_name, column_name)
+        execute(add_column_sql)
+      ensure
+        clear_table_columns_cache(table_name)
+      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])}"
+        add_column_options!(change_column_sql, options.merge(:type=>type, :column_name=>column_name, :table_name=>table_name))
+        change_column_sql << tablespace_for((type_to_sql(type).downcase.to_sym), nil, options[:table_name], options[:column_name])
+        execute(change_column_sql)
+      ensure
+        clear_table_columns_cache(table_name)
+      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
+
+      def tablespace(table_name)
+        select_value <<-SQL
+          SELECT tablespace_name
+          FROM user_tables
+          WHERE table_name='#{table_name.to_s.upcase}'
+        SQL
+      end
+
+      private
+
+      def tablespace_for(obj_type, tablespace_option, table_name=nil, column_name=nil)
+        tablespace_sql = ''
+        if tablespace = (tablespace_option || default_tablespace_for(obj_type))
+          tablespace_sql << if [:blob, :clob].include?(obj_type.to_sym)
+           " LOB (#{quote_column_name(column_name)}) STORE AS #{column_name.to_s[0..10]}_#{table_name.to_s[0..14]}_ls (TABLESPACE #{tablespace})"
+          else
+           " TABLESPACE #{tablespace}"
+          end
+        end
+        tablespace_sql
+      end
+
+      def default_tablespace_for(type)
+        (default_tablespaces[type] || default_tablespaces[native_database_types[type][:name]]) rescue nil
+      end
+
+
+      def column_for(table_name, column_name)
+        unless column = columns(table_name).find { |c| c.name == column_name.to_s }
+          raise "No such column: #{table_name}.#{column_name}"
+        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,table_name_length-4]}_pkt"
+      end
+
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedSchemaStatements
+end