activerecord-oracle_enhanced-adapter 5.2.8 → 7.0.3

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

@@ -1,24 +1,25 @@
 # frozen_string_literal: true
 
-module ActiveRecord #:nodoc:
-  module ConnectionAdapters #:nodoc:
-    module OracleEnhanced #:nodoc:
-      module StructureDump #:nodoc:
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    module OracleEnhanced # :nodoc:
+      module StructureDump # :nodoc:
         # Statements separator used in structure dump to allow loading of structure dump also with SQL*Plus
         STATEMENT_TOKEN = "\n\n/\n\n"
 
-        def structure_dump #:nodoc:
-          sequences = select(<<-SQL.strip.gsub(/\s+/, " "), "sequences to dump at structure dump")
-            SELECT sequence_name, min_value, max_value, increment_by, order_flag, cycle_flag
+        def structure_dump # :nodoc:
+          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', 'session_user') ORDER BY 1
+            where sequence_owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY 1
           SQL
 
           structure = sequences.map do |result|
             "CREATE SEQUENCE #{quote_table_name(result["sequence_name"])} MINVALUE #{result["min_value"]} MAXVALUE #{result["max_value"]} INCREMENT BY #{result["increment_by"]} #{result["order_flag"] == 'Y' ? "ORDER" : "NOORDER"} #{result["cycle_flag"] == 'Y' ? "CYCLE" : "NOCYCLE"}"
           end
-          tables = select_values(<<-SQL.strip.gsub(/\s+/, " "), "tables at structure dump")
-            SELECT table_name FROM all_tables t
+          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)
@@ -28,13 +29,13 @@ module ActiveRecord #:nodoc:
           SQL
           tables.each do |table_name|
             virtual_columns = virtual_columns_for(table_name) if supports_virtual_columns?
-            ddl = "CREATE#{ ' GLOBAL TEMPORARY' if temporary_table?(table_name)} TABLE \"#{table_name}\" (\n".dup
-            columns = select_all(<<-SQL.strip.gsub(/\s+/, " "), "columns at structure dump")
-              SELECT column_name, data_type, data_length, char_used, char_length,
+            ddl = +"CREATE#{ ' GLOBAL TEMPORARY' if temporary_table?(table_name)} TABLE \"#{table_name}\" (\n"
+            columns = select_all(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name)])
+              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}'
-              AND owner = SYS_CONTEXT('userenv', 'session_user')
+              WHERE table_name = :table_name
+              AND owner = SYS_CONTEXT('userenv', 'current_schema')
               ORDER BY column_id
             SQL
             cols = columns.map do |row|
@@ -54,11 +55,13 @@ 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_fk_constraints <<
+            structure_dump_views
         end
 
-        def structure_dump_column(column) #:nodoc:
-          col = "\"#{column['column_name']}\" #{column['data_type']}".dup
+        def structure_dump_column(column) # :nodoc:
+          col = +"\"#{column['column_name']}\" #{column['data_type']}"
           if (column["data_type"] == "NUMBER") && !column["data_precision"].nil?
             col << "(#{column['data_precision'].to_i}"
             col << ",#{column['data_scale'].to_i}" if !column["data_scale"].nil?
@@ -72,9 +75,9 @@ module ActiveRecord #:nodoc:
           col
         end
 
