activerecord-oracle_enhanced-adapter 1.5.6 → 1.6.9

data/lib/active_record/connection_adapters/{oracle_enhanced_structure_dump.rb → oracle_enhanced/structure_dump.rb}

@@ -10,7 +10,7 @@ module ActiveRecord #:nodoc:
           "CREATE SEQUENCE \"#{seq}\""
         end
         select_values("SELECT table_name FROM all_tables t
-                    WHERE owner = SYS_CONTEXT('userenv', 'session_user') AND secondary = 'N'
+                    WHERE owner = SYS_CONTEXT('userenv', 'current_schema') 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)
                       AND NOT EXISTS (SELECT mvl.log_table FROM all_mview_logs mvl WHERE mvl.log_owner = t.owner AND mvl.log_table = t.table_name)
                     ORDER BY 1").each do |table_name|
@@ -34,6 +34,8 @@ module ActiveRecord #:nodoc:
           structure << ddl
           structure << structure_dump_indexes(table_name)
           structure << structure_dump_unique_keys(table_name)
+          structure << structure_dump_table_comments(table_name)
+          structure << structure_dump_column_comments(table_name)
         end
 
         join_with_statement_token(structure) << structure_dump_fk_constraints
@@ -77,7 +79,7 @@ module ActiveRecord #:nodoc:
               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')
+             AND c.owner = SYS_CONTEXT('userenv', 'current_schema')
         SQL
         pks.each do |row|
           opts[:name] = row['constraint_name']
@@ -95,7 +97,7 @@ module ActiveRecord #:nodoc:
               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')
+             AND c.owner = SYS_CONTEXT('userenv', 'current_schema')
         SQL
         uks.each do |uk|
           keys[uk['constraint_name']] ||= []
@@ -123,7 +125,7 @@ module ActiveRecord #:nodoc:
       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|
+        fks = select_all("SELECT table_name FROM all_tables WHERE owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY 1").map do |table|
           if respond_to?(:foreign_keys) && (foreign_keys = foreign_keys(table["table_name"])).any?
             foreign_keys.map do |fk|
               sql = "ALTER TABLE #{quote_table_name(fk.from_table)} ADD CONSTRAINT #{quote_column_name(fk.options[:name])} "
@@ -134,12 +136,59 @@ module ActiveRecord #:nodoc:
         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} ORDER BY version")
-        join_with_statement_token(migrated.map{|v| "INSERT INTO #{sm_table} (version) VALUES ('#{v}')" })
+      def structure_dump_table_comments(table_name)
+        comments = []
+        comment = table_comment(table_name)
+
+        unless comment.nil?
+          comments << "COMMENT ON TABLE #{quote_table_name(table_name)} IS '#{quote_string(comment)}'"
+        end
+
+        join_with_statement_token(comments)
+      end
+
+      def structure_dump_column_comments(table_name)
+        comments = []
+        columns = select_values("SELECT column_name FROM user_tab_columns WHERE table_name = '#{table_name}' ORDER BY column_id")
+
+        columns.each do |column|
+          comment = column_comment(table_name, column)
+          unless comment.nil?
+            comments << "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column)} IS '#{quote_string(comment)}'"
+          end
+        end
+
+        join_with_statement_token(comments)
       end
 
+      def foreign_key_definition(to_table, options = {}) #:nodoc:
+        columns = Array(options[:column] || options[:columns])
+
+        if columns.size > 1
+          # composite foreign key
+          columns_sql = columns.map {|c| quote_column_name(c)}.join(',')
+          references = options[:references] || columns
+          references_sql = references.map {|c| quote_column_name(c)}.join(',')
+        else
+          columns_sql = quote_column_name(columns.first || "#{to_table.to_s.singularize}_id")
+          references = options[:references] ? options[:references].first : nil
+          references_sql = quote_column_name(options[:primary_key] || references || "id")
+        end
+
+        table_name = to_table
+
+        sql = "FOREIGN KEY (#{columns_sql}) REFERENCES #{quote_table_name(table_name)}(#{references_sql})"
+
+        case options[:dependent]
+        when :nullify
+          sql << " ON DELETE SET NULL"
+        when :delete
+          sql << " ON DELETE CASCADE"
+        end
+        sql
+      end
+
+
       # Extract all stored procedures, packages, synonyms and views.
       def structure_dump_db_stored_code #:nodoc:
         structure = []
