activerecord-oracle_enhanced-adapter 1.8.2 → 5.2.0.beta1

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module OracleEnhanced
@@ -10,12 +12,18 @@ module ActiveRecord
             ora_value = bind_type.new(@connection.raw_oci_connection, lob_value)
             ora_value.size = 0 if value == ""
             ora_value
-          when ActiveRecord::OracleEnhanced::Type::Text::Data
+          when Type::OracleEnhanced::Text::Data
             lob_value = value.to_s == "" ? " " : value.to_s
             bind_type = OCI8::CLOB
             ora_value = bind_type.new(@connection.raw_oci_connection, lob_value)
             ora_value.size = 0 if value.to_s == ""
             ora_value
+          when Type::OracleEnhanced::NationalCharacterText::Data
+            lob_value = value.to_s == "" ? " " : value.to_s
+            bind_type = OCI8::NCLOB
+            ora_value = bind_type.new(@connection.raw_oci_connection, lob_value)
+            ora_value.size = 0 if value.to_s == ""
+            ora_value
           else
             super
           end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support"
 
 module ActiveRecord #:nodoc:
@@ -144,7 +146,7 @@ module ActiveRecord #:nodoc:
 
               timestamp_attributes_for_update_in_model.each do |column|
                 column = column.to_s
-                next if attribute_changed?(column)
+                next if will_save_change_to_attribute?(column)
                 write_attribute(column, current_time)
               end
             end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module OracleEnhanced
@@ -62,8 +64,8 @@ module ActiveRecord
         # 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}/