-        def structure_dump_virtual_column(column, data_default) #:nodoc:
-          data_default = data_default.gsub(/"/, "")
-          col = "\"#{column['column_name']}\" #{column['data_type']}".dup
+        def structure_dump_virtual_column(column, data_default) # :nodoc:
+          data_default = data_default.delete('"')
+          col = +"\"#{column['column_name']}\" #{column['data_type']}"
           if (column["data_type"] == "NUMBER") && !column["data_precision"].nil?
             col << "(#{column['data_precision'].to_i}"
             col << ",#{column['data_scale'].to_i}" if !column["data_scale"].nil?
@@ -86,18 +89,18 @@ module ActiveRecord #:nodoc:
           col << " GENERATED ALWAYS AS (#{data_default}) VIRTUAL"
         end
 
-        def structure_dump_primary_key(table) #:nodoc:
+        def structure_dump_primary_key(table) # :nodoc:
           opts = { name: "", cols: [] }
-          pks = select_all(<<-SQL.strip.gsub(/\s+/, " "), "Primary Keys")
-          SELECT a.constraint_name, a.column_name, a.position
-            FROM all_cons_columns a
-            JOIN all_constraints c
-              ON a.constraint_name = c.constraint_name
-           WHERE c.table_name = '#{table.upcase}'
-             AND c.constraint_type = 'P'
-             AND a.owner = c.owner
-             AND c.owner = SYS_CONTEXT('userenv', 'current_schema')
-        SQL
+          pks = 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
+             WHERE c.table_name = '#{table.upcase}'
+               AND c.constraint_type = 'P'
+               AND a.owner = c.owner
+               AND c.owner = SYS_CONTEXT('userenv', 'current_schema')
+          SQL
           pks.each do |row|
             opts[:name] = row["constraint_name"]
             opts[:cols][row["position"] - 1] = row["column_name"]
@@ -105,18 +108,18 @@ module ActiveRecord #:nodoc:
           opts[:cols].length > 0 ? ",\n CONSTRAINT #{opts[:name]} PRIMARY KEY (#{opts[:cols].join(',')})" : ""
         end
 
-        def structure_dump_unique_keys(table) #:nodoc:
+        def structure_dump_unique_keys(table) # :nodoc:
           keys = {}
-          uks = select_all(<<-SQL.strip.gsub(/\s+/, " "), "Primary Keys")
-          SELECT a.constraint_name, a.column_name, a.position
-            FROM all_cons_columns a
-            JOIN all_constraints c
-              ON a.constraint_name = c.constraint_name
-           WHERE c.table_name = '#{table.upcase}'
-             AND c.constraint_type = 'U'
-             AND a.owner = c.owner
-             AND c.owner = SYS_CONTEXT('userenv', 'current_schema')
-        SQL
+          uks = 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
+             WHERE c.table_name = '#{table.upcase}'
+               AND c.constraint_type = 'U'
+               AND a.owner = c.owner
+               AND c.owner = SYS_CONTEXT('userenv', 'current_schema')
+          SQL
           uks.each do |uk|
             keys[uk["constraint_name"]] ||= []
             keys[uk["constraint_name"]][uk["position"] - 1] = uk["column_name"]
@@ -126,7 +129,7 @@ module ActiveRecord #:nodoc:
           end
         end
 
-        def structure_dump_indexes(table_name) #:nodoc:
+        def structure_dump_indexes(table_name) # :nodoc:
           indexes(table_name).map do |options|
             column_names = options.columns
             options = { name: options.name, unique: options.unique }
@@ -142,15 +145,15 @@ module ActiveRecord #:nodoc:
           end
         end
 
-        def structure_dump_fk_constraints #:nodoc:
-          foreign_keys = select_all(<<-SQL.strip.gsub(/\s+/, " "), "foreign keys at structure dump")
-            SELECT table_name FROM all_tables
+        def structure_dump_fk_constraints # :nodoc:
+          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|
             if respond_to?(:foreign_keys) && (foreign_keys = foreign_keys(table["table_name"])).any?
               foreign_keys.map do |fk|
-                sql = "ALTER TABLE #{quote_table_name(fk.from_table)} ADD CONSTRAINT #{quote_column_name(fk.options[:name])} ".dup
+                sql = +"ALTER TABLE #{quote_table_name(fk.from_table)} ADD CONSTRAINT #{quote_column_name(fk.options[:name])} "
                 sql << "#{foreign_key_definition(fk.to_table, fk.options)}"
               end
             end
@@ -171,9 +174,10 @@ module ActiveRecord #:nodoc:
 
         def structure_dump_column_comments(table_name)
           comments = []
-          columns = select_values(<<-SQL.strip.gsub(/\s+/, " "), "column comments at structure dump")
-            SELECT column_name FROM user_tab_columns
-            WHERE table_name = '#{table_name}' ORDER BY column_id
+          columns = select_values(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name)])
+            SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ column_name FROM all_tab_columns
+            WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
+            AND table_name = :table_name ORDER BY column_id
           SQL
 
           columns.each do |column|
@@ -186,7 +190,7 @@ module ActiveRecord #:nodoc:
           join_with_statement_token(comments)
         end
 
-        def foreign_key_definition(to_table, options = {}) #:nodoc:
+        def foreign_key_definition(to_table, options = {}) # :nodoc:
           column_sql = quote_column_name(options[:column] || "#{to_table.to_s.singularize}_id")
           references = options[:references] ? options[:references].first : nil
           references_sql = quote_column_name(options[:primary_key] || references || "id")
@@ -202,23 +206,23 @@ module ActiveRecord #:nodoc:
           sql
         end
 
-        # Extract all stored procedures, packages, synonyms and views.
-        def structure_dump_db_stored_code #:nodoc:
+        # Extract all stored procedures, packages, synonyms.
+        def structure_dump_db_stored_code # :nodoc:
           structure = []
-          all_source = select_all(<<-SQL.strip.gsub(/\s+/, " "), "stored program at structure dump")
-            SELECT DISTINCT name, type
+          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$%'
             AND owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY type
           SQL
           all_source.each do |source|
-            ddl = "CREATE OR REPLACE   \n".dup
-            texts = select_all(<<-SQL.strip.gsub(/\s+/, " "), "all source at structure dump")
-              SELECT text
+            ddl = +"CREATE OR REPLACE   \n"
+            texts = select_all(<<~SQL.squish, "all source at structure dump", [bind_string("source_name", source["name"]), bind_string("source_type", source["type"])])
+              SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ text
               FROM all_source
