activerecord-oracle_enhanced-adapter 1.7.3 → 1.8.0

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -28,17 +28,18 @@
 # contribution.
 # 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/database_statements'
-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/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/quoting'
-
-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_statements"
+require "active_record/connection_adapters/oracle_enhanced/schema_statements_ext"
+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/quoting"
+
+require "digest/sha1"
 
 ActiveRecord::Base.class_eval do
   class_attribute :custom_create_method, :custom_update_method, :custom_delete_method
@@ -46,90 +47,12 @@ end
 
 module ActiveRecord
   class Base
-
-    # Specify table columns which should be ignored by ActiveRecord, e.g.:
-    #
-    #   ignore_table_columns :attribute1, :attribute2
-    def self.ignore_table_columns(*args)
-      connection.ignore_table_columns(table_name,*args)
-    end
-
-    # Specify which table columns should be typecasted to Date (without time), e.g.:
-    #
-    #   set_date_columns :created_on, :updated_on
-    def self.set_date_columns(*args)
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        'set_date_columns` has been deprecated. Please use Rails attribute API.
-      MSG
-      # connection.set_type_for_columns(table_name,:date,*args)
-    end
-
-    # Specify which table columns should be typecasted to Time (or DateTime), e.g.:
-    #
-    #   set_datetime_columns :created_date, :updated_date
-    def self.set_datetime_columns(*args)
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        'set_datetime_columns` has been deprecated. Please use Rails attribute API.
-      MSG
-      # connection.set_type_for_columns(table_name,:datetime,*args)
-    end
-
-    # Specify which table columns should be typecasted to boolean values +true+ or +false+, e.g.:
-    #
-    #   set_boolean_columns :is_valid, :is_completed
-    def self.set_boolean_columns(*args)
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        'set_boolean_columns` has been deprecated. Please use Rails attribute API.
-      MSG
-      # connection.set_type_for_columns(table_name,:boolean,*args)
-    end
-
-    # Specify which table columns should be typecasted to integer values.
-    # Might be useful to force NUMBER(1) column to be integer and not boolean, or force NUMBER column without
-    # scale to be retrieved as integer and not decimal. Example:
-    #
-    #   set_integer_columns :version_number, :object_identifier
-    def self.set_integer_columns(*args)
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        'set_integer_columns` has been deprecated. Please use Rails attribute API.
-      MSG
-      # connection.set_type_for_columns(table_name,:integer,*args)
-    end
-
-    # Specify which table columns should be typecasted to string values.
-    # Might be useful to specify that columns should be string even if its name matches boolean column criteria.
-    #
-    #   set_string_columns :active_flag
-    def self.set_string_columns(*args)
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        'set_string_columns` has been deprecated. Please use Rails attribute API.
-      MSG
-      # connection.set_type_for_columns(table_name,:string,*args)
-    end
-
-    # Get table comment from schema definition.
-    def self.table_comment
-      #TODO: may be deprecated
-      connection.table_comment(self.table_name)
-    end
-
     def self.lob_columns
       columns.select do |column|
         column.respond_to?(:lob?) && column.lob?
       end
     end
 
-    def self.virtual_columns
-      columns.select do |column|
-        column.respond_to?(:virtual?) && column.virtual?
-      end
-    end
-
-    def arel_attributes_with_values(attribute_names)
-      virtual_column_names = self.class.virtual_columns.map(&:name)
-      super(attribute_names - virtual_column_names)
-    end
-
     # After setting large objects to empty, select the OCI8::LOB
     # and write back the data.
     before_update :record_changed_lobs
@@ -137,21 +60,21 @@ module ActiveRecord
 
     private
 