+        NONQUOTED_OBJECT_NAME   = /[[:alpha:]][\w$#]{0,29}/
+        NONQUOTED_DATABASE_LINK = /[[:alpha:]][\w$#\.@]{0,127}/
         VALID_TABLE_NAME = /\A(?:#{NONQUOTED_OBJECT_NAME}\.)?#{NONQUOTED_OBJECT_NAME}(?:@#{NONQUOTED_DATABASE_LINK})?\Z/
 
         # unescaped table name should start with letter and
@@ -71,8 +73,13 @@ module ActiveRecord
         # 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
+          object_name = name.to_s
+          !!(object_name =~ VALID_TABLE_NAME && !mixed_case?(object_name))
+        end
+
+        def self.mixed_case?(name)
+          object_name = name.include?(".") ? name.split(".").second : name
+          !!(object_name =~ /[A-Z]/ && object_name =~ /[a-z]/)
         end
 
         def quote_table_name(name) #:nodoc:
@@ -86,12 +93,14 @@ module ActiveRecord
 
         def _quote(value) #:nodoc:
           case value
-          when ActiveRecord::OracleEnhanced::Type::NationalCharacterString::Data then
-            "N" << "'#{quote_string(value.to_s)}'"
+          when Type::OracleEnhanced::NationalCharacterString::Data then
+            "N".dup << "'#{quote_string(value.to_s)}'"
           when ActiveModel::Type::Binary::Data then
             "empty_blob()"
-          when ActiveRecord::OracleEnhanced::Type::Text::Data then
+          when Type::OracleEnhanced::Text::Data then
             "empty_clob()"
+          when Type::OracleEnhanced::NationalCharacterText::Data then
+            "empty_nclob()"
           else
             super
           end
@@ -119,19 +128,26 @@ module ActiveRecord
 
         def _type_cast(value)
           case value
-          when ActiveRecord::OracleEnhanced::Type::TimestampTz::Data
+          when Type::OracleEnhanced::TimestampTz::Data, Type::OracleEnhanced::TimestampLtz::Data
             if value.acts_like?(:time)
               zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
               value.respond_to?(zone_conversion_method) ? value.send(zone_conversion_method) : value
             else
               value
             end
-          when ActiveRecord::OracleEnhanced::Type::NationalCharacterString::Data
+          when Type::OracleEnhanced::NationalCharacterString::Data
             value.to_s
           else
             super
           end
         end
+
+        private
+
+          def oracle_downcase(column_name)
+            return nil if column_name.nil?
+            column_name =~ /[a-z]/ ? column_name : column_name.downcase
+          end
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module OracleEnhanced
@@ -5,7 +7,7 @@ module ActiveRecord
         private
 
           def visit_ColumnDefinition(o)
-            if [:blob, :clob].include?(sql_type = type_to_sql(o.type,  o.options).downcase.to_sym)
+            if [:blob, :clob, :nclob].include?(sql_type = type_to_sql(o.type,  o.options).downcase.to_sym)
               if (tablespace = default_tablespace_for(sql_type))
                 @lob_tablespaces ||= {}
                 @lob_tablespaces[o.name] = tablespace
@@ -15,7 +17,7 @@ module ActiveRecord
           end
 
           def visit_TableDefinition(o)
-            create_sql = "CREATE#{' GLOBAL TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} "
+            create_sql = "CREATE#{' GLOBAL TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} ".dup
             statements = o.columns.map { |c| accept c }
             statements << accept(o.primary_keys) if o.primary_keys
 
@@ -35,22 +37,23 @@ module ActiveRecord
               end
             end
             add_table_options!(create_sql, table_options(o))
-            create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
+            create_sql << " AS #{to_sql(o.as)}" if o.as
             create_sql
           end
 
           def default_tablespace_for(type)
-            (ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_tablespaces[type] ||
-             ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_tablespaces[native_database_types[type][:name]]) rescue nil
+            OracleEnhancedAdapter.default_tablespaces[type]
           end
 
           def add_column_options!(sql, options)
             type = options[:type] || ((column = options[:column]) && column.type)
             type = type && type.to_sym
-            # handle case of defaults for CLOB columns, which would otherwise get "quoted" incorrectly
+            # handle case of defaults for CLOB/NCLOB columns, which would otherwise get "quoted" incorrectly
             if options_include_default?(options)
               if type == :text
                 sql << " DEFAULT #{@conn.quote(options[:default])}"
+              elsif type == :ntext
+                sql << " DEFAULT #{@conn.quote(options[:default])}"
               else
                 sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}"
               end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module OracleEnhanced
@@ -8,7 +10,10 @@ module ActiveRecord
         end
 
         [
-          :raw
+          :raw,
+          :timestamptz,
+          :timestampltz,
+          :ntext
         ].each do |column_type|
           module_eval <<-CODE, __FILE__, __LINE__ + 1
             def #{column_type}(*args, **options)
@@ -36,16 +41,16 @@ module ActiveRecord
       class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition
         attr_accessor :parameters, :statement_parameters, :tablespace
 
-        def initialize(table, name, unique, columns, lengths, orders, where, type, using, parameters, statement_parameters, tablespace)
+        def initialize(table, name, unique, columns, orders, type, parameters, statement_parameters, tablespace)
           @parameters = parameters
           @statement_parameters = statement_parameters
           @tablespace = tablespace
-          super(table, name, unique, columns, lengths, orders, where, type, using)
+          super(table, name, unique, columns, orders: orders, type: type)
         end
       end
 
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
-        include ActiveRecord::ConnectionAdapters::OracleEnhanced::ColumnMethods
+        include OracleEnhanced::ColumnMethods
 
         attr_accessor :tablespace, :organization
         def initialize(name, temporary = false, options = nil, as = nil, tablespace = nil, organization = nil, comment: nil)
@@ -67,7 +72,7 @@ module ActiveRecord
       end
 
       class Table < ActiveRecord::ConnectionAdapters::Table
-        include ActiveRecord::ConnectionAdapters::OracleEnhanced::ColumnMethods
+        include OracleEnhanced::ColumnMethods
       end
     end
   end

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

@@ -1,18 +1,17 @@
+# frozen_string_literal: true
+
 module ActiveRecord #:nodoc:
   module ConnectionAdapters #:nodoc:
     module OracleEnhanced #:nodoc:
-      module SchemaDumper #:nodoc:
+      class SchemaDumper < ConnectionAdapters::SchemaDumper #:nodoc:
         private
 
           def tables(stream)
-            return super unless @connection.respond_to?(:materialized_views)
             # do not include materialized views in schema dump - they should be created separately after schema creation
             sorted_tables = (@connection.tables - @connection.materialized_views).sort
             sorted_tables.each do |tbl|
               # add table prefix or suffix for schema_migrations
               next if ignored? tbl
-              # change table name inspect method
-              tbl.extend TableInspect
               table(tbl, stream)
               # add primary key trigger if table has it
               primary_key_trigger(tbl, stream)
@@ -29,7 +28,7 @@ module ActiveRecord #:nodoc:
           end
 
           def primary_key_trigger(table_name, stream)
-            if @connection.respond_to?(:has_primary_key_trigger?) && @connection.has_primary_key_trigger?(table_name)
+            if @connection.has_primary_key_trigger?(table_name)
               pk, _pk_seq = @connection.pk_and_sequence_for(table_name)
               stream.print "  add_primary_key_trigger #{table_name.inspect}"
               stream.print ", primary_key: \"#{pk}\"" if pk != "id"
@@ -38,21 +37,19 @@ module ActiveRecord #:nodoc:
           end
 
           def synonyms(stream)
-            if @connection.respond_to?(:synonyms)
-              syns = @connection.synonyms
-              syns.each do |syn|
-                next if ignored? syn.name
-                table_name = syn.table_name
-                table_name = "#{syn.table_owner}.#{table_name}" if syn.table_owner
-                table_name = "#{table_name}@#{syn.db_link}" if syn.db_link
-                stream.print "  add_synonym #{syn.name.inspect}, #{table_name.inspect}, force: true"
-                stream.puts
-              end
-              stream.puts unless syns.empty?
+            syns = @connection.synonyms
+            syns.each do |syn|
+              next if ignored? syn.name
+              table_name = syn.table_name
+              table_name = "#{syn.table_owner}.#{table_name}" if syn.table_owner
+              table_name = "#{table_name}@#{syn.db_link}" if syn.db_link
+              stream.print "  add_synonym #{syn.name.inspect}, #{table_name.inspect}, force: true"
+              stream.puts
             end
+            stream.puts unless syns.empty?
           end
 
-          def indexes(table, stream)
+          def _indexes(table, stream)
             if (indexes = @connection.indexes(table)).any?
               add_index_statements = indexes.map do |index|
                 case index.type
@@ -61,10 +58,10 @@ module ActiveRecord #:nodoc:
                   statement_parts = []
                 when "CTXSYS.CONTEXT"
                   if index.statement_parameters
-                    statement_parts = [ ("add_context_index " + table.inspect) ]
+                    statement_parts = [ ("add_context_index " + remove_prefix_and_suffix(table).inspect) ]
                     statement_parts << index.statement_parameters
                   else
-                    statement_parts = [ ("add_context_index " + table.inspect) ]
+                    statement_parts = [ ("add_context_index " + remove_prefix_and_suffix(table).inspect) ]
                     statement_parts << index.columns.inspect
                     statement_parts << ("name: " + index.name.inspect)
                   end
@@ -92,14 +89,12 @@ module ActiveRecord #:nodoc:
           end
 
           def index_parts(index)
-            return super unless @connection.respond_to?(:temporary_table?)
             index_parts = super
             index_parts << "tablespace: #{index.tablespace.inspect}" if index.tablespace
             index_parts
           end
 
           def table(table, stream)
-            return super unless @connection.respond_to?(:temporary_table?)
             columns = @connection.columns(table)
             begin
               tbl = StringIO.new
@@ -112,7 +107,7 @@ module ActiveRecord #:nodoc:
                 pk = @connection.primary_key(table)
               end
 
-              tbl.print "  create_table #{table.inspect}"
+              tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
 
               # addition to make temporary option work
               tbl.print ", temporary: true" if @connection.temporary_table?(table)
@@ -121,7 +116,7 @@ module ActiveRecord #:nodoc:
               when String
                 tbl.print ", primary_key: #{pk.inspect}" unless pk == "id"
                 pkcol = columns.detect { |c| c.name == pk }
-                pkcolspec = @connection.column_spec_for_primary_key(pkcol)
+                pkcolspec = column_spec_for_primary_key(pkcol)
                 if pkcolspec.present?
                   tbl.print ", #{format_colspec(pkcolspec)}"
                 end
@@ -131,20 +126,18 @@ module ActiveRecord #:nodoc:
                 tbl.print ", id: false"
               end
 
-              tbl.print ", force: :cascade"
-
-              table_comments = @connection.table_comment(table)
-              unless table_comments.blank?
-                tbl.print ", comment: #{table_comments.inspect}"
+              table_options = @connection.table_options(table)
+              if table_options.present?
+                tbl.print ", #{format_options(table_options)}"
               end
 
-              tbl.puts " do |t|"
+              tbl.puts ", force: :cascade do |t|"
 
               # then dump all non-primary key columns
               columns.each do |column|
                 raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
                 next if column.name == pk
-                type, colspec = @connection.column_spec(column)
+                type, colspec = column_spec(column)
                 tbl.print "    t.#{type} #{column.name.inspect}"
                 tbl.print ", #{format_colspec(colspec)}" if colspec.present?
                 tbl.puts
@@ -155,7 +148,7 @@ module ActiveRecord #:nodoc:
               tbl.puts "  end"
               tbl.puts
 
-              indexes(table, tbl)
+              _indexes(table, tbl)
 
               tbl.rewind
               stream.print tbl.read
@@ -164,34 +157,38 @@ module ActiveRecord #:nodoc:
               stream.puts "#   #{e.message}"
               stream.puts
             end
+          end
+
+          def prepare_column_options(column)
+            spec = super
+
+            if @connection.supports_virtual_columns? && column.virtual?
+              spec[:as] = extract_expression_for_virtual_column(column)
+              spec = { type: schema_type(column).inspect }.merge!(spec) unless column.type == :decimal
+            end
 
-            stream
+            spec
           end
 
-          def remove_prefix_and_suffix(table)
-            table.gsub(/^(#{ActiveRecord::Base.table_name_prefix})(.+)(#{ActiveRecord::Base.table_name_suffix})$/,  "\\2")
+          def default_primary_key?(column)
+            schema_type(column) == :integer
           end
 
-          # remove table name prefix and suffix when doing #inspect (which is used in tables method)
-          module TableInspect #:nodoc:
-            def inspect
-              remove_prefix_and_suffix(self)
-            end
+          def extract_expression_for_virtual_column(column)
+            column_name = column.name
+            table_name = column.table_name
+            @connection.select_value(<<-SQL.strip.gsub(/\s+/, " "), "Table comment", [bind_string("table_name", table_name.upcase), bind_string("column_name", column_name.upcase)]).inspect
+              select data_default from all_tab_columns
+              where owner = SYS_CONTEXT('userenv', 'session_user')
+              and table_name = :table_name
+              and column_name = :column_name
+            SQL
+          end
 
-            private
-              def remove_prefix_and_suffix(table_name)
-                if table_name =~ /\A#{ActiveRecord::Base.table_name_prefix.to_s.gsub('$', '\$')}(.*)#{ActiveRecord::Base.table_name_suffix.to_s.gsub('$', '\$')}\Z/
-                  "\"#{$1}\""
-                else
-                  "\"#{table_name}\""
-                end
-              end
+          def bind_string(name, value)
+            ActiveRecord::Relation::QueryAttribute.new(name, value, Type::OracleEnhanced::String.new)
           end
       end
     end
   end
-
-  class SchemaDumper #:nodoc:
-    prepend ConnectionAdapters::OracleEnhanced::SchemaDumper
-  end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "digest/sha1"
 
 module ActiveRecord
@@ -8,6 +10,148 @@ module ActiveRecord
         #
         # see: abstract/schema_statements.rb
 
+        def tables #:nodoc:
+          select_values(<<-SQL.strip.gsub(/\s+/, " "), "tables")
+          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
+          super | synonyms.map(&:name)
+        end
+
+        def table_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 = 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.strip.gsub(/\s+/, " "), "table exists", [bind_string("owner", table_owner), bind_string("table_name", table_name)]).any?
+          SELECT owner, table_name
+          FROM all_tables
+          WHERE owner = :owner
+          AND table_name = :table_name
+        SQL
+        end
+
+        def data_source_exists?(table_name)
+          (_owner, table_name, _db_link) = @connection.describe(table_name)
+          true
+        rescue
+          false
+        end
+
+        def views # :nodoc:
+          select_values(<<-SQL.strip.gsub(/\s+/, " "), "views")
+            SELECT LOWER(view_name) FROM all_views WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
+          SQL
+        end
+
+        def materialized_views #:nodoc:
+          select_values(<<-SQL.strip.gsub(/\s+/, " "), "materialized views")
+            SELECT LOWER(mview_name) FROM all_mviews WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
+          SQL
+        end
+
+        # get synonyms for schema dump
+        def synonyms
+          result = select_all(<<-SQL.strip.gsub(/\s+/, " "), "synonyms")
+          SELECT synonym_name, table_owner, table_name, db_link
+          FROM all_synonyms where owner = SYS_CONTEXT('userenv', 'session_user')
+        SQL
+
+          result.collect do |row|
+             OracleEnhanced::SynonymDefinition.new(oracle_downcase(row["synonym_name"]),
+             oracle_downcase(row["table_owner"]), oracle_downcase(row["table_name"]), oracle_downcase(row["db_link"]))
+           end
+        end
+
+        def indexes(table_name) #:nodoc:
+          (owner, table_name, db_link) = @connection.describe(table_name)
+          default_tablespace_name = default_tablespace
+
+          result = select_all(<<-SQL.strip.gsub(/\s+/, " "), "indexes", [bind_string("owner", owner), bind_string("owner", owner)])
+            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
+          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.strip.gsub(/\s+/, " "), "procedure", [bind_string("owner", owner), bind_string("procedure_name", procedure_name.upcase)]).join
+                  SELECT text
+                  FROM all_source#{db_link}
+                  WHERE owner = :owner
+                    AND name = :procedure_name
+                  ORDER BY line
+                SQL
+                if source =~ /-- add_context_index_parameters (.+)\n/
+                  statement_parameters = $1
+                end
+              end
+              all_schema_indexes << OracleEnhanced::IndexDefinition.new(
+                row["table_name"],
+                row["index_name"],
+                row["uniqueness"] == "UNIQUE",
+                [],
+                nil,
+                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
+
+          # 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
+
         # Additional options for +create_table+ method in migration files.
         #
         # You can specify individual starting value in table creation migration file, e.g.:
@@ -88,10 +232,6 @@ module ActiveRecord
           rebuild_primary_key_index_to_default_tablespace(table_name, options)
         end
 
-        def create_table_definition(*args)
-          ActiveRecord::ConnectionAdapters::OracleEnhanced::TableDefinition.new(*args)
-        end
-
         def rename_table(table_name, new_name) #:nodoc:
           if new_name.to_s.length > table_name_length
             raise ArgumentError, "New table name '#{new_name}' is too long; the limit is #{table_name_length} characters"
@@ -108,16 +248,13 @@ module ActiveRecord
           execute "DROP SEQUENCE #{quote_table_name(seq_name)}" rescue nil
         rescue ActiveRecord::StatementInvalid => e
           raise e unless options[:if_exists]
-        ensure
-          clear_table_columns_cache(table_name)
-          self.all_schema_indexes = nil
         end
 
         def insert_versions_sql(versions) # :nodoc:
           sm_table = quote_table_name(ActiveRecord::SchemaMigration.table_name)
 
           if supports_multi_insert?
-            versions.inject("INSERT ALL\n") { |sql, version|
+            versions.inject("INSERT ALL\n".dup) { |sql, version|
               sql << "INTO #{sm_table} (version) VALUES (#{quote(version)})\n"
             } << "SELECT * FROM DUAL\n"
           else
@@ -141,8 +278,6 @@ module ActiveRecord
               execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{quote_column_name(index_name)} #{index_type} (#{quoted_column_names})"
             end
           end
-        ensure
-          self.all_schema_indexes = nil
         end
 
         def add_index_options(table_name, column_name, comment: nil, **options) #:nodoc:
@@ -176,8 +311,6 @@ module ActiveRecord
           #TODO: It should execute only when index_type == "UNIQUE"
           execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{quote_column_name(index_name)}" rescue nil
           execute "DROP INDEX #{quote_column_name(index_name)}"
-        ensure
-          self.all_schema_indexes = nil
         end
 
         # returned shortened index name if default is too large
@@ -209,14 +342,9 @@ module ActiveRecord
         # as there's no way to determine the correct answer in that case.
         #
         # Will always query database and not index cache.
-        def index_name_exists?(table_name, index_name, default = nil)
-          unless default.nil?
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Passing default to #index_name_exists? is deprecated without replacement.
-            MSG
-          end
+        def index_name_exists?(table_name, index_name)
           (owner, table_name, db_link) = @connection.describe(table_name)
-          result = select_value(<<-SQL)
+          result = select_value(<<-SQL.strip.gsub(/\s+/, " "), "index name exists")
             SELECT 1 FROM all_indexes#{db_link} i
             WHERE i.owner = '#{owner}'
                AND i.table_owner = '#{owner}'
@@ -229,12 +357,36 @@ module ActiveRecord
         def rename_index(table_name, old_name, new_name) #:nodoc:
           validate_index_length!(table_name, new_name)
           execute "ALTER INDEX #{quote_column_name(old_name)} rename to #{quote_column_name(new_name)}"
-        ensure
-          self.all_schema_indexes = nil
+        end
+
+        # Add synonym to existing table or view or sequence. Can be used to create local synonym to
+        # remote table in other schema or in other database
+        # Examples:
+        #
+        #   add_synonym :posts, "blog.posts"
+        #   add_synonym :posts_seq, "blog.posts_seq"
+        #   add_synonym :employees, "hr.employees@dblink", :force => true
+        #
+        def add_synonym(name, table_name, options = {})
+          sql = "CREATE".dup
+          if options[:force] == true
+            sql << " OR REPLACE"
+          end
+          sql << " SYNONYM #{quote_table_name(name)} FOR #{quote_table_name(table_name)}"
+          execute sql
+        end
+
+        # Remove existing synonym to table or view or sequence
+        # Example:
+        #
+        #   remove_synonym :posts, "blog.posts"
+        #
+        def remove_synonym(name)
+          execute "DROP SYNONYM #{quote_table_name(name)}"
         end
 
         def add_reference(table_name, *args)
-          ActiveRecord::ConnectionAdapters::OracleEnhanced::ReferenceDefinition.new(*args).add_to(update_table_definition(table_name, self))
+          OracleEnhanced::ReferenceDefinition.new(*args).add_to(update_table_definition(table_name, self))
         end
 
         def add_column(table_name, column_name, type, options = {}) #:nodoc:
@@ -246,8 +398,6 @@ module ActiveRecord
           execute add_column_sql
           create_sequence_and_trigger(table_name, options) if type && type.to_sym == :primary_key
           change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
-        ensure
-          clear_table_columns_cache(table_name)
         end
 
         def aliased_types(name, fallback)
@@ -257,8 +407,6 @@ module ActiveRecord
         def change_column_default(table_name, column_name, default_or_changes) #:nodoc:
           default = extract_new_default_value(default_or_changes)
           execute "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{quote_column_name(column_name)} DEFAULT #{quote(default)}"
-        ensure
-          clear_table_columns_cache(table_name)
         end
 
         def change_column_null(table_name, column_name, null, default = nil) #:nodoc:
@@ -291,28 +439,24 @@ module ActiveRecord
           execute(change_column_sql)
 
           change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
-        ensure
-          clear_table_columns_cache(table_name)
         end
 
         def rename_column(table_name, column_name, new_column_name) #:nodoc:
           execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} to #{quote_column_name(new_column_name)}"
-          self.all_schema_indexes = nil
           rename_column_indexes(table_name, column_name, new_column_name)
-        ensure
-          clear_table_columns_cache(table_name)
         end
 
         def remove_column(table_name, column_name, type = nil, options = {}) #:nodoc:
           execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)} CASCADE CONSTRAINTS"
-        ensure
-          clear_table_columns_cache(table_name)
-          self.all_schema_indexes = nil
         end
 
         def change_table_comment(table_name, comment)
           clear_cache!
-          execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS #{quote(comment)}"
+          if comment.nil?
+            execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS ''"
+          else
+            execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS #{quote(comment)}"
+          end
         end
 
         def change_column_comment(table_name, column_name, comment) #:nodoc:
@@ -322,34 +466,40 @@ module ActiveRecord
 
         def table_comment(table_name) #:nodoc:
           (owner, table_name, db_link) = @connection.describe(table_name)
-          select_value <<-SQL
+          select_value(<<-SQL.strip.gsub(/\s+/, " "), "Table comment", [bind_string("owner", owner), bind_string("table_name", table_name)])
             SELECT comments FROM all_tab_comments#{db_link}
-            WHERE owner = '#{owner}'
-              AND table_name = '#{table_name}'
+            WHERE owner = :owner
+              AND table_name = :table_name
           SQL
         end
 
+        def table_options(table_name) # :nodoc:
+          if comment = table_comment(table_name)
+            { comment: comment }
+          end
+        end
+
         def column_comment(table_name, column_name) #:nodoc:
           # TODO: it  does not exist in Abstract adapter
           (owner, table_name, db_link) = @connection.describe(table_name)
-          select_value <<-SQL
+          select_value(<<-SQL.strip.gsub(/\s+/, " "), "Column comment", [bind_string("owner", owner), bind_string("table_name", table_name), bind_string("column_name", column_name.upcase)])
             SELECT comments FROM all_col_comments#{db_link}
-            WHERE owner = '#{owner}'
-              AND table_name = '#{table_name}'
-              AND column_name = '#{column_name.upcase}'
+            WHERE owner = :owner
+              AND table_name = :table_name
+              AND column_name = :column_name
           SQL
         end
 
         # Maps logical Rails types to Oracle-specific data types.
         def type_to_sql(type, limit: nil, precision: nil, scale: nil, **) #:nodoc:
-          # Ignore options for :text and :binary columns
-          return super(type) if ["text", "binary"].include?(type.to_s)
+          # Ignore options for :text, :ntext and :binary columns
+          return super(type) if ["text", "ntext", "binary"].include?(type.to_s)
 
           super
         end
 
         def tablespace(table_name)
-          select_value <<-SQL
+          select_value(<<-SQL.strip.gsub(/\s+/, " "), "tablespace")
             SELECT tablespace_name
             FROM all_tables
             WHERE table_name='#{table_name.to_s.upcase}'
@@ -361,7 +511,7 @@ module ActiveRecord
         def foreign_keys(table_name) #:nodoc:
           (owner, desc_table_name, db_link) = @connection.describe(table_name)
 
-          fk_info = select_all(<<-SQL, "Foreign Keys")
+          fk_info = select_all(<<-SQL.strip.gsub(/\s+/, " "), "Foreign Keys", [bind_string("owner", owner), bind_string("desc_table_name", desc_table_name)])
             SELECT r.table_name to_table
                   ,rc.column_name references_column
                   ,cc.column_name
@@ -369,8 +519,8 @@ module ActiveRecord
                   ,c.delete_rule
               FROM all_constraints#{db_link} c, all_cons_columns#{db_link} cc,
                    all_constraints#{db_link} r, all_cons_columns#{db_link} rc
-             WHERE c.owner = '#{owner}'
-               AND c.table_name = q'[#{desc_table_name}]'
+             WHERE c.owner = :owner
+               AND c.table_name = :desc_table_name
                AND c.constraint_type = 'R'
                AND cc.owner = c.owner
                AND cc.constraint_name = c.constraint_name
@@ -403,14 +553,13 @@ module ActiveRecord
         # REFERENTIAL INTEGRITY ====================================
 
         def disable_referential_integrity(&block) #:nodoc:
-          sql_constraints = <<-SQL
+          old_constraints = select_all(<<-SQL.strip.gsub(/\s+/, " "), "Foreign Keys to disable and enable")
           SELECT constraint_name, owner, table_name
             FROM all_constraints
             WHERE constraint_type = 'R'
             AND status = 'ENABLED'
             AND owner = SYS_CONTEXT('userenv', 'session_user')
           SQL
-          old_constraints = select_all(sql_constraints)
           begin
             old_constraints.each do |constraint|
               execute "ALTER TABLE #{quote_table_name(constraint["table_name"])} DISABLE CONSTRAINT #{quote_table_name(constraint["constraint_name"])}"
@@ -424,19 +573,71 @@ module ActiveRecord
         end
 
         def create_alter_table(name)
-          ActiveRecord::ConnectionAdapters::OracleEnhanced::AlterTable.new create_table_definition(name, false, {})
+          OracleEnhanced::AlterTable.new create_table_definition(name, false, {})
         end
 
         def update_table_definition(table_name, base)
-          ActiveRecord::ConnectionAdapters::OracleEnhanced::Table.new(table_name, base)
+          OracleEnhanced::Table.new(table_name, base)
+        end
+
+        def create_schema_dumper(options)
+          OracleEnhanced::SchemaDumper.create(self, options)
         end
 
         private
 
+          def schema_creation
+            OracleEnhanced::SchemaCreation.new self
+          end
+
+          def create_table_definition(*args)
+            OracleEnhanced::TableDefinition.new(*args)
+          end
+
+          def new_column_from_field(table_name, field)
+            limit, scale = field["limit"], field["scale"]
+            if limit || scale
+              field["sql_type"] += "(#{(limit || 38).to_i}" + ((scale = scale.to_i) > 0 ? ",#{scale})" : ")")
+            end
+
+            if field["sql_type_owner"]
+              field["sql_type"] = field["sql_type_owner"] + "." + field["sql_type"]
+            end
+
+            is_virtual = field["virtual_column"] == "YES"
+
+            # clean up odd default spacing from Oracle
+            if field["data_default"] && !is_virtual
+              field["data_default"].sub!(/^(.*?)\s*$/, '\1')
+
+              # If a default contains a newline these cleanup regexes need to
+              # match newlines.
+              field["data_default"].sub!(/^'(.*)'$/m, '\1')
+              field["data_default"] = nil if field["data_default"] =~ /^(null|empty_[bc]lob\(\))$/i
+              # TODO: Needs better fix to fallback "N" to false
+              field["data_default"] = false if (field["data_default"] == "N" && OracleEnhancedAdapter.emulate_booleans_from_strings)
+            end
+
+            type_metadata = fetch_type_metadata(field["sql_type"], is_virtual)
+            default_value = extract_value_from_default(field["data_default"])
+            default_value = nil if is_virtual
+            OracleEnhanced::Column.new(oracle_downcase(field["name"]),
+                             default_value,
+                             type_metadata,
+                             field["nullable"] == "Y",
+                             table_name,
+                             field["column_comment"]
+                      )
+          end
+
+          def fetch_type_metadata(sql_type, virtual = nil)
+            OracleEnhanced::TypeMetadata.new(super(sql_type), virtual: virtual)
+          end
+
           def tablespace_for(obj_type, tablespace_option, table_name = nil, column_name = nil)
-            tablespace_sql = ""
+            tablespace_sql = "".dup
             if tablespace = (tablespace_option || default_tablespace_for(obj_type))
-              if [:blob, :clob].include?(obj_type.to_sym)
+              if [:blob, :clob, :nclob].include?(obj_type.to_sym)
                 tablespace_sql << " LOB (#{quote_column_name(column_name)}) STORE AS #{column_name.to_s[0..10]}_#{table_name.to_s[0..14]}_ls (TABLESPACE #{tablespace})"
               else
                 tablespace_sql << " TABLESPACE #{tablespace}"
@@ -468,7 +669,7 @@ module ActiveRecord
             seq_name = options[:sequence_name] || default_sequence_name(table_name)
             trigger_name = options[:trigger_name] || default_trigger_name(table_name)
             primary_key = options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)
-            execute compress_lines(<<-SQL)
+            execute <<-SQL
             CREATE OR REPLACE TRIGGER #{quote_table_name(trigger_name)}
             BEFORE INSERT ON #{quote_table_name(table_name)} FOR EACH ROW
             BEGIN
@@ -491,11 +692,12 @@ module ActiveRecord
 
             return unless tablespace
 
-            index_name = Base.connection.select_value(
-              "SELECT index_name FROM all_constraints
-                  WHERE table_name = #{quote(table_name.upcase)}
+            index_name = select_value(<<-SQL.strip.gsub(/\s+/, " "), "Index name for primary key",  [bind_string("table_name", table_name.upcase)])
+              SELECT index_name FROM all_constraints
+                  WHERE table_name = :table_name
                   AND constraint_type = 'P'
-                  AND owner = SYS_CONTEXT('userenv', 'current_schema')")
+                  AND owner = SYS_CONTEXT('userenv', 'current_schema')
+            SQL
 
             return unless index_name