-              WHERE name = '#{source['name']}'
-              AND type = '#{source['type']}'
+              WHERE name = :source_name
+              AND type = :source_type
               AND owner = SYS_CONTEXT('userenv', 'current_schema')
               ORDER BY line
             SQL
@@ -229,38 +233,48 @@ module ActiveRecord #:nodoc:
             structure << ddl
           end
 
-          # export views
-          views = select_all(<<-SQL.strip.gsub(/\s+/, " "), "views at structure dump")
-            SELECT view_name, text FROM all_views
-            WHERE owner = SYS_CONTEXT('userenv', 'session_user') ORDER BY view_name ASC
+          # export synonyms
+          structure << structure_dump_synonyms
+
+          join_with_statement_token(structure)
+        end
+
+        def structure_dump_views # :nodoc:
+          structure = []
+          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|
             structure << "CREATE OR REPLACE FORCE VIEW #{view['view_name']} AS\n #{view['text']}"
           end
+          join_with_statement_token(structure)
+        end
 
-          # export synonyms
-          synonyms = select_all(<<-SQL.strip.gsub(/\s+/, " "), "synonyms at structure dump")
-            SELECT owner, synonym_name, table_name, table_owner
+        def structure_dump_synonyms # :nodoc:
+          structure = []
+          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
           synonyms.each do |synonym|
             structure << "CREATE OR REPLACE #{synonym['owner'] == 'PUBLIC' ? 'PUBLIC' : '' } SYNONYM #{synonym['synonym_name']}
-  			FOR #{synonym['table_owner']}.#{synonym['table_name']}"
+            FOR #{synonym['table_owner']}.#{synonym['table_name']}"
           end
-
           join_with_statement_token(structure)
         end
 
-        def structure_drop #:nodoc:
-          sequences = select_values(<<-SQL.strip.gsub(/\s+/, " "), "sequences to drop at structure dump")
-            SELECT sequence_name FROM all_sequences where sequence_owner = SYS_CONTEXT('userenv', 'session_user') ORDER BY 1
+        def structure_drop # :nodoc:
+          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.strip.gsub(/\s+/, " "), "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)
@@ -274,9 +288,9 @@ module ActiveRecord #:nodoc:
           join_with_statement_token(statements)
         end
 
-        def temp_table_drop #:nodoc:
-          temporary_tables = select_values(<<-SQL.strip.gsub(/\s+/, " "), "temporary tables to drop at structure dump")
-            SELECT table_name FROM all_tables
+        def temp_table_drop # :nodoc:
+          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
@@ -286,7 +300,7 @@ module ActiveRecord #:nodoc:
           join_with_statement_token(statements)
         end
 
-        def full_drop(preserve_tables = false) #:nodoc:
+        def full_drop(preserve_tables = false) # :nodoc:
           s = preserve_tables ? [] : [structure_drop]
           s << temp_table_drop if preserve_tables
           s << drop_sql_for_feature("view")
@@ -306,24 +320,23 @@ 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.strip.gsub(/\s+/, " "), "virtual columns for")
-            SELECT column_name, data_default
+          select_all(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table.upcase)])
+            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', 'session_user')
-            AND table_name = '#{table.upcase}'
+            AND owner = SYS_CONTEXT('userenv', 'current_schema')
+            AND table_name = :table_name
           SQL
         end
 
         def drop_sql_for_feature(type)
           short_type = type == "materialized view" ? "mview" : type
-          features = select_values(<<-SQL.strip.gsub(/\s+/, " "), "features to drop")
-            SELECT #{short_type}_name FROM all_#{short_type.tableize}
-            where owner = SYS_CONTEXT('userenv', 'session_user')
+          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|
             "DROP #{type.upcase} \"#{name}\""
@@ -332,9 +345,9 @@ module ActiveRecord #:nodoc:
         end
 
         def drop_sql_for_object(type)
-          objects = select_values(<<-SQL.strip.gsub(/\s+/, " "), "objects to drop")
-            SELECT object_name FROM all_objects
-            WHERE object_type = '#{type.upcase}' and owner = SYS_CONTEXT('userenv', 'session_user')
+          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|
             "DROP #{type.upcase} \"#{name}\""

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

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 module ActiveRecord
-  module ConnectionAdapters #:nodoc:
+  module ConnectionAdapters # :nodoc:
     module OracleEnhanced
       class TypeMetadata < DelegateClass(ActiveRecord::ConnectionAdapters::SqlTypeMetadata) # :nodoc:
+        include Deduplicable
+
         attr_reader :virtual
 
         def initialize(type_metadata, virtual: nil)
@@ -23,7 +25,6 @@ module ActiveRecord
         end
 
         protected
-
           def attributes_for_hash
             [self.class, @type_metadata, virtual]
           end