-    def enhanced_write_lobs
-      if self.class.connection.is_a?(ConnectionAdapters::OracleEnhancedAdapter) &&
-          !(
-            (self.class.custom_create_method || self.class.custom_create_method) ||
-            (self.class.custom_update_method || self.class.custom_update_method)
-          )
-        self.class.connection.write_lobs(self.class.table_name, self.class, attributes, @changed_lob_columns)
+      def enhanced_write_lobs
+        if self.class.connection.is_a?(ConnectionAdapters::OracleEnhancedAdapter) &&
+            !(
+              (self.class.custom_create_method || self.class.custom_create_method) ||
+              (self.class.custom_update_method || self.class.custom_update_method)
+            )
+          self.class.connection.write_lobs(self.class.table_name, self.class, attributes, @changed_lob_columns)
+        end
       end
-    end
 
-    def record_changed_lobs
-      @changed_lob_columns = self.class.lob_columns.select do |col|
-        self.attribute_changed?(col.name) && !self.class.readonly_attributes.to_a.include?(col.name)
+      def record_changed_lobs
+        @changed_lob_columns = self.class.lob_columns.select do |col|
+          self.attribute_changed?(col.name) && !self.class.readonly_attributes.to_a.include?(col.name)
+        end
       end
-    end
   end
 end
 
@@ -162,7 +85,7 @@ module ActiveRecord
       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'
+        require "active_record/connection_adapters/emulation/oracle_adapter"
         ConnectionAdapters::OracleAdapter.new(
           ConnectionAdapters::OracleEnhancedConnection.create(config), logger, config)
       else
@@ -173,7 +96,6 @@ module ActiveRecord
   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)
     # or with JRuby and Oracle JDBC driver.
@@ -260,92 +182,16 @@ 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={}
-
-      ##
-      # :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)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          `self.is_date_column?` has been deprecated. Please use Rails attribute API.
-        MSG
-        return false
-        # 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:
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          `is_date_column?` has been deprecated. Please use Rails attribute API.
-        MSG
-        return false
-        #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)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          `is_integer_column?` has been deprecated. Please use Rails attribute API.
-        MSG
-        return false
-      end
+      self.default_tablespaces = {}
 
       ##
       # :singleton-method:
@@ -356,78 +202,32 @@ module ActiveRecord
       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, sql_type, table_name = nil)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          `is_boolean_column?` has been deprecated. Please use Rails attribute API.
-        MSG
-        return false
-        # 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.
-      # 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.:
-      #
-      #   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
-
-        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 = nil, config = {}) # :nodoc:
         super(connection, logger, config)
-        @quoted_column_names, @quoted_table_names = {}, {}
-        @statements = StatementPool.new(connection, config.fetch(:statement_limit) { 250 })
+        @statements = StatementPool.new(self.class.type_cast_config_to_integer(config[:statement_limit]))
         @enable_dbms_output = false
       end
 
-      ADAPTER_NAME = 'OracleEnhanced'.freeze
+      ADAPTER_NAME = "OracleEnhanced".freeze
 
       def adapter_name #:nodoc:
         ADAPTER_NAME
@@ -441,14 +241,6 @@ module ActiveRecord
         end
       end
 
-      def supports_migrations? #:nodoc:
-        true
-      end
-
-      def supports_primary_key? #:nodoc:
-        true
-      end
-
       def supports_savepoints? #:nodoc:
         true
       end
@@ -461,12 +253,16 @@ module ActiveRecord
         true
       end
 
+      def supports_foreign_keys_in_create?
+        supports_foreign_keys?
+      end
+
       def supports_views?
         true
       end
 
       def supports_fetch_first_n_rows_and_offset?
-        if @connection.database_version == [12,1]
+        if !use_old_oracle_visitor && @connection.database_version.first >= 12
           true
         else
           false
@@ -474,56 +270,88 @@ module ActiveRecord
       end
 
       def supports_datetime_with_precision?
-        #TODO: Needs to consider to return false to keep old behaviour
-        #to map :datetime as DATE
-        @connection.database_version.first >= 9
+        true
       end
 
       def supports_comments?
         true
       end
 
