activerecord-oracle_enhanced-adapter 1.4.3 → 5.2.0

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module SchemaStatementsExt
+        # 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).
+        #
+        #   add_primary_key_trigger :users
+        #
+        # You can also create primary key trigger using +create_table+ with :primary_key_trigger
+        # option:
+        #
+        #   create_table :users, :primary_key_trigger => true do |t|
+        #     # ...
+        #   end
+        #
+        def add_primary_key_trigger(table_name, options = {})
+          # call the same private method that is used for create_table :primary_key_trigger => true
+          create_primary_key_trigger(table_name, options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,353 @@
+# frozen_string_literal: true
+
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhanced #:nodoc:
+      module StructureDump #:nodoc:
+        # 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:
+          sequences = select(<<-SQL.strip.gsub(/\s+/, " "), "sequences to dump at structure dump")
+            SELECT sequence_name, min_value, max_value, increment_by, order_flag, cycle_flag
+            FROM all_sequences
+            where sequence_owner = SYS_CONTEXT('userenv', 'session_user') ORDER BY 1
+          SQL
+
+          structure = sequences.map do |result|
+            "CREATE SEQUENCE #{quote_table_name(result["sequence_name"])} MINVALUE #{result["min_value"]} MAXVALUE #{result["max_value"]} INCREMENT BY #{result["increment_by"]} #{result["order_flag"] == 'Y' ? "ORDER" : "NOORDER"} #{result["cycle_flag"] == 'Y' ? "CYCLE" : "NOCYCLE"}"
+          end
+          tables = select_values(<<-SQL.strip.gsub(/\s+/, " "), "tables at structure dump")
+            SELECT table_name FROM all_tables t
+            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
+          SQL
+          tables.each do |table_name|
+            virtual_columns = virtual_columns_for(table_name) if supports_virtual_columns?
+            ddl = "CREATE#{ ' GLOBAL TEMPORARY' if temporary_table?(table_name)} TABLE \"#{table_name}\" (\n".dup
+            columns = select_all(<<-SQL.strip.gsub(/\s+/, " "), "columns at structure dump")
+              SELECT column_name, data_type, data_length, char_used, char_length,
+              data_precision, data_scale, data_default, nullable
+              FROM all_tab_columns
+              WHERE table_name = '#{table_name}'
+              AND owner = SYS_CONTEXT('userenv', 'session_user')
+              ORDER BY column_id
+            SQL
+            cols = columns.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.map { |col| " #{col}" }.join(",\n")
+            ddl << structure_dump_primary_key(table_name)
+            ddl << "\n)"
+            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
+        end
+
+        def structure_dump_column(column) #:nodoc:
+          col = "\"#{column['column_name']}\" #{column['data_type']}".dup
+          if (column["data_type"] == "NUMBER") && !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") || column["data_type"] == "RAW"
+            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']}".dup
+          if (column["data_type"] == "NUMBER") && !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") || column["data_type"] == "RAW"
+            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_primary_key(table) #:nodoc:
+          opts = { name: "", cols: [] }
+          pks = select_all(<<-SQL.strip.gsub(/\s+/, " "), "Primary Keys")
+          SELECT a.constraint_name, a.column_name, a.position
+            FROM all_cons_columns a
+            JOIN all_constraints c
+              ON a.constraint_name = c.constraint_name
+           WHERE c.table_name = '#{table.upcase}'
+             AND c.constraint_type = 'P'
+             AND a.owner = c.owner
+             AND c.owner = SYS_CONTEXT('userenv', 'current_schema')
+        SQL
+          pks.each do |row|
+            opts[:name] = row["constraint_name"]
+            opts[:cols][row["position"] - 1] = row["column_name"]
+          end
+          opts[:cols].length > 0 ? ",\n CONSTRAINT #{opts[:name]} PRIMARY KEY (#{opts[:cols].join(',')})" : ""
+        end
+
+        def structure_dump_unique_keys(table) #:nodoc:
+          keys = {}
+          uks = select_all(<<-SQL.strip.gsub(/\s+/, " "), "Primary Keys")
+          SELECT a.constraint_name, a.column_name, a.position
+            FROM all_cons_columns a
+            JOIN all_constraints c
+              ON a.constraint_name = c.constraint_name
+           WHERE c.table_name = '#{table.upcase}'
+             AND c.constraint_type = 'U'
+             AND a.owner = c.owner
+             AND c.owner = SYS_CONTEXT('userenv', 'current_schema')
+        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|
+            "ALTER TABLE #{table.upcase} ADD 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_or_expression(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:
+          foreign_keys = select_all(<<-SQL.strip.gsub(/\s+/, " "), "foreign keys at structure dump")
+            SELECT table_name FROM all_tables
+            WHERE owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY 1
+          SQL
+          fks = foreign_keys.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])} ".dup
+                sql << "#{foreign_key_definition(fk.to_table, fk.options)}"
+              end
+            end
+          end.flatten.compact
+          join_with_statement_token(fks)
+        end
+
+        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(<<-SQL.strip.gsub(/\s+/, " "), "column comments at structure dump")
+            SELECT column_name FROM user_tab_columns
+            WHERE table_name = '#{table_name}' ORDER BY column_id
+          SQL
+
+          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:
+          column_sql = quote_column_name(options[:column] || "#{to_table.to_s.singularize}_id")
+          references = options[:references] ? options[:references].first : nil
+          references_sql = quote_column_name(options[:primary_key] || references || "id")
+
+          sql = "FOREIGN KEY (#{column_sql}) REFERENCES #{quote_table_name(to_table)}(#{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 = []
+          all_source = select_all(<<-SQL.strip.gsub(/\s+/, " "), "stored program at structure dump")
+            SELECT DISTINCT name, type
+            FROM all_source
+            WHERE type IN ('PROCEDURE', 'PACKAGE', 'PACKAGE BODY', 'FUNCTION', 'TRIGGER', 'TYPE')
+            AND name NOT LIKE 'BIN$%'
+            AND owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY type
+          SQL
+          all_source.each do |source|
+            ddl = "CREATE OR REPLACE   \n".dup
+            texts = select_all(<<-SQL.strip.gsub(/\s+/, " "), "all source at structure dump")
+              SELECT text
+              FROM all_source
+              WHERE name = '#{source['name']}'
+              AND type = '#{source['type']}'
+              AND owner = SYS_CONTEXT('userenv', 'current_schema')
+              ORDER BY line
+            SQL
+            texts.each do |row|
+              ddl << row["text"]
+            end
+            ddl << ";" unless ddl.strip[-1, 1] == ";"
+            structure << ddl
+          end
+
+          # export views
+          views = select_all(<<-SQL.strip.gsub(/\s+/, " "), "views at structure dump")
+            SELECT view_name, text FROM all_views
+            WHERE owner = SYS_CONTEXT('userenv', 'session_user') ORDER BY view_name ASC
+          SQL
+          views.each do |view|
+            structure << "CREATE OR REPLACE FORCE VIEW #{view['view_name']} AS\n #{view['text']}"
+          end
+
+          # export synonyms
+          synonyms = select_all(<<-SQL.strip.gsub(/\s+/, " "), "synonyms at structure dump")
+            SELECT owner, synonym_name, table_name, table_owner
+            FROM all_synonyms
+            WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
+          SQL
+          synonyms.each do |synonym|
+            structure << "CREATE OR REPLACE #{synonym['owner'] == 'PUBLIC' ? 'PUBLIC' : '' } SYNONYM #{synonym['synonym_name']}
+  			FOR #{synonym['table_owner']}.#{synonym['table_name']}"
+          end
+
+          join_with_statement_token(structure)
+        end
+
+        def structure_drop #:nodoc:
+          sequences = select_values(<<-SQL.strip.gsub(/\s+/, " "), "sequences to drop at structure dump")
+            SELECT sequence_name FROM all_sequences where sequence_owner = SYS_CONTEXT('userenv', 'session_user') ORDER BY 1
+          SQL
+          statements = sequences.map do |seq|
+            "DROP SEQUENCE \"#{seq}\""
+          end
+          tables = select_values(<<-SQL.strip.gsub(/\s+/, " "), "tables to drop at structure dump")
+            SELECT table_name from all_tables t
+            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
+          SQL
+          tables.each do |table|
+            statements << "DROP TABLE \"#{table}\" CASCADE CONSTRAINTS"
+          end
+          join_with_statement_token(statements)
+        end
+
+        def temp_table_drop #:nodoc:
+          temporary_tables = select_values(<<-SQL.strip.gsub(/\s+/, " "), "temporary tables to drop at structure dump")
+            SELECT table_name FROM all_tables
+            WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
+            AND secondary = 'N' AND temporary = 'Y' ORDER BY 1
+          SQL
+          statements = temporary_tables.map do |table|
+            "DROP TABLE \"#{table}\" CASCADE CONSTRAINTS"
+          end
+          join_with_statement_token(statements)
+        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 execute_structure_dump(string)
+          string.split(STATEMENT_TOKEN).each do |ddl|
+            execute(ddl) unless ddl.blank?
+          end
+        end
+
+      private
+
+        # Called only if `supports_virtual_columns?` returns true
+        # return [{'column_name' => 'FOOS', 'data_default' => '...'}, ...]
+        def virtual_columns_for(table)
+          select_all(<<-SQL.strip.gsub(/\s+/, " "), "virtual columns for")
+            SELECT column_name, data_default
+            FROM all_tab_cols
+            WHERE virtual_column = 'YES'
+            AND owner = SYS_CONTEXT('userenv', 'session_user')
+            AND table_name = '#{table.upcase}'
+          SQL
+        end
+
+        def drop_sql_for_feature(type)
+          short_type = type == "materialized view" ? "mview" : type
+          features = select_values(<<-SQL.strip.gsub(/\s+/, " "), "features to drop")
+            SELECT #{short_type}_name FROM all_#{short_type.tableize}
+            where owner = SYS_CONTEXT('userenv', 'session_user')
+          SQL
+          statements = features.map do |name|
+            "DROP #{type.upcase} \"#{name}\""
+          end
+          join_with_statement_token(statements)
+        end
+
+        def drop_sql_for_object(type)
+          objects = select_values(<<-SQL.strip.gsub(/\s+/, " "), "objects to drop")
+            SELECT object_name FROM all_objects
+            WHERE object_type = '#{type.upcase}' and owner = SYS_CONTEXT('userenv', 'session_user')
+          SQL
+          statements = objects.map do |name|
+            "DROP #{type.upcase} \"#{name}\""
+          end
+          join_with_statement_token(statements)
+        end
+
+        def join_with_statement_token(array)
+          string = array.join(STATEMENT_TOKEN)
+          string << STATEMENT_TOKEN unless string.blank?
+          string
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhanced
+      class TypeMetadata < DelegateClass(ActiveRecord::ConnectionAdapters::SqlTypeMetadata) # :nodoc:
+        attr_reader :virtual
+
+        def initialize(type_metadata, virtual: nil)
+          super(type_metadata)
+          @type_metadata = type_metadata
+          @virtual = virtual
+        end
+
+        def ==(other)
+          other.is_a?(OracleEnhanced::TypeMetadata) &&
+            attributes_for_hash == other.attributes_for_hash
+        end
+        alias eql? ==
+
+        def hash
+          attributes_for_hash.hash
+        end
+
+        protected
+
+          def attributes_for_hash
+            [self.class, @type_metadata, virtual]
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter::VERSION = File.read(File.expand_path("../../../../../VERSION", __FILE__)).chomp

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -1,5 +1,6 @@
-# -*- coding: utf-8 -*-
-# oracle_enhanced_adapter.rb -- ActiveRecord adapter for Oracle 8i, 9i, 10g, 11g
+# frozen_string_literal: true
+
+# oracle_enhanced_adapter.rb -- ActiveRecord adapter for Oracle 10g, 11g and 12c
 #
 # Authors or original oracle_adapter: Graham Jenkins, Michael Schoen
 #
