activerecord-oracle_enhanced-adapter 1.6.9 → 1.7.0.beta1

data/lib/active_record/connection_adapters/oracle_enhanced/oci_quoting.rb

@@ -0,0 +1,36 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module OCIQuoting
+        def _type_cast(value)
+          case value
+          when ActiveModel::Type::Binary::Data
+            lob_value = value == '' ? ' ' : value
+            bind_type = OCI8::BLOB
+            ora_value = bind_type.new(@connection.raw_oci_connection, lob_value)
+            ora_value.size = 0 if value == ''
+            ora_value
+          when ActiveRecord::OracleEnhanced::Type::Text::Data
+            lob_value = value.to_s == '' ? ' ' : value.to_s
+            bind_type = OCI8::CLOB
+            ora_value = bind_type.new(@connection.raw_oci_connection, lob_value)
+            ora_value.size = 0 if value.to_s == ''
+            ora_value
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module Quoting
+        prepend OCIQuoting
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/oracle_enhanced/procedures.rb

@@ -152,7 +152,7 @@ module ActiveRecord #:nodoc:
           if partial_writes?
             # Serialized attributes should always be written in case they've been
             # changed in place.
-            update_using_custom_method(changed | (attributes.keys & self.class.columns.select {|column| column.cast_type.is_a?(Type::Serialized)}))
+            update_using_custom_method(changed | (attributes.keys & self.class.columns.select {|column| column.is_a?(Type::Serialized)}))
           else
             update_using_custom_method(attribute_names)
           end

data/lib/active_record/connection_adapters/oracle_enhanced/quoting.rb