+      def supports_multi_insert?
+        @connection.database_version.to_s >= [11, 2].to_s
+      end
+
+      def supports_virtual_columns?
+        @connection.database_version.first >= 11
+      end
+
+      def supports_json?
+        # No migration supported for :json type due to there is no `JSON` data type
+        # in Oracle Database itself.
+        #
+        # 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)
+        #
+        @connection.database_version.first >= 12
+      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
+        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 => "BINARY_FLOAT" },
-        :decimal     => { :name => "DECIMAL" },
-        :datetime    => { :name => "TIMESTAMP" },
-        :timestamp   => { :name => "TIMESTAMP" },
-        :time        => { :name => "TIMESTAMP" },
-        :date        => { :name => "DATE" },
-        :binary      => { :name => "BLOB" },
-        :boolean     => { :name => "NUMBER", :limit => 1 },
-        :raw         => { :name => "RAW", :limit => 2000 },
-        :bigint      => { :name => "NUMBER", :limit => 19 }
+        primary_key: "NUMBER(38) NOT NULL PRIMARY KEY",
+        string: { name: "VARCHAR2", limit: 255 },
+        text: { name: "CLOB" },
+        integer: { name: "NUMBER", limit: 38 },
+        float: { name: "BINARY_FLOAT" },
+        decimal: { name: "DECIMAL" },
+        datetime: { name: "TIMESTAMP" },
+        timestamp: { name: "TIMESTAMP" },
+        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 }
+        boolean: { name: "VARCHAR2", limit: 1 }
       )
       #:startdoc:
 
@@ -573,7 +401,6 @@ module ActiveRecord
       def in_clause_length
         1000
       end
-      alias ids_in_list_limit in_clause_length
 
       # CONNECTION MANAGEMENT ====================================
       #
@@ -625,7 +452,7 @@ module ActiveRecord
       end
 
       # 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
@@ -661,8 +488,8 @@ module ActiveRecord
 
       def reset_pk_sequence!(table_name, primary_key = nil, sequence_name = nil) #:nodoc:
         return nil unless data_source_exists?(table_name)
-        unless primary_key and sequence_name
-        # *Note*: Only primary key is implemented - sequence will be nil.
+        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
@@ -690,24 +517,17 @@ module ActiveRecord
 
       # 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
+        id = quote(attributes[klass.primary_key])
         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 == '')
+          next if value.blank?
           if klass.attribute_types[col.name].is_a? ActiveRecord::Type::Serialized
             value = klass.attribute_types[col.name].serialize(value)
           end
           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')
+            sql = "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]
@@ -718,6 +538,8 @@ module ActiveRecord
 
       # Current database name
       def current_database
+        select_value("SELECT SYS_CONTEXT('userenv', 'con_name') FROM dual")
+      rescue ActiveRecord::StatementInvalid
         select_value("SELECT SYS_CONTEXT('userenv', 'db_name') FROM dual")
       end
 
@@ -736,40 +558,40 @@ module ActiveRecord
         select_value("SELECT LOWER(default_tablespace) FROM user_users WHERE username = SYS_CONTEXT('userenv', 'current_schema')")
       end
 
-      def tables(name = nil) #:nodoc:
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          #tables currently returns both tables and views.
-          This behavior is deprecated and will be changed with Rails 5.1 to only return tables.
-          Use #data_sources instead.
-        MSG
-
-        if name
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Passing arguments to #tables is deprecated without replacement.
-          MSG
-        end
-
-        data_sources
+      def tables #:nodoc:
+        select_values(<<-SQL, "SCHEMA")
+          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'
+        SQL
       end
 
-
       def data_sources
-        select_values(
-        "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'",
-        'SCHEMA')
+        super
       end
 
       def table_exists?(table_name)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          #table_exists? currently checks both tables and views.
