activerecord-oracle_enhanced-adapter 6.0.4 → 6.1.1

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

@@ -11,8 +11,9 @@ module ActiveRecord
         # see: abstract/schema_statements.rb
 
         def tables #:nodoc:
-          select_values(<<~SQL.squish, "tables")
-            SELECT DECODE(table_name, UPPER(table_name), LOWER(table_name), table_name)
+          select_values(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */
+            DECODE(table_name, UPPER(table_name), LOWER(table_name), table_name)
             FROM all_tables
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
             AND secondary = 'N'
@@ -43,8 +44,8 @@ module ActiveRecord
             table_owner, table_name = default_owner, real_name
           end
 
-          select_values(<<~SQL.squish, "table exists", [bind_string("owner", table_owner), bind_string("table_name", table_name)]).any?
-            SELECT owner, table_name
+          select_values(<<~SQL.squish, "SCHEMA", [bind_string("owner", table_owner), bind_string("table_name", table_name)]).any?
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ owner, table_name
             FROM all_tables
             WHERE owner = :owner
             AND table_name = :table_name
@@ -59,20 +60,22 @@ module ActiveRecord
         end
 
         def views # :nodoc:
-          select_values(<<~SQL.squish, "views")
-            SELECT LOWER(view_name) FROM all_views WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
+          select_values(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */
+            LOWER(view_name) FROM all_views WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
         end
 
         def materialized_views #:nodoc:
-          select_values(<<~SQL.squish, "materialized views")
-            SELECT LOWER(mview_name) FROM all_mviews WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
+          select_values(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */
+            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.squish, "synonyms")
+          result = select_all(<<~SQL.squish, "SCHEMA")
             SELECT synonym_name, table_owner, table_name
             FROM all_synonyms where owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
@@ -87,8 +90,8 @@ module ActiveRecord
           (_owner, table_name) = @connection.describe(table_name)
           default_tablespace_name = default_tablespace
 
-          result = select_all(<<~SQL.squish, "indexes", [bind_string("table_name", table_name)])
-            SELECT LOWER(i.table_name) AS table_name, LOWER(i.index_name) AS index_name, i.uniqueness,
+          result = select_all(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name)])
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ 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,
@@ -117,8 +120,8 @@ module ActiveRecord
               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.squish, "procedure", [bind_string("procedure_name", procedure_name.upcase)]).join
-                  SELECT text
+                source = select_values(<<~SQL.squish, "SCHEMA", [bind_string("procedure_name", procedure_name.upcase)]).join
+                  SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ text
                   FROM all_source
                   WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
                     AND name = :procedure_name
@@ -196,19 +199,19 @@ module ActiveRecord
         #     t.string      :last_name, :comment => “Surname”
         #   end
 
-        def create_table(table_name, **options)
-          create_sequence = options[:id] != false
-          td = create_table_definition table_name, **options
+        def create_table(table_name, id: :primary_key, primary_key: nil, force: nil, **options)
+          create_sequence = id != false
+          td = create_table_definition(
+            table_name, **options.extract!(:temporary, :options, :as, :comment, :tablespace, :organization)
+          )
 
-          if options[:id] != false && !options[:as]
-            pk = options.fetch(:primary_key) do
-              Base.get_primary_key table_name.to_s.singularize
-            end
+          if id && !td.as
+            pk = primary_key || Base.get_primary_key(table_name.to_s.singularize)
 
             if pk.is_a?(Array)
               td.primary_keys pk
             else
-              td.primary_key pk, options.fetch(:id, :primary_key), **options
+              td.primary_key pk, id, **options
             end
           end
 
@@ -226,8 +229,10 @@ module ActiveRecord
           yield td if block_given?
           create_sequence = create_sequence || td.create_sequence
 
-          if options[:force] && data_source_exists?(table_name)
-            drop_table(table_name, options)
+          if force && data_source_exists?(table_name)
+            drop_table(table_name, force: force, if_exists: true)
+          else
+            schema_cache.clear_data_source_cache!(table_name.to_s)
           end
 
           execute schema_creation.accept td
@@ -235,14 +240,14 @@ module ActiveRecord
           create_sequence_and_trigger(table_name, options) if create_sequence
 
           if supports_comments? && !supports_comments_in_create?