@@ -29,27 +30,58 @@
 # contribution.
 # portions Copyright 2005 Graham Jenkins
 
-# ActiveRecord 2.2 does not load version file automatically
-require 'active_record/version' unless defined?(ActiveRecord::VERSION)
-
-require 'active_record/connection_adapters/abstract_adapter'
-require 'active_record/connection_adapters/oracle_enhanced_connection'
-
-require 'active_record/connection_adapters/oracle_enhanced_base_ext'
-require 'active_record/connection_adapters/oracle_enhanced_column'
-
-require 'digest/sha1'
+require "active_record/connection_adapters/abstract_adapter"
+require "active_record/connection_adapters/statement_pool"
+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_creation"
+require "active_record/connection_adapters/oracle_enhanced/schema_definitions"
+require "active_record/connection_adapters/oracle_enhanced/schema_dumper"
+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/context_index"
+require "active_record/connection_adapters/oracle_enhanced/column"
+require "active_record/connection_adapters/oracle_enhanced/quoting"
+require "active_record/connection_adapters/oracle_enhanced/database_limits"
+require "active_record/connection_adapters/oracle_enhanced/dbms_output"
+require "active_record/connection_adapters/oracle_enhanced/type_metadata"
+require "active_record/connection_adapters/oracle_enhanced/structure_dump"
+require "active_record/connection_adapters/oracle_enhanced/lob"
+
+require "active_record/type/oracle_enhanced/raw"
+require "active_record/type/oracle_enhanced/integer"
+require "active_record/type/oracle_enhanced/string"
+require "active_record/type/oracle_enhanced/national_character_string"
+require "active_record/type/oracle_enhanced/text"
+require "active_record/type/oracle_enhanced/national_character_text"
+require "active_record/type/oracle_enhanced/boolean"
+require "active_record/type/oracle_enhanced/json"
+require "active_record/type/oracle_enhanced/timestamptz"
+require "active_record/type/oracle_enhanced/timestampltz"
 
 module ActiveRecord
-  module ConnectionAdapters #:nodoc:
+  module ConnectionHandling #:nodoc:
+    # Establishes a connection to the database that's used by all Active Record objects.
+    def 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::OracleEnhanced::Connection.create(config), logger, config)
+      else
+        ConnectionAdapters::OracleEnhancedAdapter.new(
+          ConnectionAdapters::OracleEnhanced::Connection.create(config), logger, config)
+      end
+    end
+  end
 
+  module ConnectionAdapters #:nodoc:
     # Oracle enhanced adapter will work with both
-    # Ruby 1.8/1.9 ruby-oci8 gem (which provides interface to Oracle OCI client)
+    # CRuby ruby-oci8 gem (which provides interface to Oracle OCI client)
     # or with JRuby and Oracle JDBC driver.
     #
-    # It should work with Oracle 9i, 10g and 11g databases.
-    # Limited set of functionality should work on Oracle 8i as well but several features
-    # rely on newer functionality in Oracle database.
+    # It should work with Oracle 10g, 11g and 12c databases.
     #
     # Usage notes:
     # * Key generation assumes a "${table_name}_seq" sequence is available
@@ -79,9 +111,10 @@ module ActiveRecord
     # * <tt>:privilege</tt> - set "SYSDBA" if you want to connect with this privilege
     # * <tt>:allow_concurrency</tt> - set to "true" if non-blocking mode should be enabled (just for OCI client)
     # * <tt>:prefetch_rows</tt> - how many rows should be fetched at one time to increase performance, defaults to 100
-    # * <tt>:cursor_sharing</tt> - cursor sharing mode to minimize amount of unique statements, defaults to "force"
+    # * <tt>:cursor_sharing</tt> - cursor sharing mode to minimize amount of unique statements, no default value
     # * <tt>:time_zone</tt> - database session time zone
     #   (it is recommended to set it using ENV['TZ'] which will be then also used for database session time zone)
+    # * <tt>:schema</tt> - database schema which holds schema objects.
     #
     # Optionals NLS parameters:
     #
@@ -89,6 +122,7 @@ module ActiveRecord
     # * <tt>:nls_comp</tt>
     # * <tt>:nls_currency</tt>
     # * <tt>:nls_date_format</tt> - format for :date columns, defaults to <tt>YYYY-MM-DD HH24:MI:SS</tt>
+    #   (changing `nls_date_format` parameter value is not supported. Use the default value.)
     # * <tt>:nls_date_language</tt>
     # * <tt>:nls_dual_currency</tt>
     # * <tt>:nls_iso_currency</tt>
@@ -100,11 +134,20 @@ module ActiveRecord
     # * <tt>:nls_sort</tt>
     # * <tt>:nls_territory</tt>
     # * <tt>:nls_timestamp_format</tt> - format for :timestamp columns, defaults to <tt>YYYY-MM-DD HH24:MI:SS:FF6</tt>
+    #   (changing `nls_timestamp_format` parameter value is not supported. Use the default value.)
     # * <tt>:nls_timestamp_tz_format</tt>
     # * <tt>:nls_time_format</tt>
     # * <tt>:nls_time_tz_format</tt>
     #
     class OracleEnhancedAdapter < AbstractAdapter
+      include OracleEnhanced::DatabaseStatements
+      include OracleEnhanced::SchemaStatements
+      include OracleEnhanced::SchemaStatementsExt
+      include OracleEnhanced::ContextIndex
+      include OracleEnhanced::Quoting
+      include OracleEnhanced::DatabaseLimits
+      include OracleEnhanced::DbmsOutput
+      include OracleEnhanced::StructureDump
 
       ##
       # :singleton-method:
@@ -118,419 +161,197 @@ module ActiveRecord
 
       ##
       # :singleton-method:
-      # By default, the OracleEnhancedAdapter will typecast all columns of type <tt>DATE</tt>
-      # to Time or DateTime (if value is out of Time value range) value.
-      # If you wish that DATE values with hour, minutes and seconds equal to 0 are typecasted
-      # to Date then you can add the following line to your initializer file:
+      # OracleEnhancedAdapter will use the default tablespace, but if you want specific types of
+      # objects to go into specific tablespaces, specify them like this in an initializer:
       #
-      #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates = true
+      #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_tablespaces =
+      #  {:clob => 'TS_LOB', :blob => 'TS_LOB', :index => 'TS_INDEX', :table => 'TS_DATA'}
       #