-          This behavior is deprecated and will be changed with Rails 5.1 to only check tables.
-          Use #data_source_exists? instead.
-        MSG
-
-        data_source_exists?(table_name)
+        table_name = table_name.to_s
+        if table_name.include?("@")
+          # db link is not table
+          false
+        else
+          default_owner = current_schema
+        end
+        real_name = ActiveRecord::ConnectionAdapters::OracleEnhanced::Quoting.valid_table_name?(table_name) ?
+          table_name.upcase : table_name
+        if real_name.include?(".")
+          table_owner, table_name = real_name.split(".")
+        else
+          table_owner, table_name = default_owner, real_name
+        end
+        select_values(<<-SQL, "SCHEMA").any?
+          SELECT owner, table_name
+          FROM all_tables
+          WHERE owner = '#{table_owner}'
+          AND table_name = q'[#{table_name}]'
+        SQL
       end
 
-      # Will return true if database object exists (to be able to use also views and synonyms for ActiveRecord models)
       # Needs to consider how to support synonyms in Rails 5.1
       def data_source_exists?(table_name)
         (_owner, table_name, _db_link) = @connection.describe(table_name)
@@ -779,7 +601,7 @@ module ActiveRecord
       end
 
       def views # :nodoc:
-        select_values("SELECT LOWER(view_name) FROM all_views WHERE owner = SYS_CONTEXT('userenv', 'session_user')")
+        select_values("SELECT LOWER(view_name) FROM all_views WHERE owner = SYS_CONTEXT('userenv', 'current_schema')")
       end
 
       def materialized_views #:nodoc:
@@ -794,7 +616,7 @@ module ActiveRecord
         (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+/, ' '))
+          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,
@@ -819,10 +641,10 @@ module ActiveRecord
           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']
+            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'])
+              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}
@@ -835,82 +657,36 @@ module ActiveRecord
                 end
               end
               all_schema_indexes << OracleEnhanced::IndexDefinition.new(
-                row['table_name'],
-                row['index_name'],
-                row['uniqueness'] == "UNIQUE",
+                row["table_name"],
+                row["index_name"],
+                row["uniqueness"] == "UNIQUE",
                 [],
                 nil,
                 nil,
                 nil,
-                row['index_type'] == 'DOMAIN' ? "#{row['ityp_owner']}.#{row['ityp_name']}" : nil,
+                row["index_type"] == "DOMAIN" ? "#{row['ityp_owner']}.#{row['ityp_name']}" : nil,
                 nil,
-                row['parameters'],
+                row["parameters"],
                 statement_parameters,
-                row['tablespace_name'] == default_tablespace_name ? nil : row['tablespace_name'])
-              current_index = row['index_name']
+                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']
+            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
+              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:
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          `ignore_table_columns` will be deprecated in next version of Oracle enhanced adapter
-          since Rails 5 introduces `ignored_columns`. Use `ignored_columns` instead of `ignore_table_columns`.
-        MSG
-        @@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:
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          `set_type_for_columns` has been deprecated. Please use Rails attribute API.
-        MSG
-      end
-
-      def get_type_for_column(table_name, column_name) #:nodoc:
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          `get_type_for_columns` has been deprecated. Please use Rails attribute API.
-        MSG
-      end
-
-      # used just in tests to clear column data type definitions
-      def clear_types_for_columns #:nodoc:
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          `clear_types_for_columns` has been deprecated. Please use Rails attribute API.
-        MSG
+        all_schema_indexes.select { |i| i.table == table_name }
       end
 
       # check if table has primary key trigger with _pkt suffix
@@ -922,12 +698,12 @@ module ActiveRecord
           SELECT trigger_name
           FROM all_triggers#{db_link}
           WHERE owner = '#{owner}'
-            AND trigger_name = '#{trigger_name}'
+            AND trigger_name = q'[#{trigger_name}]'
             AND table_owner = '#{owner}'