@@ -147,14 +196,14 @@ module ActiveRecord #:nodoc:
                      FROM all_source
                     WHERE type IN ('PROCEDURE', 'PACKAGE', 'PACKAGE BODY', 'FUNCTION', 'TRIGGER', 'TYPE')
                       AND name NOT LIKE 'BIN$%'
-                      AND owner = SYS_CONTEXT('userenv', 'session_user') ORDER BY type").each do |source|
+                      AND owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY type").each do |source|
           ddl = "CREATE OR REPLACE   \n"
           select_all(%Q{
                   SELECT text
                     FROM all_source
                    WHERE name = '#{source['name']}'
                      AND type = '#{source['type']}'
-                     AND owner = SYS_CONTEXT('userenv', 'session_user')
+                     AND owner = SYS_CONTEXT('userenv', 'current_schema')
                    ORDER BY line
                 }).each do |row|
             ddl << row['text']
@@ -171,7 +220,7 @@ module ActiveRecord #:nodoc:
         # 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|
+                     WHERE owner = SYS_CONTEXT('userenv', 'current_schema') ").each do |synonym|
           structure << "CREATE OR REPLACE #{synonym['owner'] == 'PUBLIC' ? 'PUBLIC' : '' } SYNONYM #{synonym['synonym_name']}
 			FOR #{synonym['table_owner']}.#{synonym['table_name']}"
         end
@@ -184,7 +233,7 @@ module ActiveRecord #:nodoc:
           "DROP SEQUENCE \"#{seq}\""
         end
         select_values("SELECT table_name from all_tables t
-                    WHERE owner = SYS_CONTEXT('userenv', 'session_user') AND secondary = 'N'
+                    WHERE owner = SYS_CONTEXT('userenv', 'current_schema') 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)
                       AND NOT EXISTS (SELECT mvl.log_table FROM all_mview_logs mvl WHERE mvl.log_owner = t.owner AND mvl.log_table = t.table_name)
                     ORDER BY 1").each do |table|
@@ -196,7 +245,7 @@ module ActiveRecord #:nodoc:
       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|
+                    WHERE owner = SYS_CONTEXT('userenv', 'current_schema') AND secondary = 'N' AND temporary = 'Y' ORDER BY 1").map do |table|
           "DROP TABLE \"#{table}\" CASCADE CONSTRAINTS"
         end)
       end
@@ -258,7 +307,7 @@ module ActiveRecord #:nodoc:
                AND table_name = '#{table.upcase}'
           SQL
         # feature not supported previous to 11g
-        rescue ActiveRecord::StatementInvalid => e
+        rescue ActiveRecord::StatementInvalid => _e
           []
         end
       end

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

@@ -0,0 +1 @@
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter::VERSION = File.read(File.expand_path('../../../../../VERSION', __FILE__)).chomp

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -30,9 +30,13 @@
 # portions Copyright 2005 Graham Jenkins
 
 require 'active_record/connection_adapters/abstract_adapter'
-require 'active_record/connection_adapters/oracle_enhanced_connection'
+require 'active_record/connection_adapters/oracle_enhanced/connection'
+require 'active_record/connection_adapters/oracle_enhanced/database_statements'
+require 'active_record/connection_adapters/oracle_enhanced/schema_statements'
+require 'active_record/connection_adapters/oracle_enhanced/column_dumper'
+require 'active_record/connection_adapters/oracle_enhanced/context_index'
 
-require 'active_record/connection_adapters/oracle_enhanced_column'
+require 'active_record/connection_adapters/oracle_enhanced/column'
 
 require 'digest/sha1'
 