-      # As this option can have side effects when unnecessary typecasting is done it is recommended
-      # that Date columns are explicily defined with +set_date_columns+ method.
-      cattr_accessor :emulate_dates
-      self.emulate_dates = false
-
-       ##
-        # :singleton-method:
-        # OracleEnhancedAdapter will use the default tablespace, but if you want specific types of
-        # objects to go into specific tablespaces, specify them like this in an initializer:
-        #
-        #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_tablespaces =
-        #  {:clob => 'TS_LOB', :blob => 'TS_LOB', :index => 'TS_INDEX', :table => 'TS_DATA'}
-        #
-        # Using the :tablespace option where available (e.g create_table) will take precedence
-        # over these settings.
+      # Using the :tablespace option where available (e.g create_table) will take precedence
+      # over these settings.
       cattr_accessor :default_tablespaces
-      self.default_tablespaces={}
+      self.default_tablespaces = {}
 
       ##
       # :singleton-method:
-      # By default, the OracleEnhancedAdapter will typecast all columns of type <tt>DATE</tt>
-      # to Time or DateTime (if value is out of Time value range) value.
-      # If you wish that DATE columns with "date" in their name (e.g. "creation_date") are typecasted
-      # to Date then you can add the following line to your initializer file:
-      #
-      #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
-      #
-      # As this option can have side effects when unnecessary typecasting is done it is recommended
-      # that Date columns are explicily defined with +set_date_columns+ method.
-      cattr_accessor :emulate_dates_by_column_name
-      self.emulate_dates_by_column_name = false
-
-      # 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.
-      def self.is_date_column?(name, table_name = nil)
-        name =~ /(^|_)date(_|$)/i
-      end
-
-      # instance method uses at first check if column type defined at class level
-      def is_date_column?(name, table_name = nil) #:nodoc:
-        case get_type_for_column(table_name, name)
-        when nil
-          self.class.is_date_column?(name, table_name)
-        when :date
-          true
-        else
-          false
-        end
-      end
-
-      ##
-      # :singleton-method:
-      # By default, the OracleEnhancedAdapter will typecast all columns of type <tt>NUMBER</tt>
-      # (without precision or scale) to Float or BigDecimal value.
-      # If you wish that NUMBER columns with name "id" or that end with "_id" are typecasted
-      # to Integer then you can add the following line to your initializer file:
-      #
-      #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
-      cattr_accessor :emulate_integers_by_column_name
-      self.emulate_integers_by_column_name = false
-
-      # Check column name to identify if it is Integer (and not Float or BigDecimal) column.
-      # 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
-      end
-
-      ##
-      # :singleton-method:
-      # If you wish that CHAR(1), VARCHAR2(1) columns or VARCHAR2 columns with FLAG or YN at the end of their name
-      # are typecasted to booleans then you can add the following line to your initializer file:
+      # If you wish that CHAR(1), VARCHAR2(1) columns are typecasted to booleans
+      # then you can add the following line to your initializer file:
       #
       #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
       cattr_accessor :emulate_booleans_from_strings
       self.emulate_booleans_from_strings = false
 
-      # 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)
-      end
-
-      # How boolean value should be quoted to String.
-      # Used if +emulate_booleans_from_strings+ option is set to +true+.
-      def self.boolean_to_string(bool)
-        bool ? "Y" : "N"
-      end
-
       ##
       # :singleton-method:
-      # Specify non-default date format that should be used when assigning string values to :date columns, e.g.:
+      # By default, OracleEnhanced adapter will use Oracle12 visitor
+      # if database version is Oracle 12.1.
+      # If you wish to use Oracle visitor which is intended to work with Oracle 11.2 or lower
+      # for Oracle 12.1 database you can add the following line to your initializer file:
       #
-      #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.string_to_date_format = “%d.%m.%Y”
-      cattr_accessor :string_to_date_format
-      self.string_to_date_format = nil
+      #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.use_old_oracle_visitor = true
+      cattr_accessor :use_old_oracle_visitor
+      self.use_old_oracle_visitor = false
 
       ##
       # :singleton-method:
-      # Specify non-default time format that should be used when assigning string values to :datetime columns, e.g.:
+      # Specify default sequence start with value (by default 10000 if not explicitly set), e.g.:
       #
-      #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.string_to_time_format = “%d.%m.%Y %H:%M:%S”
-      cattr_accessor :string_to_time_format
-      self.string_to_time_format = nil
-
-      class StatementPool
-        include Enumerable
-
-        def initialize(connection, max = 300)
-          @connection = connection
-          @max        = max
-          @cache      = {}
-        end
-
-        def each(&block); @cache.each(&block); end
-        def key?(key);    @cache.key?(key); end
-        def [](key);      @cache[key]; end
-        def length;       @cache.length; end
-        def delete(key);  @cache.delete(key); end
+      #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_sequence_start_value = 1
+      cattr_accessor :default_sequence_start_value
+      self.default_sequence_start_value = 10000
 
-        def []=(sql, key)
-          while @max <= @cache.size
-            @cache.shift.last.close
-          end
-          @cache[sql] = key
-        end
+      class StatementPool < ConnectionAdapters::StatementPool
+        private
 
-        def clear
-          @cache.values.each do |cursor|
-            cursor.close
+          def dealloc(stmt)
+            stmt.close
           end
-          @cache.clear
-        end
       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 })
+      def initialize(connection, logger = nil, config = {}) # :nodoc:
+        super(connection, logger, config)
+        @statements = StatementPool.new(self.class.type_cast_config_to_integer(config[:statement_limit]))
         @enable_dbms_output = false
-        @visitor = Arel::Visitors::Oracle.new self if defined?(Arel::Visitors::Oracle)
       end
 
-      def self.visitor_for(pool) # :nodoc:
-        Arel::Visitors::Oracle.new(pool)
-      end
-
-      ADAPTER_NAME = 'OracleEnhanced'.freeze
+      ADAPTER_NAME = "OracleEnhanced".freeze
 
       def adapter_name #:nodoc:
         ADAPTER_NAME
       end
 
-      def supports_migrations? #:nodoc:
-        true
-      end
-
-      def supports_primary_key? #:nodoc:
-        true
+      def arel_visitor # :nodoc:
+        if supports_fetch_first_n_rows_and_offset?
+          Arel::Visitors::Oracle12.new(self)
+        else
+          Arel::Visitors::Oracle.new(self)
+        end
       end
 
       def supports_savepoints? #:nodoc:
         true
       end
 
-      #:stopdoc:
-      DEFAULT_NLS_PARAMETERS = {
-        :nls_calendar            => nil,
-        :nls_comp                => nil,
-        :nls_currency            => nil,
-        :nls_date_format         => 'YYYY-MM-DD HH24:MI:SS',
-        :nls_date_language       => nil,
-        :nls_dual_currency       => nil,
-        :nls_iso_currency        => nil,
-        :nls_language            => nil,
-        :nls_length_semantics    => 'CHAR',
-        :nls_nchar_conv_excp     => nil,
-        :nls_numeric_characters  => nil,
-        :nls_sort                => nil,
-        :nls_territory           => nil,
-        :nls_timestamp_format    => 'YYYY-MM-DD HH24:MI:SS:FF6',
-        :nls_timestamp_tz_format => nil,
-        :nls_time_format         => nil,
-        :nls_time_tz_format      => nil
-      }
-
-      #:stopdoc:
-      NATIVE_DATABASE_TYPES = {
-        :primary_key => "NUMBER(38) NOT NULL PRIMARY KEY",
-        :string      => { :name => "VARCHAR2", :limit => 255 },
-        :text        => { :name => "CLOB" },
-        :integer     => { :name => "NUMBER", :limit => 38 },
-        :float       => { :name => "NUMBER" },
-        :decimal     => { :name => "DECIMAL" },
-        :datetime    => { :name => "DATE" },
-        # changed to native TIMESTAMP type
-        # :timestamp   => { :name => "DATE" },
-        :timestamp   => { :name => "TIMESTAMP" },
-        :time        => { :name => "DATE" },
-        :date        => { :name => "DATE" },
-        :binary      => { :name => "BLOB" },
-        :boolean     => { :name => "NUMBER", :limit => 1 },
-        :raw         => { :name => "RAW", :limit => 2000 }
-      }
-      # if emulate_booleans_from_strings then store booleans in VARCHAR2
-      NATIVE_DATABASE_TYPES_BOOLEAN_STRINGS = NATIVE_DATABASE_TYPES.dup.merge(
-        :boolean     => { :name => "VARCHAR2", :limit => 1 }
-      )
-      #:startdoc:
-
-      def native_database_types #:nodoc:
-        emulate_booleans_from_strings ? NATIVE_DATABASE_TYPES_BOOLEAN_STRINGS : NATIVE_DATABASE_TYPES
-      end
-
-      # maximum length of Oracle identifiers
-      IDENTIFIER_MAX_LENGTH = 30
-
-      def table_alias_length #:nodoc:
-        IDENTIFIER_MAX_LENGTH
-      end
-
-      # the maximum length of a table name
-      def table_name_length
-        IDENTIFIER_MAX_LENGTH
-      end
-
-      # the maximum length of a column name
-      def column_name_length
-        IDENTIFIER_MAX_LENGTH
-      end
-
-      # the maximum length of an index name
-      def index_name_length
-        IDENTIFIER_MAX_LENGTH
+      def supports_transaction_isolation? #:nodoc:
+        true
       end
 
-      # the maximum length of a sequence name
-      def sequence_name_length
-        IDENTIFIER_MAX_LENGTH
+      def supports_foreign_keys?
+        true
       end
 