-            AND table_name = '#{desc_table_name}'
+            AND table_name = q'[#{desc_table_name}]'
             AND status = 'ENABLED'
         SQL
-        select_value(pkt_sql, 'Primary Key Trigger') ? true : false
+        select_value(pkt_sql, "Primary Key Trigger") ? true : false
       end
 
       ##
@@ -951,17 +727,15 @@ module ActiveRecord
 
       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)
 
         (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 cols.column_name AS name, cols.data_type AS sql_type, 
-                 cols.data_default, cols.nullable, cols.virtual_column, cols.hidden_column, 
+        table_cols = <<-SQL.strip.gsub(/\s+/, " ")
+          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,
@@ -973,7 +747,7 @@ module ActiveRecord
                  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 = '#{desc_table_name}'
+             AND cols.table_name = #{quote(desc_table_name)}
              AND cols.hidden_column = 'NO'
              AND cols.owner = comments.owner
              AND cols.table_name = comments.table_name
@@ -982,46 +756,44 @@ module ActiveRecord
         SQL
 
         # added deletion of ignored columns
-        select_all(table_cols, name).to_a.delete_if do |row|
-          ignored_columns && ignored_columns.include?(row['name'].downcase)
-        end.map do |row|
-          limit, scale = row['limit'], row['scale']
+        select_all(table_cols, name).to_a.map do |row|
+          limit, scale = row["limit"], row["scale"]
           if limit || scale
-            row['sql_type'] += "(#{(limit || 38).to_i}" + ((scale = scale.to_i) > 0 ? ",#{scale})" : ")")
+            row["sql_type"] += "(#{(limit || 38).to_i}" + ((scale = scale.to_i) > 0 ? ",#{scale})" : ")")
           end
 
-          if row['sql_type_owner']
-            row['sql_type'] = row['sql_type_owner'] + '.' + row['sql_type']
+          if row["sql_type_owner"]
+            row["sql_type"] = row["sql_type_owner"] + "." + row["sql_type"]
           end
 
-          is_virtual = row['virtual_column']=='YES'
+          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 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
+            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)
+            row["data_default"] = false if (row["data_default"] == "N" && OracleEnhancedAdapter.emulate_booleans_from_strings)
           end
 