-            if table_comment = options[:comment].presence
+            if table_comment = td.comment.presence
               change_table_comment(table_name, table_comment)
             end
             td.columns.each do |column|
               change_column_comment(table_name, column.name, column.comment) if column.comment.present?
             end
           end
-          td.indexes.each { |c, o| add_index table_name, c, o }
+          td.indexes.each { |c, o| add_index table_name, c, **o }
 
           rebuild_primary_key_index_to_default_tablespace(table_name, options)
         end
@@ -251,13 +256,16 @@ module ActiveRecord
           if new_name.to_s.length > DatabaseLimits::IDENTIFIER_MAX_LENGTH
             raise ArgumentError, "New table name '#{new_name}' is too long; the limit is #{DatabaseLimits::IDENTIFIER_MAX_LENGTH} characters"
           end
+          schema_cache.clear_data_source_cache!(table_name.to_s)
+          schema_cache.clear_data_source_cache!(new_name.to_s)
           execute "RENAME #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
           execute "RENAME #{quote_table_name("#{table_name}_seq")} TO #{default_sequence_name(new_name)}" rescue nil
 
           rename_table_indexes(table_name, new_name)
         end
 
-        def drop_table(table_name, options = {}) #:nodoc:
+        def drop_table(table_name, **options) #:nodoc:
+          schema_cache.clear_data_source_cache!(table_name.to_s)
           execute "DROP TABLE #{quote_table_name(table_name)}#{' CASCADE CONSTRAINTS' if options[:force] == :cascade}"
           seq_name = options[:sequence_name] || default_sequence_name(table_name)
           execute "DROP SEQUENCE #{quote_table_name(seq_name)}" rescue nil
@@ -287,7 +295,7 @@ module ActiveRecord
           end
         end
 
-        def add_index(table_name, column_name, options = {}) #:nodoc:
+        def add_index(table_name, column_name, **options) #:nodoc:
           index_name, index_type, quoted_column_names, tablespace, index_options = add_index_options(table_name, column_name, **options)
           execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})#{tablespace} #{index_options}"
           if index_type == "UNIQUE"
@@ -306,13 +314,11 @@ module ActiveRecord
           index_type = options[:unique] ? "UNIQUE" : ""
           index_name = options[:name].to_s if options.key?(:name)
           tablespace = tablespace_for(:index, options[:tablespace])
-          max_index_length = options.fetch(:internal, false) ? index_name_length : allowed_index_name_length
-          # TODO: This option is used for NOLOGGING, needs better argumetn name
+          # TODO: This option is used for NOLOGGING, needs better argument name
           index_options = options[:options]
 
-          if index_name.to_s.length > max_index_length
-            raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{max_index_length} characters"
-          end
+          validate_index_length!(table_name, index_name, options.fetch(:internal, false))
+
           if table_exists?(table_name) && index_name_exists?(table_name, index_name)
             raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists"
           end
@@ -323,8 +329,8 @@ module ActiveRecord
 
         # Remove the given index from the table.
         # Gives warning if index does not exist
-        def remove_index(table_name, options = {}) #:nodoc:
-          index_name = index_name_for_remove(table_name, options)
+        def remove_index(table_name, column_name = nil, **options) #:nodoc:
+          index_name = index_name_for_remove(table_name, column_name, options)
           # 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)}"
@@ -361,8 +367,8 @@ module ActiveRecord
         # Will always query database and not index cache.
         def index_name_exists?(table_name, index_name)
           (_owner, table_name) = @connection.describe(table_name)
-          result = select_value(<<~SQL.squish, "index name exists")
-            SELECT 1 FROM all_indexes i
+          result = select_value(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ 1 FROM all_indexes i
             WHERE i.owner = SYS_CONTEXT('userenv', 'current_schema')
                AND i.table_owner = SYS_CONTEXT('userenv', 'current_schema')
                AND i.table_name = '#{table_name}'
@@ -440,7 +446,7 @@ module ActiveRecord
           change_column table_name, column_name, column.sql_type, null: null
         end
 
-        def change_column(table_name, column_name, type, options = {}) #:nodoc:
+        def change_column(table_name, column_name, type, **options) #:nodoc:
           column = column_for(table_name, column_name)
 
           # remove :null option if its value is the same as current column definition
@@ -494,9 +500,10 @@ module ActiveRecord
         end
 
         def table_comment(table_name) #:nodoc:
+          # TODO
           (_owner, table_name) = @connection.describe(table_name)
-          select_value(<<~SQL.squish, "Table comment", [bind_string("table_name", table_name)])
-            SELECT comments FROM all_tab_comments
+          select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name)])
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ comments FROM all_tab_comments
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
               AND table_name = :table_name
           SQL