@@ -131,7 +135,7 @@ module ActiveRecord
 
     def record_changed_lobs
       @changed_lob_columns = self.class.lob_columns.select do |col|
-        (self.class.serialized_attributes.keys.include?(col.name) || self.send(:"#{col.name}_changed?")) && !self.class.readonly_attributes.to_a.include?(col.name)
+        self.attribute_changed?(col.name) && !self.class.readonly_attributes.to_a.include?(col.name)
       end
     end
   end
@@ -218,6 +222,15 @@ module ActiveRecord
     # * <tt>:nls_time_tz_format</tt>
     #
     class OracleEnhancedAdapter < AbstractAdapter
+      # TODO: Use relative
+      include ActiveRecord::ConnectionAdapters::OracleEnhanced::DatabaseStatements
+      include ActiveRecord::ConnectionAdapters::OracleEnhanced::SchemaStatements
+      include ActiveRecord::ConnectionAdapters::OracleEnhanced::ColumnDumper
+      include ActiveRecord::ConnectionAdapters::OracleEnhanced::ContextIndex
+
+      def schema_creation
+        OracleEnhanced::SchemaCreation.new self
+      end
 
       ##
       # :singleton-method:
@@ -270,13 +283,6 @@ module ActiveRecord
       cattr_accessor :emulate_dates_by_column_name
       self.emulate_dates_by_column_name = false
 
-      ##
-      # :singleton-method:
-      # Specify how `NUMBER` datatype columns, without precision and scale, are handled in Rails world.
-      # Default is :decimal and other valid option is :float. Be wary of setting it to other values.
-      cattr_accessor :number_datatype_coercion
-      self.number_datatype_coercion = :decimal
-
       # Check column name to identify if it is Date (and not Time) column.
       # Is used if +emulate_dates_by_column_name+ option is set to +true+.
       # Override this method definition in initializer file if different Date column recognition is needed.
@@ -311,7 +317,7 @@ module ActiveRecord
       # Is used if +emulate_integers_by_column_name+ option is set to +true+.
       # Override this method definition in initializer file if different Integer column recognition is needed.
       def self.is_integer_column?(name, table_name = nil)
-        !!(name =~ /(^|_)id$/i)
+        name =~ /(^|_)id$/i
       end
 
       ##
@@ -326,9 +332,9 @@ module ActiveRecord
       # Check column name to identify if it is boolean (and not String) column.
       # Is used if +emulate_booleans_from_strings+ option is set to +true+.
       # Override this method definition in initializer file if different boolean column recognition is needed.
-      def self.is_boolean_column?(name, field_type, table_name = nil)
-        return true if ["CHAR(1)","VARCHAR2(1)"].include?(field_type)
-        field_type =~ /^VARCHAR2/ && (name =~ /_flag$/i || name =~ /_yn$/i)
+      def self.is_boolean_column?(name, sql_type, table_name = nil)
+        return true if ["CHAR(1)","VARCHAR2(1)"].include?(sql_type)
+        sql_type =~ /^VARCHAR2/ && (name =~ /_flag$/i || name =~ /_yn$/i)
       end
 
       # How boolean value should be quoted to String.
@@ -383,21 +389,18 @@ module ActiveRecord
         end
       end
 
-      class BindSubstitution < Arel::Visitors::Oracle #:nodoc:
-        include Arel::Visitors::BindVisitor
-      end
-
       def initialize(connection, logger, config) #:nodoc:
         super(connection, logger)
         @quoted_column_names, @quoted_table_names = {}, {}
         @config = config
         @statements = StatementPool.new(connection, config.fetch(:statement_limit) { 250 })
         @enable_dbms_output = false
-        if config.fetch(:prepared_statements) { true }
-          @visitor = Arel::Visitors::Oracle.new self
+        @visitor = Arel::Visitors::Oracle.new self
+
+        if self.class.type_cast_config_to_boolean(config.fetch(:prepared_statements) { true })
           @prepared_statements = true
         else