-      # To avoid ORA-01795: maximum number of expressions in a list is 1000
-      # tell ActiveRecord to limit us to 1000 ids at a time
-      def in_clause_length
-        1000
+      def supports_foreign_keys_in_create?
+        supports_foreign_keys?
       end
-      alias ids_in_list_limit in_clause_length
 
-      # 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
+      def supports_views?
+        true
       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
+      def supports_fetch_first_n_rows_and_offset?
+        if !use_old_oracle_visitor && @connection.database_version.first >= 12
+          true
         else
-          name
+          false
         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 = name.to_s
-        @quoted_table_names[name] ||= name.split('.').map{|n| n.split('@').map{|m| quote_column_name(m)}.join('@')}.join('.')
-      end
-
-      def quote_string(s) #:nodoc:
-        s.gsub(/'/, "''")
-      end
-
-      def quote(value, column = nil) #:nodoc:
-        if value && column
-          case column.type
-          when :text, :binary
-            %Q{empty_#{ column.sql_type.downcase rescue 'blob' }()}
-          # NLS_DATE_FORMAT independent TIMESTAMP support
-          when :timestamp
-            quote_timestamp_with_to_timestamp(value)
-          # NLS_DATE_FORMAT independent DATE support
-          when :date, :time, :datetime
-            quote_date_with_to_date(value)
-          when :raw
-            quote_raw(value)
-          when :string
-            # NCHAR and NVARCHAR2 literals should be quoted with N'...'.
-            # Read directly instance variable as otherwise migrations with table column default values are failing
-            # as migrations pass ColumnDefinition object to this method.
-            # Check if instance variable is defined to avoid warnings about accessing undefined instance variable.
-            column.instance_variable_defined?('@nchar') && column.instance_variable_get('@nchar') ? 'N' << super : super
-          else
-            super
-          end
-        elsif value.acts_like?(:date)
-          quote_date_with_to_date(value)
-        elsif value.acts_like?(:time)
-          value.to_i == value.to_f ? quote_date_with_to_date(value) : quote_timestamp_with_to_timestamp(value)
-        else
-          super
-        end
+      def supports_datetime_with_precision?
+        true
       end
 
-      def quoted_true #:nodoc:
-        return "'#{self.class.boolean_to_string(true)}'" if emulate_booleans_from_strings
-        "1"
+      def supports_comments?
+        true
       end
 
-      def quoted_false #:nodoc:
-        return "'#{self.class.boolean_to_string(false)}'" if emulate_booleans_from_strings
-        "0"
+      def supports_multi_insert?
+        @connection.database_version.to_s >= [11, 2].to_s
       end
 
-      def quote_date_with_to_date(value) #:nodoc:
-        # 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')"
+      def supports_virtual_columns?
+        @connection.database_version.first >= 11
       end
 
-      # Encode a string or byte array as string of hex codes
-      def self.encode_raw(value)
-        # When given a string, convert to a byte array.
-        value = value.unpack('C*') if value.is_a?(String)
-        value.map { |x| "%02X" % x }.join
+      def supports_json?
+        # Oracle Database 12.1 or higher version supports JSON.
+        # However, Oracle enhanced adapter has limited support for JSON data type.
+        # which does not pass many of ActiveRecord JSON tests.
+        #
+        # No migration supported for :json type due to there is no `JSON` data type
+        # in Oracle Database itself.
+        #
+        # If you want to use JSON data type, here are steps
+        # 1.Define :string or :text in migration
+        #
+        # create_table :test_posts, force: true do |t|
+        #   t.string  :title
+        #   t.text    :article
+        # end
+        #
+        # 2. Set :json attributes
+        #
+        # class TestPost < ActiveRecord::Base
+        #  attribute :title, :json
+        #  attribute :article, :json
+        # end
+        #
+        # 3. Add `is json` database constraints by running sql statements
+        #
+        # alter table test_posts add constraint test_posts_title_is_json check (title is json)
+        # alter table test_posts add constraint test_posts_article_is_json check (article is json)
+        #
+        false
       end
 
-      # quote encoded raw value
-      def quote_raw(value) #:nodoc:
-        "'#{self.class.encode_raw(value)}'"
-      end
+      #:stopdoc:
+      DEFAULT_NLS_PARAMETERS = {
+        nls_calendar: nil,
+        nls_comp: nil,
+        nls_currency: nil,
+        nls_date_format: "YYYY-MM-DD HH24:MI:SS",
+        nls_date_language: nil,
+        nls_dual_currency: nil,
+        nls_iso_currency: nil,
+        nls_language: nil,
+        nls_length_semantics: "CHAR",
+        nls_nchar_conv_excp: nil,
+        nls_numeric_characters: nil,
+        nls_sort: nil,
+        nls_territory: nil,
+        nls_timestamp_format: "YYYY-MM-DD HH24:MI:SS:FF6",
+        nls_timestamp_tz_format: nil,
+        nls_time_format: nil,
+        nls_time_tz_format: nil
+      }
 
-      def quote_timestamp_with_to_timestamp(value) #:nodoc:
-        # 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
+      #:stopdoc:
+      NATIVE_DATABASE_TYPES = {
+        primary_key: "NUMBER(38) NOT NULL PRIMARY KEY",
+        string: { name: "VARCHAR2", limit: 255 },
+        text: { name: "CLOB" },
+        ntext: { name: "NCLOB" },
+        integer: { name: "NUMBER", limit: 38 },
+        float: { name: "BINARY_FLOAT" },
+        decimal: { name: "DECIMAL" },
+        datetime: { name: "TIMESTAMP" },
+        timestamp: { name: "TIMESTAMP" },
+        timestamptz: { name: "TIMESTAMP WITH TIME ZONE" },
+        timestampltz: { name: "TIMESTAMP WITH LOCAL TIME ZONE" },
+        time: { name: "TIMESTAMP" },
+        date: { name: "DATE" },
+        binary: { name: "BLOB" },
+        boolean: { name: "NUMBER", limit: 1 },
+        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(
+        boolean: { name: "VARCHAR2", limit: 1 }
+      )
+      #:startdoc:
 
-      # 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
-          else
-            value
-          end
-        else
-          super
-        end
+      def native_database_types #:nodoc:
+        emulate_booleans_from_strings ? NATIVE_DATABASE_TYPES_BOOLEAN_STRINGS : NATIVE_DATABASE_TYPES
       end
 
       # CONNECTION MANAGEMENT ====================================
@@ -559,15 +380,15 @@ module ActiveRecord
         # last known state, which isn't good enough if the connection has
         # gone stale since the last use.
         @connection.ping
-      rescue OracleEnhancedConnectionException
+      rescue OracleEnhanced::ConnectionException
         false
       end
 
       # Reconnects to the database.
       def reconnect! #:nodoc:
-        clear_cache!
+        super
         @connection.reset!
-      rescue OracleEnhancedConnectionException => e
+      rescue OracleEnhanced::ConnectionException => e
         @logger.warn "#{adapter_name} automatic reconnection failed: #{e.message}" if @logger
       end
 
@@ -578,188 +399,16 @@ module ActiveRecord
 
       # Disconnects from the database.
       def disconnect! #:nodoc:
-        clear_cache!
+        super
         @connection.logoff rescue nil
       end
 
-      # DATABASE STATEMENTS ======================================
-      #
-      # see: abstract/database_statements.rb
-
-      # Executes a SQL statement
-      def execute(sql, name = nil)
-        log(sql, name) { @connection.exec(sql) }
-      end
-
-      def substitute_at(column, index)
-        Arel.sql(":a#{index + 1}")
-      end
-
-      def clear_cache!
-        @statements.clear
-      end
-
-      def exec_query(sql, name = 'SQL', binds = [])
-        log(sql, name, binds) do
-          cursor = nil
-          cached = false
-          if binds.empty?
-            cursor = @connection.prepare(sql)
-          else
-            unless @statements.key? sql
-              @statements[sql] = @connection.prepare(sql)
-            end
-
-            cursor = @statements[sql]
-
-            binds.each_with_index do |bind, i|
-              col, val = bind
-              cursor.bind_param(i + 1, type_cast(val, col), col)
-            end
-
-            cached = true
-          end
-
-          cursor.exec
-
-          if name == 'EXPLAIN'
-            res = true
-          else
-            columns = cursor.get_col_names.map do |col_name|
-              @connection.oracle_downcase(col_name)
-            end
-            rows = []
-            fetch_options = {:get_lob_value => (name != 'Writable Large Object')}
-            while row = cursor.fetch(fetch_options)
-              rows << row
-            end
-            res = ActiveRecord::Result.new(columns, rows)
-          end
-
-          cursor.close unless cached
-          res
-        end
-      end
-
-      def supports_statement_cache?
-        true
-      end
-
-      def supports_explain?
-        true
-      end
-
-      def explain(arel, binds = [])
-        sql = "EXPLAIN PLAN FOR #{to_sql(arel)}"
-        return if sql =~ /FROM all_/
-        if ORACLE_ENHANCED_CONNECTION == :jdbc
-          exec_query(sql, 'EXPLAIN', binds)
-        else
-          exec_query(sql, 'EXPLAIN')
-        end
-        select_values("SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY)", 'EXPLAIN').join("\n")
-      end
-
-      # Returns an array of arrays containing the field values.
-      # Order is the same as that returned by #columns.
-      def select_rows(sql, name = nil)
-        # last parameter indicates to return also column list
-        result = columns = nil
-        log(sql, name) do
-          result, columns = @connection.select(sql, name, true)
-        end
-        result.map{ |v| columns.map{|c| v[c]} }
-      end
-
-      # Executes an INSERT statement and returns the new record's ID
-      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-        # if primary key value is already prefetched from sequence
-        # or if there is no primary key
-        if id_value || pk.nil?
-          execute(sql, name)
-          return id_value
-        end
-
-        sql_with_returning = sql + @connection.returning_clause(quote_column_name(pk))
-        log(sql, name) do
-          @connection.exec_with_returning(sql_with_returning)
-        end
-      end
-      protected :insert_sql
-
-      # New method in ActiveRecord 3.1
-      # Will add RETURNING clause in case of trigger generated primary keys
-      def sql_for_insert(sql, pk, id_value, sequence_name, binds)
-        unless id_value || pk.nil? || (defined?(CompositePrimaryKeys) && pk.kind_of?(CompositePrimaryKeys::CompositeKeys))
-          sql = "#{sql} RETURNING #{quote_column_name(pk)} INTO :returning_id"
-          returning_id_col = OracleEnhancedColumn.new("returning_id", nil, "number", true, "dual", :integer, true, true)
-          (binds = binds.dup) << [returning_id_col, nil]
-        end
-        [sql, binds]
-      end
-
-      # New method in ActiveRecord 3.1
-      def exec_insert(sql, name, binds)
-        log(sql, name, binds) do
-          returning_id_col = returning_id_index = nil
-          cursor = if @statements.key?(sql)
-            @statements[sql]
-          else
-            @statements[sql] = @connection.prepare(sql)
-          end
-
-          binds.each_with_index do |bind, i|
-            col, val = bind
-            if col.returning_id?
-              returning_id_col = [col]
-              returning_id_index = i + 1
-              cursor.bind_returning_param(returning_id_index, Integer)
-            else
-              cursor.bind_param(i + 1, type_cast(val, col), col)
-            end
-          end
-
-          cursor.exec_update
-
-          rows = []
-          if returning_id_index
-            returning_id = cursor.get_returning_param(returning_id_index, Integer)
-            rows << [returning_id]
-          end
-          ActiveRecord::Result.new(returning_id_col || [], rows)
-        end
-      end
-
-      # New method in ActiveRecord 3.1
-      def exec_update(sql, name, binds)
-        log(sql, name, binds) do
-          cached = false
-          if binds.empty?
-            cursor = @connection.prepare(sql)
-          else
-            cursor = if @statements.key?(sql)
-              @statements[sql]
-            else
-              @statements[sql] = @connection.prepare(sql)
-            end
-
-            binds.each_with_index do |bind, i|
-              col, val = bind
-              cursor.bind_param(i + 1, type_cast(val, col), col)
-            end
-            cached = true
-          end
-
-          res = cursor.exec_update
-          cursor.close unless cached
-          res
-        end
+      def discard!
+        @connection = nil
       end
 
-      alias :exec_delete :exec_update
-
       # use in set_sequence_name to avoid fetching primary key value from sequence
-      AUTOGENERATED_SEQUENCE_NAME = 'autogenerated'.freeze
+      AUTOGENERATED_SEQUENCE_NAME = "autogenerated".freeze
 
       # Returns the next sequence value from a sequence generator. Not generally
       # called directly; used by ActiveRecord to get the next primary key value
@@ -768,266 +417,81 @@ module ActiveRecord
         # if sequence_name is set to :autogenerated then it means that primary key will be populated by trigger
         return nil if sequence_name == AUTOGENERATED_SEQUENCE_NAME
         # call directly connection method to avoid prepared statement which causes fetching of next sequence value twice
-        @connection.select_value("SELECT #{quote_table_name(sequence_name)}.NEXTVAL FROM dual")
-      end
-
-      def begin_db_transaction #:nodoc:
-        @connection.autocommit = false
-      end
-
-      def commit_db_transaction #:nodoc:
-        @connection.commit
-      ensure
-        @connection.autocommit = true
-      end
-
-      def rollback_db_transaction #:nodoc:
-        @connection.rollback
-      ensure
-        @connection.autocommit = true
-      end
-
-      def create_savepoint #:nodoc:
-        execute("SAVEPOINT #{current_savepoint_name}")
-      end
-
-      def rollback_to_savepoint #:nodoc:
-        execute("ROLLBACK TO #{current_savepoint_name}")
-      end
-
-      def release_savepoint #:nodoc:
-        # there is no RELEASE SAVEPOINT statement in Oracle
-      end
-
-      def add_limit_offset!(sql, options) #:nodoc:
-        # added to_i for limit and offset to protect from SQL injection
-        offset = (options[:offset] || 0).to_i
-        limit = options[:limit]
-        limit = limit.is_a?(String) && limit.blank? ? nil : limit && limit.to_i
-        if limit && offset > 0
-          sql.replace "SELECT * FROM (SELECT raw_sql_.*, ROWNUM raw_rnum_ FROM (#{sql}) raw_sql_ WHERE ROWNUM <= #{offset+limit}) WHERE raw_rnum_ > #{offset}"
-        elsif limit
-          sql.replace "SELECT * FROM (#{sql}) WHERE ROWNUM <= #{limit}"
-        elsif offset > 0
-          sql.replace "SELECT * FROM (SELECT raw_sql_.*, ROWNUM raw_rnum_ FROM (#{sql}) raw_sql_) WHERE raw_rnum_ > #{offset}"
-        end
+        select_value(<<-SQL.strip.gsub(/\s+/, " "), "next sequence value")
+          SELECT #{quote_table_name(sequence_name)}.NEXTVAL FROM dual
+        SQL
       end
 
-      @@do_not_prefetch_primary_key = {}
-
       # Returns true for Oracle adapter (since Oracle requires primary key
       # values to be pre-fetched before insert). See also #next_sequence_value.
       def prefetch_primary_key?(table_name = nil)
         return true if table_name.nil?
         table_name = table_name.to_s
-        do_not_prefetch = @@do_not_prefetch_primary_key[table_name]
-        if do_not_prefetch.nil?
-          owner, desc_table_name, db_link = @connection.describe(table_name)
-          @@do_not_prefetch_primary_key[table_name] = do_not_prefetch =
-            !has_primary_key?(table_name, owner, desc_table_name, db_link) ||
-            has_primary_key_trigger?(table_name, owner, desc_table_name, db_link)
-        end
+        owner, desc_table_name, db_link = @connection.describe(table_name)
+        do_not_prefetch = !has_primary_key?(table_name, owner, desc_table_name, db_link) || has_primary_key_trigger?(table_name, owner, desc_table_name, db_link)
         !do_not_prefetch
       end
 
-      # used just in tests to clear prefetch primary key flag for all tables
-      def clear_prefetch_primary_key #:nodoc:
-        @@do_not_prefetch_primary_key = {}
-      end
-
-      # Returns default sequence name for table.
-      # Will take all or first 26 characters of table name and append _seq suffix
-      def default_sequence_name(table_name, primary_key = nil)
-        # TODO: remove schema prefix if present before truncating
-        # truncate table name if necessary to fit in max length of identifier
-        "#{table_name.to_s[0,IDENTIFIER_MAX_LENGTH-4]}_seq"
-      end
-
-      # Inserts the given fixture into the table. Overridden to properly handle lobs.
-      def insert_fixture(fixture, table_name) #:nodoc:
-        super
-
-        if ActiveRecord::Base.pluralize_table_names
-          klass = table_name.singularize.camelize
-        else
-          klass = table_name.camelize
+      def reset_pk_sequence!(table_name, primary_key = nil, sequence_name = nil) #:nodoc:
+        return nil unless data_source_exists?(table_name)
+        unless primary_key && sequence_name
+          # *Note*: Only primary key is implemented - sequence will be nil.
+          primary_key, sequence_name = pk_and_sequence_for(table_name)
+          # TODO This sequence_name implemantation is just enough
+          # to satisty fixures. To get correct sequence_name always
+          # pk_and_sequence_for method needs some work.
+          begin
+            sequence_name = table_name.classify.constantize.sequence_name
+          rescue
+            sequence_name = default_sequence_name(table_name)
+          end
         end
 
-        klass = klass.constantize rescue nil
-        if klass.respond_to?(:ancestors) && klass.ancestors.include?(ActiveRecord::Base)
-          write_lobs(table_name, klass, fixture, klass.lob_columns)
+        if @logger && primary_key && !sequence_name
+          @logger.warn "#{table_name} has primary key #{primary_key} with no default sequence"
         end
-      end
 
-      # Writes LOB values from attributes for specified columns
-      def write_lobs(table_name, klass, attributes, columns) #:nodoc:
-        # is class with composite primary key>
-        is_with_cpk = klass.respond_to?(:composite?) && klass.composite?
-        if is_with_cpk
-          id = klass.primary_key.map {|pk| attributes[pk.to_s] }
-        else
-          id = quote(attributes[klass.primary_key])
-        end
-        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]
-          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"
-            unless lob_record = select_one(sql, 'Writable Large Object')
-              raise ActiveRecord::RecordNotFound, "statement #{sql} returned no rows"
-            end
-            lob = lob_record[col.name]
-            @connection.write_lob(lob, value.to_s, col.type == :binary)
-          end
+        if primary_key && sequence_name
+          new_start_value = select_value(<<-SQL.strip.gsub(/\s+/, " "), "new start value")
+            select NVL(max(#{quote_column_name(primary_key)}),0) + 1 from #{quote_table_name(table_name)}
+          SQL
+
+          execute "DROP SEQUENCE #{quote_table_name(sequence_name)}"
+          execute "CREATE SEQUENCE #{quote_table_name(sequence_name)} START WITH #{new_start_value}"
         end
       end
 
       # Current database name
       def current_database
-        select_value("SELECT SYS_CONTEXT('userenv', 'db_name') FROM dual")
+        select_value(<<-SQL.strip.gsub(/\s+/, " "), "current database on CDB ")
+          SELECT SYS_CONTEXT('userenv', 'con_name') FROM dual
+        SQL
+      rescue ActiveRecord::StatementInvalid
+        select_value(<<-SQL.strip.gsub(/\s+/, " "), "current database")
+          SELECT SYS_CONTEXT('userenv', 'db_name') FROM dual
+        SQL
       end
 
       # Current database session user
       def current_user
-        select_value("SELECT SYS_CONTEXT('userenv', 'session_user') 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')")
-      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'",
-        name)
-      end
-
-      # Will return true if database object exists (to be able to use also views and synonyms for ActiveRecord models)
-      def table_exists?(table_name)
-        (owner, table_name, db_link) = @connection.describe(table_name)
-        true
-      rescue
-        false
-      end
-
-      def materialized_views #:nodoc:
-        select_values("SELECT LOWER(mview_name) FROM all_mviews WHERE owner = SYS_CONTEXT('userenv', 'session_user')")
-      end
-
-      cattr_accessor :all_schema_indexes #:nodoc:
-
-      # This method selects all indexes at once, and caches them in a class variable.
-      # Subsequent index calls get them from the variable, without going to the DB.
-      def indexes(table_name, name = nil) #:nodoc:
-        (owner, table_name, db_link) = @connection.describe(table_name)
-        unless all_schema_indexes
-          default_tablespace_name = default_tablespace
-          result = select_all(<<-SQL.strip.gsub(/\s+/, ' '))
-            SELECT LOWER(i.table_name) AS table_name, LOWER(i.index_name) AS index_name, i.uniqueness,
-              i.index_type, i.ityp_owner, i.ityp_name, i.parameters,
-              LOWER(i.tablespace_name) AS tablespace_name,
-              LOWER(c.column_name) AS column_name, e.column_expression,
-              atc.virtual_column
-            FROM all_indexes#{db_link} i
-              JOIN all_ind_columns#{db_link} c ON c.index_name = i.index_name AND c.index_owner = i.owner
-              LEFT OUTER JOIN all_ind_expressions#{db_link} e ON e.index_name = i.index_name AND
-                e.index_owner = i.owner AND e.column_position = c.column_position
-              LEFT OUTER JOIN all_tab_cols#{db_link} atc ON i.table_name = atc.table_name AND
-                c.column_name = atc.column_name AND i.owner = atc.owner AND atc.hidden_column = 'NO'
-            WHERE i.owner = '#{owner}'
-               AND i.table_owner = '#{owner}'
-               AND NOT EXISTS (SELECT uc.index_name FROM all_constraints uc
-                WHERE uc.index_name = i.index_name AND uc.owner = i.owner AND uc.constraint_type = 'P')
-            ORDER BY i.index_name, c.column_position
-          SQL
-
-          current_index = nil
-          self.all_schema_indexes = []
-
-          result.each do |row|
-            # have to keep track of indexes because above query returns dups
-            # there is probably a better query we could figure out
-            if current_index != row['index_name']
-              statement_parameters = nil
-              if row['index_type'] == 'DOMAIN' && row['ityp_owner'] == 'CTXSYS' && row['ityp_name'] == 'CONTEXT'
-                procedure_name = default_datastore_procedure(row['index_name'])
-                source = select_values(<<-SQL).join
-                  SELECT text
-                  FROM all_source#{db_link}
-                  WHERE owner = '#{owner}'
-                    AND name = '#{procedure_name.upcase}'
-                  ORDER BY line
-                SQL
-                if source =~ /-- add_context_index_parameters (.+)\n/
-                  statement_parameters = $1
-                end
-              end
-              all_schema_indexes << OracleEnhancedIndexDefinition.new(row['table_name'], row['index_name'],
-                row['uniqueness'] == "UNIQUE", row['index_type'] == 'DOMAIN' ? "#{row['ityp_owner']}.#{row['ityp_name']}" : nil,
-                row['parameters'], statement_parameters,
-                row['tablespace_name'] == default_tablespace_name ? nil : row['tablespace_name'], [])
-              current_index = row['index_name']
-            end
-
-            # Functional index columns and virtual columns both get stored as column expressions,
-            # but re-creating a virtual column index as an expression (instead of using the virtual column's name)
-            # results in a ORA-54018 error.  Thus, we only want the column expression value returned
-            # when the column is not virtual.
-            if row['column_expression'] && row['virtual_column'] != 'YES'
-              all_schema_indexes.last.columns << row['column_expression']
-            else
-              all_schema_indexes.last.columns << row['column_name'].downcase
-            end
-          end
-        end
-
-        # Return the indexes just for the requested table, since AR is structured that way
-        table_name = table_name.downcase
-        all_schema_indexes.select{|i| i.table == table_name}
-      end
-
-      @@ignore_table_columns = nil #:nodoc:
-
-      # set ignored columns for table
-      def ignore_table_columns(table_name, *args) #:nodoc:
-        @@ignore_table_columns ||= {}
-        @@ignore_table_columns[table_name] ||= []
-        @@ignore_table_columns[table_name] += args.map{|a| a.to_s.downcase}
-        @@ignore_table_columns[table_name].uniq!
-      end
-
-      def ignored_table_columns(table_name) #:nodoc:
-        @@ignore_table_columns ||= {}
-        @@ignore_table_columns[table_name]
-      end
-
-      # used just in tests to clear ignored table columns
-      def clear_ignored_table_columns #:nodoc:
-        @@ignore_table_columns = nil
-      end
-
-      @@table_column_type = nil #:nodoc:
-
-      # set explicit type for specified table columns
-      def set_type_for_columns(table_name, column_type, *args) #:nodoc:
-        @@table_column_type ||= {}
-        @@table_column_type[table_name] ||= {}
-        args.each do |col|
-          @@table_column_type[table_name][col.to_s.downcase] = column_type
-        end
+        select_value(<<-SQL.strip.gsub(/\s+/, " "), "current user")
+          SELECT SYS_CONTEXT('userenv', 'session_user') FROM dual
+        SQL
       end
 
-      def get_type_for_column(table_name, column_name) #:nodoc:
-        @@table_column_type && @@table_column_type[table_name] && @@table_column_type[table_name][column_name.to_s.downcase]
+      # Current database session schema
+      def current_schema
+        select_value(<<-SQL.strip.gsub(/\s+/, " "), "current schema")
+          SELECT SYS_CONTEXT('userenv', 'current_schema') FROM dual
+        SQL
       end
 
-      # used just in tests to clear column data type definitions
-      def clear_types_for_columns #:nodoc:
-        @@table_column_type = nil
+      # Default tablespace name of current user
+      def default_tablespace
+        select_value(<<-SQL.strip.gsub(/\s+/, " "), "default tablespace")
+          SELECT LOWER(default_tablespace) FROM user_users
+          WHERE username = SYS_CONTEXT('userenv', 'current_schema')
+        SQL
       end
 
       # check if table has primary key trigger with _pkt suffix
@@ -1035,152 +499,76 @@ module ActiveRecord
         (owner, desc_table_name, db_link) = @connection.describe(table_name) unless owner
 
         trigger_name = default_trigger_name(table_name).upcase
-        pkt_sql = <<-SQL
+
+        !!select_value(<<-SQL.strip.gsub(/\s+/, " "), "Primary Key Trigger", [bind_string("owner", owner), bind_string("trigger_name", trigger_name), bind_string("owner", owner), bind_string("table_name", desc_table_name)])
           SELECT trigger_name
           FROM all_triggers#{db_link}
-          WHERE owner = '#{owner}'
-            AND trigger_name = '#{trigger_name}'
-            AND table_owner = '#{owner}'
-            AND table_name = '#{desc_table_name}'
+          WHERE owner = :owner
+            AND trigger_name = :trigger_name
+            AND table_owner = :owner
+            AND table_name = :table_name
             AND status = 'ENABLED'
         SQL
-        select_value(pkt_sql, 'Primary Key Trigger') ? true : false
-      end
-
-      ##
-      # :singleton-method:
-      # Cache column description between requests.
-      # Could be used in development environment to avoid selecting table columns from data dictionary tables for each request.
-      # This can speed up request processing in development mode if development database is not on local computer.
-      #
-      #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.cache_columns = true
-      cattr_accessor :cache_columns
-      self.cache_columns = false
-
-      def columns(table_name, name = nil) #:nodoc:
-        if @@cache_columns
-          @@columns_cache ||= {}
-          @@columns_cache[table_name] ||= columns_without_cache(table_name, name)
-        else
-          columns_without_cache(table_name, name)
-        end
       end
 
-      def columns_without_cache(table_name, name = nil) #:nodoc:
-        table_name = table_name.to_s
-        # get ignored_columns by original table name
-        ignored_columns = ignored_table_columns(table_name)
-
+      def column_definitions(table_name)
         (owner, desc_table_name, db_link) = @connection.describe(table_name)
 
-        # reset do_not_prefetch_primary_key cache for this table
-        @@do_not_prefetch_primary_key[table_name] = nil
-
-        table_cols = <<-SQL.strip.gsub(/\s+/, ' ')
-          SELECT column_name AS name, data_type AS sql_type, data_default, nullable, virtual_column, hidden_column, data_type_owner AS sql_type_owner,
-                 DECODE(data_type, 'NUMBER', data_precision,
+        select_all(<<-SQL.strip.gsub(/\s+/, " "), "Column definitions", [bind_string("owner", owner), bind_string("table_name", desc_table_name)])
+          SELECT cols.column_name AS name, cols.data_type AS sql_type,
+                 cols.data_default, cols.nullable, cols.virtual_column, cols.hidden_column,
+                 cols.data_type_owner AS sql_type_owner,
+                 DECODE(cols.data_type, 'NUMBER', data_precision,
                                    'FLOAT', data_precision,
                                    'VARCHAR2', DECODE(char_used, 'C', char_length, data_length),
                                    'RAW', DECODE(char_used, 'C', char_length, data_length),
                                    'CHAR', DECODE(char_used, 'C', char_length, data_length),
                                     NULL) AS limit,
-                 DECODE(data_type, 'NUMBER', data_scale, NULL) AS scale
-            FROM all_tab_cols#{db_link}
-           WHERE owner      = '#{owner}'
-             AND table_name = '#{desc_table_name}'
-             AND hidden_column = 'NO'
-           ORDER BY column_id
+                 DECODE(data_type, 'NUMBER', data_scale, NULL) AS scale,
+                 comments.comments as column_comment
+            FROM all_tab_cols#{db_link} cols, all_col_comments#{db_link} comments
+           WHERE cols.owner      = :owner
+             AND cols.table_name = :table_name
+             AND cols.hidden_column = 'NO'
+             AND cols.owner = comments.owner
+             AND cols.table_name = comments.table_name
+             AND cols.column_name = comments.column_name
+           ORDER BY cols.column_id
         SQL
-
-        # added deletion of ignored columns
-        select_all(table_cols, name).delete_if do |row|
-          ignored_columns && ignored_columns.include?(row['name'].downcase)
-        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})" : ")")
-          end
-
-          if row['sql_type_owner']
-            row['sql_type'] = row['sql_type_owner'] + '.' + row['sql_type']
-          end
-
-          is_virtual = row['virtual_column']=='YES'
-
-          # clean up odd default spacing from Oracle
-          if row['data_default'] && !is_virtual
-            row['data_default'].sub!(/^(.*?)\s*$/, '\1')
-
-            # If a default contains a newline these cleanup regexes need to
-            # match newlines.
-            row['data_default'].sub!(/^'(.*)'$/m, '\1')
-            row['data_default'] = nil if row['data_default'] =~ /^(null|empty_[bc]lob\(\))$/i
-          end
-
-          OracleEnhancedColumn.new(oracle_downcase(row['name']),
-                           row['data_default'],
-                           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)
-        end
-      end
-
-      # used just in tests to clear column cache
-      def clear_columns_cache #:nodoc:
-        @@columns_cache = nil
-        @@pk_and_sequence_for_cache = nil
       end
 
-      # used in migrations to clear column cache for specified table
-      def clear_table_columns_cache(table_name)
-        if @@cache_columns
-          @@columns_cache ||= {}
-          @@columns_cache[table_name.to_s] = nil
-        end
-      end
-
-      ##
-      # :singleton-method:
-      # Specify default sequence start with value (by default 10000 if not explicitly set), e.g.:
-      #
-      #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_sequence_start_value = 1
-      cattr_accessor :default_sequence_start_value
-      self.default_sequence_start_value = 10000
-
       # 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:
-        if @@cache_columns
-          @@pk_and_sequence_for_cache ||= {}
-          if @@pk_and_sequence_for_cache.key?(table_name)
-            @@pk_and_sequence_for_cache[table_name]
-          else
-            @@pk_and_sequence_for_cache[table_name] = pk_and_sequence_for_without_cache(table_name, owner, desc_table_name, db_link)
-          end
-        else
-          pk_and_sequence_for_without_cache(table_name, owner, desc_table_name, db_link)
-        end
-      end
-
-      def pk_and_sequence_for_without_cache(table_name, owner=nil, desc_table_name=nil, db_link=nil) #:nodoc:
+      def pk_and_sequence_for(table_name, owner = nil, desc_table_name = nil, db_link = nil) #:nodoc:
         (owner, desc_table_name, db_link) = @connection.describe(table_name) unless owner
 
+        seqs = select_values(<<-SQL.strip.gsub(/\s+/, " "), "Sequence", [bind_string("owner", owner), bind_string("sequence_name", default_sequence_name(desc_table_name).upcase)])
+          select us.sequence_name
+          from all_sequences#{db_link} us
+          where us.sequence_owner = :owner
+          and us.sequence_name = :sequence_name
+        SQL
+
         # changed back from user_constraints to all_constraints for consistency
-        pks = select_values(<<-SQL.strip.gsub(/\s+/, ' '), 'Primary Key')
+        pks = select_values(<<-SQL.strip.gsub(/\s+/, " "), "Primary Key", [bind_string("owner", owner), bind_string("table_name", desc_table_name)])
           SELECT cc.column_name
             FROM all_constraints#{db_link} c, all_cons_columns#{db_link} cc
-           WHERE c.owner = '#{owner}'
-             AND c.table_name = '#{desc_table_name}'
+           WHERE c.owner = :owner
+             AND c.table_name = :table_name
              AND c.constraint_type = 'P'
              AND cc.owner = c.owner
              AND cc.constraint_name = c.constraint_name
         SQL
 
+        warn <<-WARNING.strip_heredoc if pks.count > 1
+          WARNING: Active Record does not support composite primary key.
+
+          #{table_name} has composite primary key. Composite primary key is ignored.
+        WARNING
+
         # only support single column keys
-        pks.size == 1 ? [oracle_downcase(pks.first), nil] : nil
+        pks.size == 1 ? [oracle_downcase(pks.first),
+                         oracle_downcase(seqs.first)] : nil
       end
 
       # Returns just a table's primary key
@@ -1189,215 +577,129 @@ module ActiveRecord
         pk_and_sequence && pk_and_sequence.first
       end
 
-      def has_primary_key?(table_name, owner=nil, desc_table_name=nil, db_link=nil) #:nodoc:
+      def has_primary_key?(table_name, owner = nil, desc_table_name = nil, db_link = nil) #:nodoc:
         !pk_and_sequence_for(table_name, owner, desc_table_name, db_link).nil?
       end
 
-      # 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
-      # queries. However, with those columns included in the SELECT DISTINCT list, you
-      # won't actually get a distinct list of the column you want (presuming the column
-      # has duplicates with multiple values for the ordered-by columns. So we use the
-      # FIRST_VALUE function to get a single (first) value for each column, effectively
-      # making every row the same.
-      #
-      #   distinct("posts.id", "posts.created_at desc")
-      def distinct(columns, order_by) #:nodoc:
-        return "DISTINCT #{columns}" if order_by.blank?
-
-        # construct a valid DISTINCT clause, ie. one that includes the ORDER BY columns, using
-        # FIRST_VALUE such that the inclusion of these columns doesn't invalidate the DISTINCT
-        order_columns = if order_by.is_a?(String)
-          order_by.split(',').map { |s| s.strip }.reject(&:blank?)
-        else # in latest ActiveRecord versions order_by is already Array
-          order_by
-        end
-        order_columns = order_columns.zip((0...order_columns.size).to_a).map do |c, i|
-          # remove any ASC/DESC modifiers
-          value = c =~ /^(.+)\s+(ASC|DESC)\s*$/i ? $1 : c
-          "FIRST_VALUE(#{value}) OVER (PARTITION BY #{columns} ORDER BY #{c}) AS alias_#{i}__"
-        end
-        sql = "DISTINCT #{columns}, "
-        sql << order_columns * ", "
-      end
+      def primary_keys(table_name) # :nodoc:
+        (owner, desc_table_name, db_link) = @connection.describe(table_name) unless owner
 
-      def temporary_table?(table_name) #:nodoc:
-        select_value("SELECT temporary FROM user_tables WHERE table_name = '#{table_name.upcase}'") == 'Y'
+        pks = select_values(<<-SQL.strip.gsub(/\s+/, " "), "Primary Keys", [bind_string("owner", owner), bind_string("table_name", desc_table_name)])
+          SELECT cc.column_name
+            FROM all_constraints#{db_link} c, all_cons_columns#{db_link} cc
+           WHERE c.owner = :owner
+             AND c.table_name = :table_name
+             AND c.constraint_type = 'P'
+             AND cc.owner = c.owner
+             AND cc.constraint_name = c.constraint_name
+             order by cc.position
+        SQL
+        pks.map { |pk| oracle_downcase(pk) }
       end
 
-      # ORDER BY clause for the passed order option.
-      #
-      # Uses column aliases as defined by #distinct.
-      #
-      # In Rails 3.x this method is moved to Arel
-      def add_order_by_for_association_limiting!(sql, options) #:nodoc:
-        return sql if options[:order].blank?
-
-        order = options[:order].split(',').collect { |s| s.strip }.reject(&:blank?)
-        order.map! {|s| $1 if s =~ / (.*)/}
-        order = order.zip((0...order.size).to_a).map { |s,i| "alias_#{i}__ #{s}" }.join(', ')
-
-        sql << " ORDER BY #{order}"
+      def columns_for_distinct(columns, orders) #:nodoc:
+        # construct a valid columns name for DISTINCT clause,
+        # ie. one that includes the ORDER BY columns, using FIRST_VALUE such that
+        # the inclusion of these columns doesn't invalidate the DISTINCT
+        #
+        # It does not construct DISTINCT clause. Just return column names for distinct.
+        order_columns = orders.reject(&:blank?).map { |s|
+            s = s.to_sql unless s.is_a?(String)
+            # remove any ASC/DESC modifiers
+            s.gsub(/\s+(ASC|DESC)\s*?/i, "")
+          }.reject(&:blank?).map.with_index { |column, i|
+            "FIRST_VALUE(#{column}) OVER (PARTITION BY #{columns} ORDER BY #{column}) AS alias_#{i}__"
+          }
+        [super, *order_columns].join(", ")
       end
 
-      # construct additional wrapper subquery if select.offset is used to avoid generation of invalid subquery
-      # ... IN ( SELECT * FROM ( SELECT raw_sql_.*, rownum raw_rnum_ FROM ( ... ) raw_sql_ ) WHERE raw_rnum_ > ... )
-      def join_to_update(update, select) #:nodoc:
-        if select.offset
-          subsubselect = select.clone
-          subsubselect.projections = [update.key]
-
-          subselect = Arel::SelectManager.new(select.engine)
-          subselect.project Arel.sql(quote_column_name update.key.name)
-          subselect.from subsubselect.as('alias_join_to_update')
-
-          update.where update.key.in(subselect)
-        else
-          super
-        end
+      def temporary_table?(table_name) #:nodoc:
+        select_value(<<-SQL.strip.gsub(/\s+/, " "), "temporary table", [bind_string("table_name", table_name.upcase)]) == "Y"
+          SELECT temporary FROM all_tables WHERE table_name = :table_name and owner = SYS_CONTEXT('userenv', 'session_user')
+        SQL
       end
 
-      protected
+      private
 
-      def translate_exception(exception, message) #:nodoc:
-        case @connection.error_code(exception)
-        when 1
-          RecordNotUnique.new(message, exception)
-        when 2291
-          InvalidForeignKey.new(message, exception)
-        else
+        def initialize_type_map(m = type_map)
           super
-        end
-      end
-
-      private
+          # oracle
+          register_class_with_precision m, %r(WITH TIME ZONE)i,       Type::OracleEnhanced::TimestampTz
+          register_class_with_precision m, %r(WITH LOCAL TIME ZONE)i, Type::OracleEnhanced::TimestampLtz
+          register_class_with_limit m, %r(raw)i,            Type::OracleEnhanced::Raw
+          register_class_with_limit m, %r(char)i,           Type::OracleEnhanced::String
+          register_class_with_limit m, %r(clob)i,           Type::OracleEnhanced::Text
+          register_class_with_limit m, %r(nclob)i,           Type::OracleEnhanced::NationalCharacterText
+
+          m.register_type "NCHAR", Type::OracleEnhanced::NationalCharacterString.new
+          m.alias_type %r(NVARCHAR2)i,    "NCHAR"
+
+          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
+              Type::OracleEnhanced::Integer.new(precision: precision, limit: limit)
+            else
+              Type::Decimal.new(precision: precision, scale: scale)
+            end
+          end
 
-      def select(sql, name = nil, binds = [])
-        if ActiveRecord.const_defined?(:Result)
-          exec_query(sql, name, binds).to_a
-        else
-          log(sql, name) do
-            @connection.select(sql, name, false)
+          if OracleEnhancedAdapter.emulate_booleans
+            m.register_type %r(^NUMBER\(1\))i, Type::Boolean.new
           end
         end
-      end
-
-      def oracle_downcase(column_name)
-        @connection.oracle_downcase(column_name)
-      end
 
-      def compress_lines(string, join_with = "\n")
-        string.split($/).map { |line| line.strip }.join(join_with)
-      end
-
-      public
-      # DBMS_OUTPUT =============================================
-      #
-      # PL/SQL in Oracle uses dbms_output for logging print statements
-      # These methods stick that output into the Rails log so Ruby and PL/SQL
-      # code can can be debugged together in a single application
-
-      # Maximum DBMS_OUTPUT buffer size
-      DBMS_OUTPUT_BUFFER_SIZE = 10000  # can be 1-1000000
-
-      # Turn DBMS_Output logging on
-      def enable_dbms_output
-        set_dbms_output_plsql_connection
-        @enable_dbms_output = true
-        plsql(:dbms_output).sys.dbms_output.enable(DBMS_OUTPUT_BUFFER_SIZE)
-      end
-      # Turn DBMS_Output logging off
-      def disable_dbms_output
-        set_dbms_output_plsql_connection
-        @enable_dbms_output = false
-        plsql(:dbms_output).sys.dbms_output.disable
-      end
-      # Is DBMS_Output logging enabled?
-      def dbms_output_enabled?
-        @enable_dbms_output
-      end
-
-      protected
-      def log(sql, name, binds = nil) #:nodoc:
-        if binds
-          super sql, name, binds
-        else
-          super sql, name
+        def extract_value_from_default(default)
+          case default
+          when String
+            default.gsub("''", "'")
+          else
+            default
+          end
         end
-      ensure
-        log_dbms_output if dbms_output_enabled?
-      end
 
-      private
-
-      def set_dbms_output_plsql_connection
-        raise OracleEnhancedConnectionException, "ruby-plsql gem is required for logging DBMS output" unless self.respond_to?(:plsql)
-        # do not reset plsql connection if it is the same (as resetting will clear PL/SQL metadata cache)
-        unless plsql(:dbms_output).connection && plsql(:dbms_output).connection.raw_connection == raw_connection
-          plsql(:dbms_output).connection = raw_connection
+        def extract_limit(sql_type) #:nodoc:
+          case sql_type
+          when /^bigint/i
+            19
+          when /\((.*)\)/
+            $1.to_i
+          end
         end
-      end
 
-      def log_dbms_output
-        while true do
-          result = plsql(:dbms_output).sys.dbms_output.get_line(:line => '', :status => 0)
-          break unless result[:status] == 0
-          @logger.debug "DBMS_OUTPUT: #{result[:line]}" if @logger
+        def translate_exception(exception, message) #:nodoc:
+          case @connection.error_code(exception)
+          when 1
+            RecordNotUnique.new(message)
+          when 60
+            Deadlocked.new(message)
+          when 900, 904, 942, 955, 1418, 2289, 2449, 17008
+            ActiveRecord::StatementInvalid.new(message)
+          when 1400
+            ActiveRecord::NotNullViolation.new(message)
+          when 2291
+            InvalidForeignKey.new(message)
+          when 12899
+            ValueTooLong.new(message)
+          else
+            super
+          end
         end
-      end
 
-    end
-  end
-end
+        # create bind object for type String
+        def bind_string(name, value)
+          ActiveRecord::Relation::QueryAttribute.new(name, value, Type::OracleEnhanced::String.new)
+        end
 
-# Added LOB writing callback for sessions stored in database
-# Otherwise it is not working as Session class is defined before OracleAdapter is loaded in Rails 2.0
-if defined?(CGI::Session::ActiveRecordStore::Session)
-  if !CGI::Session::ActiveRecordStore::Session.respond_to?(:after_save_callback_chain) ||
-      CGI::Session::ActiveRecordStore::Session.after_save_callback_chain.detect{|cb| cb.method == :enhanced_write_lobs}.nil?
-    #:stopdoc:
-    class CGI::Session::ActiveRecordStore::Session
-      after_save :enhanced_write_lobs
+        ActiveRecord::Type.register(:boolean, Type::OracleEnhanced::Boolean, adapter: :oracleenhanced)
+        ActiveRecord::Type.register(:json, Type::OracleEnhanced::Json, adapter: :oracleenhanced)
     end
-    #:startdoc:
   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'
+require "active_record/connection_adapters/oracle_enhanced/version"
 
-# 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'
-
-# Load additional methods for composite_primary_keys support
-require 'active_record/connection_adapters/oracle_enhanced_cpk'
-
-# Load patch for dirty tracking methods
-require 'active_record/connection_adapters/oracle_enhanced_dirty'
-
-# Load rake tasks definitions
-begin
-  require 'active_record/connection_adapters/oracle_enhanced_tasks'
-rescue LoadError
-end if defined?(Rails) || defined?(RAILS_ROOT)
-
-# Patches and enhancements for schema dumper
-require 'active_record/connection_adapters/oracle_enhanced_schema_dumper'
-
-# 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'
-
-require 'active_record/connection_adapters/oracle_enhanced_activerecord_patches'
-
-require 'active_record/connection_adapters/oracle_enhanced_version'
+module ActiveRecord
+  autoload :OracleEnhancedProcedures, "active_record/connection_adapters/oracle_enhanced/procedures"
+end