-          type_metadata = fetch_type_metadata(row['sql_type'])
-          new_column(oracle_downcase(row['name']),
-                           row['data_default'],
+          type_metadata = fetch_type_metadata(row["sql_type"])
+          new_column(oracle_downcase(row["name"]),
+                           row["data_default"],
                            type_metadata,
-                           row['nullable'] == 'Y',
+                           row["nullable"] == "Y",
                            table_name,
                            is_virtual,
                            false,
-                           row['column_comment']
+                           row["column_comment"]
                     )
         end
       end
 
-      def new_column(name, default, sql_type_metadata = nil, null = true, table_name = nil, virtual = false, returning_id = false,comment = nil) # :nodoc:
+      def new_column(name, default, sql_type_metadata = nil, null = true, table_name = nil, virtual = false, returning_id = false, comment = nil) # :nodoc:
         OracleEnhancedColumn.new(name, default, sql_type_metadata, null, table_name, virtual, returning_id, comment)
       end
 
@@ -1049,7 +821,7 @@ module ActiveRecord
 
       # 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:
+      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)
@@ -1062,22 +834,22 @@ module ActiveRecord
         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_without_cache(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')
+        seqs = select_values(<<-SQL.strip.gsub(/\s+/, " "), "Sequence")
           select us.sequence_name
           from all_sequences#{db_link} us
           where us.sequence_owner = '#{owner}'
-          and us.sequence_name = '#{desc_table_name}_SEQ'
+          and us.sequence_name = upper(#{quote(default_sequence_name(desc_table_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")
           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}'
+             AND c.table_name = #{quote(desc_table_name)}
              AND c.constraint_type = 'P'
              AND cc.owner = c.owner
              AND cc.constraint_name = c.constraint_name
@@ -1100,14 +872,14 @@ 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
 
       def primary_keys(table_name) # :nodoc:
         (owner, desc_table_name, db_link) = @connection.describe(table_name) unless owner
 
-        pks = select_values(<<-SQL.strip_heredoc, 'Primary Keys')
+        pks = select_values(<<-SQL.strip_heredoc, "Primary Keys")
           SELECT cc.column_name
             FROM all_constraints#{db_link} c, all_cons_columns#{db_link} cc
            WHERE c.owner = '#{owner}'
@@ -1117,7 +889,7 @@ module ActiveRecord
              AND cc.constraint_name = c.constraint_name
              order by cc.position
         SQL
-        pks.map {|pk| oracle_downcase(pk)}
+        pks.map { |pk| oracle_downcase(pk) }
       end
 
       def columns_for_distinct(columns, orders) #:nodoc:
@@ -1126,30 +898,18 @@ module ActiveRecord
         # 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|
+        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(', ')
+        [super, *order_columns].join(", ")
       end
 
       def temporary_table?(table_name) #:nodoc:
-        select_value("SELECT temporary FROM all_tables WHERE table_name = '#{table_name.upcase}' and owner = SYS_CONTEXT('userenv', 'session_user')") == 'Y'
-      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, key) #:nodoc:
-        #TODO: Need to validate if we can remove join_to_update from Oracle enhanced adapter after testing
-        # older version of Oracle 11gR2
-        super
-      end
-
-      def valid_type?(type)
-        !native_database_types[type].nil?
+        select_value("SELECT temporary FROM all_tables WHERE table_name = '#{table_name.upcase}' and owner = SYS_CONTEXT('userenv', 'session_user')") == "Y"
       end
 
       def combine_bind_parameters(
@@ -1161,78 +921,89 @@ module ActiveRecord
         offset: nil
       ) # :nodoc:
         result = from_clause + join_clause + where_clause + having_clause
-        if offset
+        if RUBY_ENGINE == "jruby" && !supports_fetch_first_n_rows_and_offset? && offset && limit
           result << offset
-        end
-        if limit
           result << limit
+          result << offset
+        else
+          if offset
+            result << offset
+          end
+          if limit
+            result << limit
+          end
         end
         result
       end
 
       protected
 
-      def initialize_type_map(m)
-        super
-        # oracle
-        register_class_with_limit m, %r(raw)i,            ActiveRecord::OracleEnhanced::Type::Raw
-        register_class_with_limit m, %r(char)i,           ActiveRecord::OracleEnhanced::Type::String
-        register_class_with_limit m, %r(clob)i,           ActiveRecord::OracleEnhanced::Type::Text
-
-        m.register_type  'NCHAR', ActiveRecord::OracleEnhanced::Type::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
-            ActiveRecord::OracleEnhanced::Type::Integer.new(precision: precision, limit: limit)
-          else
-            Type::Decimal.new(precision: precision, scale: scale)
+        def initialize_type_map(m)
+          super
+          # oracle
+          register_class_with_precision m, %r(ZONE)i,  ActiveRecord::OracleEnhanced::Type::TimestampTz
+          register_class_with_limit m, %r(raw)i,            ActiveRecord::OracleEnhanced::Type::Raw
+          register_class_with_limit m, %r(char)i,           ActiveRecord::OracleEnhanced::Type::String
+          register_class_with_limit m, %r(clob)i,           ActiveRecord::OracleEnhanced::Type::Text
+
+          m.register_type "NCHAR", ActiveRecord::OracleEnhanced::Type::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
+              ActiveRecord::OracleEnhanced::Type::Integer.new(precision: precision, limit: limit)
+            else
+              Type::Decimal.new(precision: precision, scale: scale)
+            end
           end
-        end
 