-          @visitor = unprepared_visitor
+          @prepared_statements = false
         end
       end
 
@@ -423,7 +426,13 @@ module ActiveRecord
         true
       end
 
-      NUMBER_MAX_PRECISION = 38
+      def supports_foreign_keys?
+        true
+      end
+
+      def supports_views?
+        true
+      end
 
       #:stopdoc:
       DEFAULT_NLS_PARAMETERS = {
@@ -448,11 +457,11 @@ module ActiveRecord
 
       #:stopdoc:
       NATIVE_DATABASE_TYPES = {
-        :primary_key => "NUMBER(#{NUMBER_MAX_PRECISION}) NOT NULL PRIMARY KEY",
+        :primary_key => "NUMBER(38) NOT NULL PRIMARY KEY",
         :string      => { :name => "VARCHAR2", :limit => 255 },
         :text        => { :name => "CLOB" },
-        :integer     => { :name => "NUMBER", :limit => NUMBER_MAX_PRECISION },
-        :float       => { :name => "NUMBER" },
+        :integer     => { :name => "NUMBER", :limit => 38 },
+        :float       => { :name => "BINARY_FLOAT" },
         :decimal     => { :name => "DECIMAL" },
         :datetime    => { :name => "DATE" },
         # changed to native TIMESTAMP type
@@ -462,7 +471,8 @@ module ActiveRecord
         :date        => { :name => "DATE" },
         :binary      => { :name => "BLOB" },
         :boolean     => { :name => "NUMBER", :limit => 1 },
-        :raw         => { :name => "RAW", :limit => 2000 }
+        :raw         => { :name => "RAW", :limit => 2000 },
+        :bigint      => { :name => "NUMBER", :limit => 19 }
       }
       # if emulate_booleans_from_strings then store booleans in VARCHAR2
       NATIVE_DATABASE_TYPES_BOOLEAN_STRINGS = NATIVE_DATABASE_TYPES.dup.merge(
@@ -667,22 +677,26 @@ module ActiveRecord
 
       # Cast a +value+ to a type that the database understands.
       def type_cast(value, column)
-        case value
-        when true, false
-          if emulate_booleans_from_strings || column && column.type == :string
-            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
+        if column && column.cast_type.is_a?(Type::Serialized)
+          super
+        else
+          case value
+          when true, false
+            if emulate_booleans_from_strings || column && column.type == :string
+              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
           else
-            value
+            super
           end
-        else
-          super
         end
       end
 
@@ -794,8 +808,8 @@ module ActiveRecord
             select NVL(max(#{quote_column_name(primary_key)}),0) + 1 from #{quote_table_name(table_name)}
           ", new_start_value)
 
-          execute ("DROP SEQUENCE #{quote_table_name(sequence_name)}")
-          execute ("CREATE SEQUENCE #{quote_table_name(sequence_name)} START WITH #{new_start_value}")
+          execute "DROP SEQUENCE #{quote_table_name(sequence_name)}"
+          execute "CREATE SEQUENCE #{quote_table_name(sequence_name)} START WITH #{new_start_value}"
         end
       end
 
@@ -811,8 +825,8 @@ module ActiveRecord
         columns.each do |col|
           value = attributes[col.name]
           # changed sequence of next two lines - should check if value is nil before converting to yaml
-          next if value.nil?  || (value == '')
-          value = value.to_yaml if col.text? && klass.serialized_attributes[col.name]
+          next if value.blank?
+          value = col.cast_type.type_cast_for_database(value)
           uncached do
             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"
@@ -835,27 +849,32 @@ module ActiveRecord
         select_value("SELECT SYS_CONTEXT('userenv', 'session_user') FROM dual")
       end
 
+      # Current database session schema
+      def current_schema
+        select_value("SELECT SYS_CONTEXT('userenv', 'current_schema') FROM dual")
+      end
+
       # Default tablespace name of current user
       def default_tablespace
-        select_value("SELECT LOWER(default_tablespace) FROM user_users WHERE username = SYS_CONTEXT('userenv', 'session_user')")
+        select_value("SELECT LOWER(default_tablespace) FROM user_users WHERE username = SYS_CONTEXT('userenv', 'current_schema')")
       end
 
       def tables(name = nil) #:nodoc:
         select_values(
-        "SELECT DECODE(table_name, UPPER(table_name), LOWER(table_name), table_name) FROM all_tables WHERE owner = SYS_CONTEXT('userenv', 'session_user') AND secondary = 'N'",
+        "SELECT DECODE(table_name, UPPER(table_name), LOWER(table_name), table_name) FROM all_tables WHERE owner = SYS_CONTEXT('userenv', 'current_schema') AND secondary = 'N'",
         name)
       end
 
       # Will return true if database object exists (to be able to use also views and synonyms for ActiveRecord models)
       def table_exists?(table_name)
-        (owner, table_name, db_link) = @connection.describe(table_name)
+        (_owner, table_name, _db_link) = @connection.describe(table_name)
         true
       rescue
         false
       end
 
       def materialized_views #:nodoc:
-        select_values("SELECT LOWER(mview_name) FROM all_mviews WHERE owner = SYS_CONTEXT('userenv', 'session_user')")
+        select_values("SELECT LOWER(mview_name) FROM all_mviews WHERE owner = SYS_CONTEXT('userenv', 'current_schema')")
       end
 
       cattr_accessor :all_schema_indexes #:nodoc:
@@ -906,7 +925,7 @@ module ActiveRecord
                   statement_parameters = $1
                 end
               end
-              all_schema_indexes << OracleEnhancedIndexDefinition.new(row['table_name'], row['index_name'],
+              all_schema_indexes << OracleEnhanced::IndexDefinition.new(row['table_name'], row['index_name'],
                 row['uniqueness'] == "UNIQUE", row['index_type'] == 'DOMAIN' ? "#{row['ityp_owner']}.#{row['ityp_name']}" : nil,
                 row['parameters'], statement_parameters,
                 row['tablespace_name'] == default_tablespace_name ? nil : row['tablespace_name'], [])
@@ -1038,7 +1057,7 @@ module ActiveRecord
         end.map do |row|
           limit, scale = row['limit'], row['scale']
           if limit || scale
-            row['sql_type'] += "(#{(limit || NUMBER_MAX_PRECISION).to_i}" + ((scale = scale.to_i) > 0 ? ",#{scale})" : ")")
+            row['sql_type'] += "(#{(limit || 38).to_i}" + ((scale = scale.to_i) > 0 ? ",#{scale})" : ")")
           end
 
           if row['sql_type_owner']
@@ -1055,19 +1074,61 @@ module ActiveRecord
             # match newlines.
             row['data_default'].sub!(/^'(.*)'$/m, '\1')
             row['data_default'] = nil if row['data_default'] =~ /^(null|empty_[bc]lob\(\))$/i
+            # TODO: Needs better fix to fallback "N" to false
+            row['data_default'] = false if (row['data_default'] == "N" && OracleEnhancedAdapter.emulate_booleans_from_strings)
           end
 
-          OracleEnhancedColumn.new(oracle_downcase(row['name']),
+          # TODO: Consider to extract another method such as `get_cast_type`
+          case row['sql_type']
+          when /decimal|numeric|number/i
+            if get_type_for_column(table_name, oracle_downcase(row['name'])) == :integer
+              cast_type = ActiveRecord::OracleEnhanced::Type::Integer.new
+            elsif OracleEnhancedAdapter.emulate_booleans && row['sql_type'].upcase == "NUMBER(1)"
+              cast_type = Type::Boolean.new
+            elsif OracleEnhancedAdapter.emulate_integers_by_column_name && OracleEnhancedAdapter.is_integer_column?(row['name'], table_name)
+              cast_type = ActiveRecord::OracleEnhanced::Type::Integer.new
+            else
+              cast_type = lookup_cast_type(row['sql_type'])
+            end
+          when /char/i
+            if get_type_for_column(table_name, oracle_downcase(row['name'])) == :string
+              cast_type = Type::String.new
+            elsif get_type_for_column(table_name, oracle_downcase(row['name'])) == :boolean
+              cast_type = Type::Boolean.new
+            elsif OracleEnhancedAdapter.emulate_booleans_from_strings && OracleEnhancedAdapter.is_boolean_column?(row['name'], row['sql_type'], table_name)
+              cast_type = Type::Boolean.new
+            else
+              cast_type = lookup_cast_type(row['sql_type'])
+            end
+          when /date/i
+            if get_type_for_column(table_name, oracle_downcase(row['name'])) == :date
+              cast_type = Type::Date.new
+            elsif get_type_for_column(table_name, oracle_downcase(row['name'])) == :datetime
+              cast_type = Type::DateTime.new
+            elsif OracleEnhancedAdapter.emulate_dates_by_column_name && OracleEnhancedAdapter.is_date_column?(row['name'], table_name)
+              cast_type = Type::Date.new
+            else
+              cast_type = lookup_cast_type(row['sql_type'])
+            end
+          else
+            cast_type = lookup_cast_type(row['sql_type'])
+          end
+
+          new_column(oracle_downcase(row['name']),
                            row['data_default'],
+                           cast_type,
                            row['sql_type'],
                            row['nullable'] == 'Y',
-                           # pass table name for table specific column definitions
                            table_name,
-                           # pass column type if specified in class definition
-                           get_type_for_column(table_name, oracle_downcase(row['name'])), is_virtual)
+                           is_virtual,
+                           false )
         end
       end
 
+      def new_column(name, default, cast_type, sql_type = nil, null = true, table_name = nil, virtual=false, returning_id=false)
+        OracleEnhancedColumn.new(name, default, cast_type, sql_type, null, table_name, virtual, returning_id)
+      end
+
       # used just in tests to clear column cache
       def clear_columns_cache #:nodoc:
         @@columns_cache = nil
@@ -1207,6 +1268,34 @@ module ActiveRecord
 
       protected
 
+      def initialize_type_map(m)
+        super
+        # oracle
+        register_class_with_limit m, %r(date)i,           Type::DateTime
+        register_class_with_limit m, %r(raw)i,            ActiveRecord::OracleEnhanced::Type::Raw
+        register_class_with_limit m, %r(timestamp)i,      ActiveRecord::OracleEnhanced::Type::Timestamp
+
+        m.register_type(%r(NUMBER)i) do |sql_type|
+          scale = extract_scale(sql_type)
+          precision = extract_precision(sql_type)
+          limit = extract_limit(sql_type)
+          if scale == 0
+            ActiveRecord::OracleEnhanced::Type::Integer.new(precision: precision, limit: limit)
+          else
+            Type::Decimal.new(precision: precision, scale: scale)
+          end
+        end
+      end
+
+      def extract_limit(sql_type) #:nodoc:
+        case sql_type
+        when /^bigint/i
+          19
+        when /\((.*)\)/
+          $1.to_i
+        end
+      end
+
       def translate_exception(exception, message) #:nodoc:
         case @connection.error_code(exception)
         when 1
@@ -1220,6 +1309,10 @@ module ActiveRecord
 
       private
 
+      def select(sql, name = nil, binds = [])
+        exec_query(sql, name, binds)
+      end
+
       def oracle_downcase(column_name)
         @connection.oracle_downcase(column_name)
       end
@@ -1256,12 +1349,8 @@ module ActiveRecord
       end
 
       protected
-      def log(sql, name, binds = nil) #:nodoc:
-        if binds
-          super sql, name, binds
-        else
-          super sql, name
-        end
+      def log(sql, name = "SQL", binds = [], statement_name = nil) #:nodoc:
+        super
       ensure
         log_dbms_output if dbms_output_enabled?
       end
@@ -1289,38 +1378,47 @@ module ActiveRecord
 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'
+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'
+require 'active_record/connection_adapters/oracle_enhanced/schema_definitions'
 
 # Extensions for context index definition
-require 'active_record/connection_adapters/oracle_enhanced_context_index'
+require 'active_record/connection_adapters/oracle_enhanced/context_index'
 
 # Load additional methods for composite_primary_keys support
-require 'active_record/connection_adapters/oracle_enhanced_cpk'
+require 'active_record/connection_adapters/oracle_enhanced/cpk'
 
 # Load patch for dirty tracking methods
-require 'active_record/connection_adapters/oracle_enhanced_dirty'
+require 'active_record/connection_adapters/oracle_enhanced/dirty'
 
 # Patches and enhancements for schema dumper
-require 'active_record/connection_adapters/oracle_enhanced_schema_dumper'
+require 'active_record/connection_adapters/oracle_enhanced/schema_dumper'
 
 # Implementation of structure dump
-require 'active_record/connection_adapters/oracle_enhanced_structure_dump'
+require 'active_record/connection_adapters/oracle_enhanced/structure_dump'
 
-require 'active_record/connection_adapters/oracle_enhanced_version'
+require 'active_record/connection_adapters/oracle_enhanced/version'
 
 module ActiveRecord
-  autoload :OracleEnhancedProcedures, 'active_record/connection_adapters/oracle_enhanced_procedures'
+  autoload :OracleEnhancedProcedures, 'active_record/connection_adapters/oracle_enhanced/procedures'
 end
 
 # Patches and enhancements for column dumper
-require 'active_record/connection_adapters/oracle_enhanced_column_dumper'
+require 'active_record/connection_adapters/oracle_enhanced/column_dumper'
 
 # Moved SchemaCreation class
-require 'active_record/connection_adapters/oracle_enhanced_schema_creation'
+require 'active_record/connection_adapters/oracle_enhanced/schema_creation'
 
 # Moved DatabaseStetements
-require 'active_record/connection_adapters/oracle_enhanced_database_statements'
+require 'active_record/connection_adapters/oracle_enhanced/database_statements'
+
+# Add Type:Raw
+require 'active_record/oracle_enhanced/type/raw'
+
+# Add Type:Timestamp
+require 'active_record/oracle_enhanced/type/timestamp'
+
+# Add OracleEnhanced::Type::Integer
+require 'active_record/oracle_enhanced/type/integer'

data/lib/active_record/oracle_enhanced/type/integer.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  module OracleEnhanced
+    module Type
+      class Integer < ActiveRecord::Type::Integer # :nodoc:
+        private
+
+        def max_value
+          ("9"*38).to_i
+        end
+      end
+    end
+  end
+end

data/lib/active_record/oracle_enhanced/type/raw.rb

@@ -0,0 +1,13 @@
+require 'active_record/type/string'
+
+module ActiveRecord
+  module OracleEnhanced
+    module Type
+      class Raw < ActiveRecord::Type::String # :nodoc:
+        def type
+          :raw
+        end
+      end
+    end
+  end
+end

data/lib/active_record/oracle_enhanced/type/timestamp.rb

@@ -0,0 +1,11 @@
+module ActiveRecord
+  module OracleEnhanced
+    module Type
+      class Timestamp < ActiveRecord::Type::Value # :nodoc:
+        def type
+          :timestamp
+        end
+      end
+    end
+  end
+end

data/lib/activerecord-oracle_enhanced-adapter.rb

@@ -5,7 +5,7 @@ if defined?(::Rails::Railtie)
     module ConnectionAdapters
       class OracleEnhancedRailtie < ::Rails::Railtie
         rake_tasks do
-          load 'active_record/connection_adapters/oracle_enhanced_database_tasks.rb'
+          load 'active_record/connection_adapters/oracle_enhanced/database_tasks.rb'
         end
 
         ActiveSupport.on_load(:active_record) do