@@ -0,0 +1,174 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module Quoting
+        # QUOTING ==================================================
+        #
+        # see: abstract/quoting.rb
+
+        def quote_column_name(name) #:nodoc:
+          name = name.to_s
+          @quoted_column_names[name] ||= begin
+            # if only valid lowercase column characters in name
+            if name =~ /\A[a-z][a-z_0-9\$#]*\Z/
+              "\"#{name.upcase}\""
+            else
+              # remove double quotes which cannot be used inside quoted identifier
+              "\"#{name.gsub('"', '')}\""
+            end
+          end
+        end
+
+        # This method is used in add_index to identify either column name (which is quoted)
+        # or function based index (in which case function expression is not quoted)
+        def quote_column_name_or_expression(name) #:nodoc:
+          name = name.to_s
+          case name
+          # if only valid lowercase 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
+
+        # Used only for quoting database links as the naming rules for links
+        # differ from the rules for column names. Specifically, link names may
+        # include periods.
+        def quote_database_link(name)
+          case name
+          when NONQUOTED_DATABASE_LINK
+            %Q("#{name.upcase}")
+          else
+            name
+          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 =~ VALID_TABLE_NAME && !(name =~ /[A-Z]/ && name =~ /[a-z]/) ? true : false
+        end
+
+        def quote_table_name(name) #:nodoc:
+          name, link = name.to_s.split('@')
+          @quoted_table_names[name] ||= [name.split('.').map{|n| quote_column_name(n)}.join('.'), quote_database_link(link)].compact.join('@')
+        end
+
+        def quote_string(s) #:nodoc:
+          s.gsub(/'/, "''")
+        end
+
+        def quote(value, column = nil) #:nodoc:
+          super
+        end
+
+        def _quote(value) #:nodoc:
+          case value
+          when ActiveRecord::OracleEnhanced::Type::NationalCharacterString::Data then
+             "N" << "'#{quote_string(value.to_s)}'"
+          when ActiveModel::Type::Binary::Data then
+            %Q{empty_#{ type_to_sql(column.type.to_sym).downcase rescue 'blob' }()}
+          when ActiveRecord::OracleEnhanced::Type::Text::Data then
+            %Q{empty_#{ type_to_sql(column.type.to_sym).downcase rescue 'clob' }()}
+          else
+            super
+          end
+        end
+
+        def quoted_true #:nodoc:
+          return "'#{self.class.boolean_to_string(true)}'" if emulate_booleans_from_strings
+          "1"
+        end
+
+        def quoted_false #:nodoc:
+          return "'#{self.class.boolean_to_string(false)}'" if emulate_booleans_from_strings
+          "0"
+        end
+
+        def quote_date_with_to_date(value) #:nodoc:
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            `quote_date_with_to_date` will be deprecated in future version of Oracle enhanced adapter.
+            Also this method should not be called directly. Let Abstract adapter `_quote` method handle it.
+          MSG
+          # should support that composite_primary_keys gem will pass date as string
+          value = quoted_date(value) if value.acts_like?(:date) || value.acts_like?(:time)
+          "TO_DATE('#{value}','YYYY-MM-DD HH24:MI:SS')"
+        end
+
+        def quote_timestamp_with_to_timestamp(value) #:nodoc:
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            `quote_timestamp_with_to_timestamp` will be deprecated in future version of Oracle enhanced adapter.
+            Also this method should not be called directly. Let Abstract adapter `_quote` method handle it.
+          MSG
+          # add up to 9 digits of fractional seconds to inserted time
+          value = "#{quoted_date(value)}:#{("%.6f"%value.to_f).split('.')[1]}" if value.acts_like?(:time)
+          "TO_TIMESTAMP('#{value}','YYYY-MM-DD HH24:MI:SS:FF6')"
+        end
+
+        # Cast a +value+ to a type that the database understands.
+        def type_cast(value, column = nil)
+          super
+        end
+
+        def _type_cast(value)
+          case value
+          when true, false
+            #if emulate_booleans_from_strings || column && column.type == :string
+            if emulate_booleans_from_strings
+              self.class.boolean_to_string(value)
+            else
+              value ? 1 : 0
+            end
+          when Date, Time
+            if value.acts_like?(:time)
+              zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+              value.respond_to?(zone_conversion_method) ? value.send(zone_conversion_method) : value
+            else
+              value
+            end
+          when ActiveRecord::OracleEnhanced::Type::NationalCharacterString::Data
+            value.to_s
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end
+
+# if MRI or YARV
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
+  require 'active_record/connection_adapters/oracle_enhanced/oci_quoting'
+# if JRuby
+elsif RUBY_ENGINE == 'jruby'
+  require 'active_record/connection_adapters/oracle_enhanced/jdbc_quoting'
+else
+  raise "Unsupported Ruby engine #{RUBY_ENGINE}"
+end

data/lib/active_record/connection_adapters/oracle_enhanced/schema_creation.rb

@@ -19,21 +19,27 @@ module ActiveRecord
         end
 
         def visit_TableDefinition(o)
-          create_sql = "CREATE#{' GLOBAL TEMPORARY' if o.temporary} TABLE "
-          create_sql << "#{quote_table_name(o.name)} ("
-          create_sql << o.columns.map { |c| accept c }.join(', ')
-          create_sql << ")"
+          create_sql = "CREATE#{' GLOBAL TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} "
+          statements = o.columns.map { |c| accept c }
+          statements << accept(o.primary_keys) if o.primary_keys
+
+          if supports_foreign_keys?
+            statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
+          end
+
+          create_sql << "(#{statements.join(', ')})" if statements.present?
 
           unless o.temporary
             @lob_tablespaces.each do |lob_column, tablespace|
               create_sql << " LOB (#{quote_column_name(lob_column)}) STORE AS (TABLESPACE #{tablespace}) \n"
             end if defined?(@lob_tablespaces)
-            create_sql << " ORGANIZATION #{o.options[:organization]}" if o.options[:organization]
-            if (tablespace = o.options[:tablespace] || default_tablespace_for(:table))
+            create_sql << " ORGANIZATION #{o.organization}" if o.organization
+            if (tablespace = o.tablespace || default_tablespace_for(:table))
               create_sql << " TABLESPACE #{tablespace}"
             end
           end
-          create_sql << " #{o.options[:options]}"
+          add_table_options!(create_sql, table_options(o))
+          create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
           create_sql
         end
 
@@ -50,7 +56,7 @@ module ActiveRecord
             if type == :text
               sql << " DEFAULT #{@conn.quote(options[:default])}"
             else
-              sql << " DEFAULT #{quote_value(options[:default], options[:column])}"
+              sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}"
             end
           end
           # must explicitly add NULL or NOT NULL to allow change_column to work on migrations
@@ -63,6 +69,9 @@ module ActiveRecord
           if options[:as].present?
             sql << " AS (#{options[:as]})"
           end
+          if options[:primary_key] == true
+            sql << " PRIMARY KEY"
+          end
         end
 
         def action_sql(action, dependency)

data/lib/active_record/connection_adapters/oracle_enhanced/schema_definitions.rb

@@ -26,25 +26,26 @@ module ActiveRecord
       end
 
       class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition
-        attr_accessor :table, :name, :unique, :type, :parameters, :statement_parameters, :tablespace, :columns
+        attr_accessor :parameters, :statement_parameters, :tablespace
  
-        def initialize(table, name, unique, type, parameters, statement_parameters, tablespace, columns)
-          @table = table
-          @name = name
-          @unique = unique
-          @type = type
+        def initialize(table, name, unique, columns, lengths, orders, where, type, using, parameters, statement_parameters, tablespace)
           @parameters = parameters
           @statement_parameters = statement_parameters
           @tablespace = tablespace
-          @columns = columns
-          super(table, name, unique, columns, nil, nil, nil, nil)
+          super(table, name, unique, columns, lengths, orders, where, type, using)
         end
       end
 
-      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+      class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
+
+      end
 
-        def raw(name, options={})
-          column(name, :raw, options)
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        attr_accessor :tablespace, :organization
+        def initialize(name, temporary = false, options = nil, as = nil, tablespace = nil, organization = nil, comment: nil)
+          @tablespace = tablespace
+          @organization = organization
+          super(name, temporary, options, as, comment: comment)
         end
 
         def virtual(* args)
@@ -69,6 +70,11 @@ module ActiveRecord
           super(name, type, options)
         end
 
+        private
+        def create_column_definition(name, type)
+          OracleEnhanced::ColumnDefinition.new name, type
+        end
+
       end
 
       class AlterTable < ActiveRecord::ConnectionAdapters::AlterTable

data/lib/active_record/connection_adapters/oracle_enhanced/schema_dumper.rb

@@ -1,225 +1,207 @@
 module ActiveRecord #:nodoc:
   module ConnectionAdapters #:nodoc:
-    module OracleEnhancedSchemaDumper #:nodoc:
+    module OracleEnhanced #:nodoc:
+      module SchemaDumper #:nodoc:
 
-      def self.included(base) #:nodoc:
-        base.class_eval do
-          private
-          alias_method_chain :tables, :oracle_enhanced
-          alias_method_chain :indexes, :oracle_enhanced
-          alias_method_chain :foreign_keys, :oracle_enhanced
-        end
-      end
-
-      private
+        private
 
-      def ignore_table?(table)
-        ['schema_migrations', ignore_tables].flatten.any? do |ignored|
-          case ignored
-          when String; remove_prefix_and_suffix(table) == ignored
-          when Regexp; remove_prefix_and_suffix(table) =~ ignored
-          else
-            raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
+        def tables(stream)
+          # do not include materialized views in schema dump - they should be created separately after schema creation
+          sorted_tables = (@connection.data_sources - @connection.materialized_views).sort
+          sorted_tables.each do |tbl|
+            # add table prefix or suffix for schema_migrations
+            next if ignored? tbl
+            # change table name inspect method
+            tbl.extend TableInspect
+            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 ignored? tbl
+            foreign_keys(tbl, stream)
           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)
+          # add synonyms in local schema
+          synonyms(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"
+        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
-      end
 
-      def foreign_keys_with_oracle_enhanced(table_name, stream)
-        return foreign_keys_without_oracle_enhanced(table_name, stream)
-      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
+        def synonyms(stream)
+          if @connection.respond_to?(:synonyms)
+            syns = @connection.synonyms
+            syns.each do |syn|
+              next if ignored? 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
-          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) ]
+        def indexes(table, stream)
+          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
-            else
-              # unrecognized index type
-              statement_parts = ["# unrecognized index #{index.name.inspect} with type #{index.type.inspect}"]
+              '  ' + statement_parts.join(', ')
             end
-            '  ' + statement_parts.join(', ')
-          end
 
-          stream.puts add_index_statements.sort.join("\n")
-          stream.puts
+            stream.puts add_index_statements.sort.join("\n")
+            stream.puts
+          end
         end
-      end
 
-      def oracle_enhanced_table(table, stream)
-        columns = @connection.columns(table)
-        begin
-          tbl = StringIO.new
+        def 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
+            # first dump primary key column
+            if @connection.respond_to?(:primary_keys)
+              pk = @connection.primary_keys(table)
+              pk = pk.first unless pk.size > 1
+            else
+              pk = @connection.primary_key(table)
+            end
 
-          tbl.print "  create_table #{table.inspect}"
+            tbl.print "  create_table #{table.inspect}"
 
-          # addition to make temporary option work
-          tbl.print ", temporary: true" if @connection.temporary_table?(table)
+            # addition to make temporary option work
+            tbl.print ", temporary: true" if @connection.temporary_table?(table)
 
-          table_comments = @connection.table_comment(table)
-          unless table_comments.nil?
-            tbl.print ", comment: #{table_comments.inspect}"
-          end
+            table_comments = @connection.table_comment(table)
+            unless table_comments.nil?
+              tbl.print ", comment: #{table_comments.inspect}"
+            end
 
-          if columns.detect { |c| c.name == pk }
-            if pk != 'id'
-              tbl.print %Q(, primary_key: "#{pk}")
+            case pk
+            when String
+              tbl.print ", primary_key: #{pk.inspect}" unless pk == 'id'
+              pkcol = columns.detect { |c| c.name == pk }
+              pkcolspec = @connection.column_spec_for_primary_key(pkcol)
+              if pkcolspec.present?
+                pkcolspec.each do |key, value|
+                  tbl.print ", #{key}: #{value}"
+                end
+              end
+            when Array
+              tbl.print ", primary_key: #{pk.inspect}"
+            else
+              tbl.print ", id: false"
             end
-          else
-            tbl.print ", id: false"
-          end
-          tbl.print ", force: :cascade"
-          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
-            @connection.column_spec(column, @types)
-          end.compact
+            tbl.print ", force: :cascade"
+            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}'" unless @connection.valid_type?(column.type)
+              next if column.name == pk
+              @connection.column_spec(column)
+            end.compact
+
+            # find all migration keys used in this table
+            #
+            # TODO `& column_specs.map(&:keys).flatten` should be executed
+            # in migration_keys_with_oracle_enhanced
+            keys = @connection.migration_keys & column_specs.map(&:keys).flatten
 