@@ -511,8 +518,8 @@ module ActiveRecord
         def column_comment(table_name, column_name) #:nodoc:
           # TODO: it  does not exist in Abstract adapter
           (_owner, table_name) = @connection.describe(table_name)
-          select_value(<<~SQL.squish, "Column comment", [bind_string("table_name", table_name), bind_string("column_name", column_name.upcase)])
-            SELECT comments FROM all_col_comments
+          select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name), bind_string("column_name", column_name.upcase)])
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ comments FROM all_col_comments
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
               AND table_name = :table_name
               AND column_name = :column_name
@@ -528,8 +535,8 @@ module ActiveRecord
         end
 
         def tablespace(table_name)
-          select_value(<<~SQL.squish, "tablespace")
-            SELECT tablespace_name
+          select_value(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ tablespace_name
             FROM all_tables
             WHERE table_name='#{table_name.to_s.upcase}'
             AND owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -540,8 +547,8 @@ module ActiveRecord
         def foreign_keys(table_name) #:nodoc:
           (_owner, desc_table_name) = @connection.describe(table_name)
 
-          fk_info = select_all(<<~SQL.squish, "Foreign Keys", [bind_string("desc_table_name", desc_table_name)])
-            SELECT r.table_name to_table
+          fk_info = select_all(<<~SQL.squish, "SCHEMA", [bind_string("desc_table_name", desc_table_name)])
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ r.table_name to_table
                   ,rc.column_name references_column
                   ,cc.column_name
                   ,c.constraint_name name
@@ -582,8 +589,8 @@ module ActiveRecord
         # REFERENTIAL INTEGRITY ====================================
 
         def disable_referential_integrity(&block) #:nodoc:
-          old_constraints = select_all(<<~SQL.squish, "Foreign Keys to disable and enable")
-            SELECT constraint_name, owner, table_name
+          old_constraints = select_all(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ constraint_name, owner, table_name
               FROM all_constraints
               WHERE constraint_type = 'R'
               AND status = 'ENABLED'
@@ -614,13 +621,12 @@ module ActiveRecord
         end
 
         private
-
           def schema_creation
             OracleEnhanced::SchemaCreation.new self
           end
 
-          def create_table_definition(*args, **options)
-            OracleEnhanced::TableDefinition.new(self, *args, **options)
+          def create_table_definition(name, **options)
+            OracleEnhanced::TableDefinition.new(self, name, **options)
           end
 
           def new_column_from_field(table_name, field)
@@ -642,7 +648,7 @@ module ActiveRecord
               # 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
+              field["data_default"] = nil if /^(null|empty_[bc]lob\(\))$/i.match?(field["data_default"])
               # TODO: Needs better fix to fallback "N" to false
               field["data_default"] = false if field["data_default"] == "N" && OracleEnhancedAdapter.emulate_booleans_from_strings
             end
@@ -699,7 +705,7 @@ module ActiveRecord
             return unless tablespace
 
             index_name = select_value(<<~SQL.squish, "Index name for primary key",  [bind_string("table_name", table_name.upcase)])
-              SELECT index_name FROM all_constraints
+              SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ index_name FROM all_constraints
                   WHERE table_name = :table_name
                   AND constraint_type = 'P'
                   AND owner = SYS_CONTEXT('userenv', 'current_schema')

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

@@ -8,8 +8,9 @@ module ActiveRecord #:nodoc:
         STATEMENT_TOKEN = "\n\n/\n\n"
 
         def structure_dump #:nodoc:
-          sequences = select(<<~SQL.squish, "sequences to dump at structure dump")
-            SELECT sequence_name, min_value, max_value, increment_by, order_flag, cycle_flag
+          sequences = select(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */
+            sequence_name, min_value, max_value, increment_by, order_flag, cycle_flag
             FROM all_sequences
             where sequence_owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY 1
           SQL
@@ -17,8 +18,8 @@ module ActiveRecord #:nodoc:
           structure = sequences.map do |result|
             "CREATE SEQUENCE #{quote_table_name(result["sequence_name"])} MINVALUE #{result["min_value"]} MAXVALUE #{result["max_value"]} INCREMENT BY #{result["increment_by"]} #{result["order_flag"] == 'Y' ? "ORDER" : "NOORDER"} #{result["cycle_flag"] == 'Y' ? "CYCLE" : "NOCYCLE"}"
           end
-          tables = select_values(<<~SQL.squish, "tables at structure dump")
-            SELECT table_name FROM all_tables t
+          tables = select_values(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ table_name FROM all_tables t
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema') AND secondary = 'N'
             AND NOT EXISTS (SELECT mv.mview_name FROM all_mviews mv
                             WHERE mv.owner = t.owner AND mv.mview_name = t.table_name)
@@ -29,8 +30,8 @@ module ActiveRecord #:nodoc:
           tables.each do |table_name|
             virtual_columns = virtual_columns_for(table_name) if supports_virtual_columns?
             ddl = +"CREATE#{ ' GLOBAL TEMPORARY' if temporary_table?(table_name)} TABLE \"#{table_name}\" (\n"
-            columns = select_all(<<~SQL.squish, "columns at structure dump")
-              SELECT column_name, data_type, data_length, char_used, char_length,
+            columns = select_all(<<~SQL.squish, "SCHEMA")
+              SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ column_name, data_type, data_length, char_used, char_length,
               data_precision, data_scale, data_default, nullable
               FROM all_tab_columns
               WHERE table_name = '#{table_name}'
@@ -54,8 +55,9 @@ module ActiveRecord #:nodoc:
             structure << structure_dump_column_comments(table_name)
           end
 
-          join_with_statement_token(structure) << structure_dump_fk_constraints
-          join_with_statement_token(structure) << structure_dump_views
+          join_with_statement_token(structure) <<
+            structure_dump_fk_constraints <<
+            structure_dump_views
         end
 
         def structure_dump_column(column) #:nodoc:
@@ -89,8 +91,8 @@ module ActiveRecord #:nodoc:
 
         def structure_dump_primary_key(table) #:nodoc:
           opts = { name: "", cols: [] }
-          pks = select_all(<<~SQL.squish, "Primary Keys")
-            SELECT a.constraint_name, a.column_name, a.position
+          pks = select_all(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ a.constraint_name, a.column_name, a.position
               FROM all_cons_columns a
               JOIN all_constraints c
                 ON a.constraint_name = c.constraint_name
@@ -108,8 +110,8 @@ module ActiveRecord #:nodoc:
 
         def structure_dump_unique_keys(table) #:nodoc:
           keys = {}
-          uks = select_all(<<~SQL.squish, "Primary Keys")
-            SELECT a.constraint_name, a.column_name, a.position
+          uks = select_all(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ a.constraint_name, a.column_name, a.position
               FROM all_cons_columns a
               JOIN all_constraints c
                 ON a.constraint_name = c.constraint_name
@@ -144,8 +146,8 @@ module ActiveRecord #:nodoc:
         end
 
         def structure_dump_fk_constraints #:nodoc:
-          foreign_keys = select_all(<<~SQL.squish, "foreign keys at structure dump")
-            SELECT table_name FROM all_tables
+          foreign_keys = select_all(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ table_name FROM all_tables
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY 1
           SQL
           fks = foreign_keys.map do |table|
@@ -172,8 +174,8 @@ module ActiveRecord #:nodoc:
 
         def structure_dump_column_comments(table_name)
           comments = []
-          columns = select_values(<<~SQL.squish, "column comments at structure dump")
-            SELECT column_name FROM user_tab_columns
+          columns = select_values(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ column_name FROM user_tab_columns
             WHERE table_name = '#{table_name}' ORDER BY column_id
           SQL
 
@@ -206,8 +208,8 @@ module ActiveRecord #:nodoc:
         # Extract all stored procedures, packages, synonyms.
         def structure_dump_db_stored_code #:nodoc:
           structure = []
-          all_source = select_all(<<~SQL.squish, "stored program at structure dump")
-            SELECT DISTINCT name, type
+          all_source = select_all(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ DISTINCT name, type
             FROM all_source
             WHERE type IN ('PROCEDURE', 'PACKAGE', 'PACKAGE BODY', 'FUNCTION', 'TRIGGER', 'TYPE')
             AND name NOT LIKE 'BIN$%'
@@ -216,7 +218,7 @@ module ActiveRecord #:nodoc:
           all_source.each do |source|
             ddl = +"CREATE OR REPLACE   \n"
             texts = select_all(<<~SQL.squish, "all source at structure dump")
-              SELECT text
+              SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ text
               FROM all_source
               WHERE name = '#{source['name']}'
               AND type = '#{source['type']}'
@@ -238,8 +240,8 @@ module ActiveRecord #:nodoc:
 
         def structure_dump_views #:nodoc:
           structure = []
-          views = select_all(<<~SQL.squish, "views at structure dump")
-            SELECT view_name, text FROM all_views
+          views = select_all(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ view_name, text FROM all_views
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY view_name ASC
           SQL
           views.each do |view|
@@ -250,8 +252,8 @@ module ActiveRecord #:nodoc:
 
         def structure_dump_synonyms #:nodoc:
           structure = []
-          synonyms = select_all(<<~SQL.squish, "synonyms at structure dump")
-            SELECT owner, synonym_name, table_name, table_owner
+          synonyms = select_all(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ owner, synonym_name, table_name, table_owner
             FROM all_synonyms
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
@@ -263,14 +265,15 @@ module ActiveRecord #:nodoc:
         end
 
         def structure_drop #:nodoc:
-          sequences = select_values(<<~SQL.squish, "sequences to drop at structure dump")
-            SELECT sequence_name FROM all_sequences where sequence_owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY 1
+          sequences = select_values(<<~SQL.squish, "SCHEMA")
+            SELECT/*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */
+            sequence_name FROM all_sequences where sequence_owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY 1
           SQL
           statements = sequences.map do |seq|
             "DROP SEQUENCE \"#{seq}\""
           end
-          tables = select_values(<<~SQL.squish, "tables to drop at structure dump")
-            SELECT table_name from all_tables t
+          tables = select_values(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ table_name from all_tables t
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema') AND secondary = 'N'
             AND NOT EXISTS (SELECT mv.mview_name FROM all_mviews mv
                             WHERE mv.owner = t.owner AND mv.mview_name = t.table_name)
@@ -285,8 +288,8 @@ module ActiveRecord #:nodoc:
         end
 
         def temp_table_drop #:nodoc:
-          temporary_tables = select_values(<<~SQL.squish, "temporary tables to drop at structure dump")
-            SELECT table_name FROM all_tables
+          temporary_tables = select_values(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ table_name FROM all_tables
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
             AND secondary = 'N' AND temporary = 'Y' ORDER BY 1
           SQL
@@ -316,12 +319,11 @@ module ActiveRecord #:nodoc:
         end
 
       private
-
         # Called only if `supports_virtual_columns?` returns true
         # return [{'column_name' => 'FOOS', 'data_default' => '...'}, ...]
         def virtual_columns_for(table)
-          select_all(<<~SQL.squish, "virtual columns for")
-            SELECT column_name, data_default
+          select_all(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ column_name, data_default
             FROM all_tab_cols
             WHERE virtual_column = 'YES'
             AND owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -331,8 +333,8 @@ module ActiveRecord #:nodoc:
 
         def drop_sql_for_feature(type)
           short_type = type == "materialized view" ? "mview" : type
-          features = select_values(<<~SQL.squish, "features to drop")
-            SELECT #{short_type}_name FROM all_#{short_type.tableize}
+          features = select_values(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ #{short_type}_name FROM all_#{short_type.tableize}
             where owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
           statements = features.map do |name|
@@ -342,8 +344,8 @@ module ActiveRecord #:nodoc:
         end
 
         def drop_sql_for_object(type)
-          objects = select_values(<<~SQL.squish, "objects to drop")
-            SELECT object_name FROM all_objects
+          objects = select_values(<<~SQL.squish, "SCHEMA")
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ object_name FROM all_objects
             WHERE object_type = '#{type.upcase}' and owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
           statements = objects.map do |name|