-        if OracleEnhancedAdapter.emulate_booleans
-          if OracleEnhancedAdapter.emulate_booleans_from_strings
-            m.register_type %r(^VARCHAR2\(1\))i, ActiveRecord::OracleEnhanced::Type::Boolean.new
-          else
-            m.register_type %r(^NUMBER\(1\))i, Type::Boolean.new
+          if OracleEnhancedAdapter.emulate_booleans
+            if OracleEnhancedAdapter.emulate_booleans_from_strings
+              m.register_type %r(^VARCHAR2\(1\))i, ActiveRecord::OracleEnhanced::Type::Boolean.new
+            else
+              m.register_type %r(^NUMBER\(1\))i, Type::Boolean.new
+            end
           end
         end
-      end
 
-      def extract_limit(sql_type) #:nodoc:
-        case sql_type
-        when /^bigint/i
-          19
-        when /\((.*)\)/
-          $1.to_i
+        def extract_limit(sql_type) #:nodoc:
+          case sql_type
+          when /^bigint/i
+            19
+          when /\((.*)\)/
+            $1.to_i
+          end
         end
-      end
 
-      def translate_exception(exception, message) #:nodoc:
-        case @connection.error_code(exception)
-        when 1
-          RecordNotUnique.new(message)
-        when 2291
-          InvalidForeignKey.new(message)
-        when 12899
-          ValueTooLong.new(message)
-        else
-          super
+        def translate_exception(exception, message) #:nodoc:
+          case @connection.error_code(exception)
+          when 1
+            RecordNotUnique.new(message)
+          when 942, 955, 1418
+            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
 
       private
 
-      def oracle_downcase(column_name)
-        @connection.oracle_downcase(column_name)
-      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
+        def compress_lines(string, join_with = "\n")
+          string.split($/).map { |line| line.strip }.join(join_with)
+        end
 
       public
       # DBMS_OUTPUT =============================================
@@ -1262,82 +1033,88 @@ module ActiveRecord
       end
 
       protected
-      def log(sql, name = "SQL", binds = [], statement_name = nil) #:nodoc:
-        super
-      ensure
-        log_dbms_output if dbms_output_enabled?
-      end
+        def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
+          super
+        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 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
+          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 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
+          end
         end
-      end
-
     end
   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/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'
-
-# Load additional methods for composite_primary_keys support
-require 'active_record/connection_adapters/oracle_enhanced/cpk'
+require "active_record/connection_adapters/oracle_enhanced/context_index"
 
 # 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'
+require "active_record/oracle_enhanced/type/raw"
 
 # Add OracleEnhanced::Type::Integer
-require 'active_record/oracle_enhanced/type/integer'
+require "active_record/oracle_enhanced/type/integer"
 
 # Add OracleEnhanced::Type::String
-require 'active_record/oracle_enhanced/type/string'
+require "active_record/oracle_enhanced/type/string"
 
 # Add OracleEnhanced::Type::NationalCharacterString
-require 'active_record/oracle_enhanced/type/national_character_string'
+require "active_record/oracle_enhanced/type/national_character_string"
 
 # Add OracleEnhanced::Type::Text
-require 'active_record/oracle_enhanced/type/text'
+require "active_record/oracle_enhanced/type/text"
 
 # Add OracleEnhanced::Type::Boolean
-require 'active_record/oracle_enhanced/type/boolean'
+require "active_record/oracle_enhanced/type/boolean"
+
+# To use :boolean type for Attribute API, each type needs registered explicitly.
+ActiveRecord::Type.register(:boolean, ActiveRecord::OracleEnhanced::Type::Boolean, adapter: :oracleenhanced)
+
+# Add JSON attribute support
+require "active_record/oracle_enhanced/type/json"
+ActiveRecord::Type.register(:json, ActiveRecord::OracleEnhanced::Type::Json, adapter: :oracleenhanced)
+
+# Add Type:TimestampTz
+require "active_record/oracle_enhanced/type/timestamptz"