-          # find all migration keys used in this table
-          # 
-          # TODO `& column_specs.map(&:keys).flatten` should be executed 
-          # in migration_keys_with_oracle_enhanced
-          keys = @connection.migration_keys & 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 }
 
-          # 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" }
 
-          # 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
 
-          # 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 "
 
-          # add column type definition to our format string
-          format_string.unshift "    t.%-#{type_length}s "
+            format_string *= ''
 
-          format_string *= ''
+            # dirty hack to replace virtual_type: with type:
+            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*$/, '').gsub(/virtual_type:/, "type:"))
+              tbl.puts
+            end
 
-          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
+
+            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
 
-          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
+          stream
         end
-        
-        stream
-      end
 
-      def remove_prefix_and_suffix(table)
-        table.gsub(/^(#{ActiveRecord::Base.table_name_prefix})(.+)(#{ActiveRecord::Base.table_name_suffix})$/,  "\\2")
-      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)
+        def remove_prefix_and_suffix(table)
+          table.gsub(/^(#{ActiveRecord::Base.table_name_prefix})(.+)(#{ActiveRecord::Base.table_name_suffix})$/,  "\\2")
         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}\""
+
+        # 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
   end
-end
 
-ActiveRecord::SchemaDumper.class_eval do
-  include ActiveRecord::ConnectionAdapters::OracleEnhancedSchemaDumper
+  class SchemaDumper #:nodoc:
+    prepend ConnectionAdapters::OracleEnhanced::SchemaDumper
+  end
 end