activerecord-oracle_enhanced-adapter 6.1.4 → 7.0.1

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

@@ -8,25 +8,25 @@ module ActiveRecord
         #
         # see: abstract/quoting.rb
 
-        def quote_column_name(name) #:nodoc:
+        def quote_column_name(name) # :nodoc:
           name = name.to_s
-          self.class.quoted_column_names[name] ||= if /\A[a-z][a-z_0-9\$#]*\Z/.match?(name)
+          self.class.quoted_column_names[name] ||= if /\A[a-z][a-z_0-9$#]*\Z/.match?(name)
             "\"#{name.upcase}\""
           else
             # remove double quotes which cannot be used inside quoted identifier
-            "\"#{name.gsub('"', '')}\""
+            "\"#{name.delete('"')}\""
           end
         end
 
         # This method is used in add_index to identify either column name (which is quoted)
         # or function based index (in which case function expression is not quoted)
-        def quote_column_name_or_expression(name) #:nodoc:
+        def quote_column_name_or_expression(name) # :nodoc:
           name = name.to_s
           case name
           # if only valid lowercase column characters in name
-          when /^[a-z][a-z_0-9\$#]*$/
+          when /^[a-z][a-z_0-9$#]*$/
             "\"#{name.upcase}\""
-          when /^[a-z][a-z_0-9\$#\-]*$/i
+          when /^[a-z][a-z_0-9$#\-]*$/i
             "\"#{name}\""
           # if other characters present then assume that it is expression
           # which should not be quoted
@@ -55,7 +55,7 @@ module ActiveRecord
         # contain letters, digits, _, $ or #
         # can be prefixed with schema name
         # CamelCase table names should be quoted
-        def self.valid_table_name?(name) #:nodoc:
+        def self.valid_table_name?(name) # :nodoc:
           object_name = name.to_s
           !!(object_name =~ VALID_TABLE_NAME && !mixed_case?(object_name))
         end
@@ -65,16 +65,16 @@ module ActiveRecord
           !!(object_name =~ /[A-Z]/ && object_name =~ /[a-z]/)
         end
 
-        def quote_table_name(name) #:nodoc:
+        def quote_table_name(name) # :nodoc:
           name, _link = name.to_s.split("@")
           self.class.quoted_table_names[name] ||= [name.split(".").map { |n| quote_column_name(n) }].join(".")
         end
 
-        def quote_string(s) #:nodoc:
+        def quote_string(s) # :nodoc:
           s.gsub(/'/, "''")
         end
 
-        def _quote(value) #:nodoc:
+        def quote(value) # :nodoc:
           case value
           when Type::OracleEnhanced::CharacterString::Data then
             "'#{quote_string(value.to_s)}'"
@@ -91,31 +91,31 @@ module ActiveRecord
           end
         end
 
-        def quoted_true #:nodoc:
+        def quoted_true # :nodoc:
           return "'Y'" if emulate_booleans_from_strings
           "1"
         end
 
-        def unquoted_true #:nodoc:
+        def unquoted_true # :nodoc:
           return "Y" if emulate_booleans_from_strings
           "1"
         end
 
-        def quoted_false #:nodoc:
+        def quoted_false # :nodoc:
           return "'N'" if emulate_booleans_from_strings
           "0"
         end
 
-        def unquoted_false #:nodoc:
+        def unquoted_false # :nodoc:
           return "N" if emulate_booleans_from_strings
           "0"
         end
 
-        def _type_cast(value)
+        def type_cast(value)
           case value
           when Type::OracleEnhanced::TimestampTz::Data, Type::OracleEnhanced::TimestampLtz::Data
             if value.acts_like?(:time)
-              zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+              zone_conversion_method = ActiveRecord.default_timezone == :utc ? :getutc : :getlocal
               value.respond_to?(zone_conversion_method) ? value.send(zone_conversion_method) : value
             else
               value

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

@@ -21,7 +21,7 @@ module ActiveRecord
             statements << accept(o.primary_keys) if o.primary_keys
 
             if supports_foreign_keys?
-              statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
+              statements.concat(o.foreign_keys.map { |fk| accept fk })
             end
 
             create_sql << "(#{statements.join(', ')})" if statements.present?

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

@@ -35,7 +35,7 @@ module ActiveRecord
         end
       end
 
-      class SynonymDefinition < Struct.new(:name, :table_owner, :table_name) #:nodoc:
+      class SynonymDefinition < Struct.new(:name, :table_owner, :table_name) # :nodoc:
       end
 
       class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module ActiveRecord #:nodoc:
-  module ConnectionAdapters #:nodoc:
-    module OracleEnhanced #:nodoc:
-      class SchemaDumper < ConnectionAdapters::SchemaDumper #:nodoc:
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    module OracleEnhanced # :nodoc:
+      class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
         DEFAULT_PRIMARY_KEY_COLUMN_SPEC = { precision: "38", null: "false" }.freeze
         private_constant :DEFAULT_PRIMARY_KEY_COLUMN_SPEC
 
@@ -47,7 +47,7 @@ module ActiveRecord #:nodoc:
 
           def _indexes(table, stream)
             if (indexes = @connection.indexes(table)).any?
-              add_index_statements = indexes.map do |index|
+              add_index_statements = indexes.filter_map do |index|
                 case index.type
                 when nil
                   # do nothing here. see indexes_in_create
@@ -67,7 +67,7 @@ module ActiveRecord #:nodoc:
                   statement_parts = ["# unrecognized index #{index.name.inspect} with type #{index.type.inspect}"]
                 end
                 "  " + statement_parts.join(", ") unless statement_parts.empty?
-              end.compact
+              end
 
               return if add_index_statements.empty?
 

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "digest/sha1"
+require "openssl"
 
 module ActiveRecord
   module ConnectionAdapters
@@ -10,7 +10,7 @@ module ActiveRecord
         #
         # see: abstract/schema_statements.rb
 
-        def tables #:nodoc:
+        def tables # :nodoc:
           select_values(<<~SQL.squish, "SCHEMA")
             SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */
             DECODE(table_name, UPPER(table_name), LOWER(table_name), table_name)
@@ -66,7 +66,7 @@ module ActiveRecord
           SQL
         end
 
-        def materialized_views #:nodoc:
+        def materialized_views # :nodoc:
           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')
@@ -86,7 +86,7 @@ module ActiveRecord
            end
         end
 
-        def indexes(table_name) #:nodoc:
+        def indexes(table_name) # :nodoc:
           (_owner, table_name) = @connection.describe(table_name)
           default_tablespace_name = default_tablespace
 
@@ -252,7 +252,7 @@ module ActiveRecord
           rebuild_primary_key_index_to_default_tablespace(table_name, options)
         end
 
-        def rename_table(table_name, new_name) #:nodoc:
+        def rename_table(table_name, new_name) # :nodoc:
           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
@@ -264,7 +264,7 @@ module ActiveRecord
           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)
@@ -295,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"
@@ -305,7 +305,7 @@ module ActiveRecord
           end
         end
 
-        def add_index_options(table_name, column_name, comment: nil, **options) #:nodoc:
+        def add_index_options(table_name, column_name, comment: nil, **options) # :nodoc:
           column_names = Array(column_name)
           index_name   = index_name(table_name, column: column_names)
 
@@ -329,7 +329,9 @@ module ActiveRecord
 
         # Remove the given index from the table.
         # Gives warning if index does not exist
-        def remove_index(table_name, column_name = nil, **options) #:nodoc:
+        def remove_index(table_name, column_name = nil, **options) # :nodoc:
+          return if options[:if_exists] && !index_exists?(table_name, column_name, **options)
+
           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
@@ -337,7 +339,7 @@ module ActiveRecord
         end
 
         # returned shortened index name if default is too large
-        def index_name(table_name, options) #:nodoc:
+        def index_name(table_name, options) # :nodoc:
           default_name = super(table_name, options).to_s
           # sometimes options can be String or Array with column names
           options = {} unless options.is_a?(Hash)
@@ -353,7 +355,7 @@ module ActiveRecord
           end
           # generate unique name using hash function
           if shortened_name.length > identifier_max_length
-            shortened_name = "i" + Digest::SHA1.hexdigest(default_name)[0, identifier_max_length - 1]
+            shortened_name = "i" + OpenSSL::Digest::SHA1.hexdigest(default_name)[0, identifier_max_length - 1]
           end
           @logger.warn "#{adapter_name} shortened default index name #{default_name} to #{shortened_name}" if @logger
           shortened_name
@@ -367,17 +369,17 @@ 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, "SCHEMA")
+          result = select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name), bind_string("index_name", index_name.to_s.upcase)])
             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}'
-               AND i.index_name = '#{index_name.to_s.upcase}'
+               AND i.table_name = :table_name
+               AND i.index_name = :index_name
           SQL
           result == 1
         end
 
-        def rename_index(table_name, old_name, new_name) #:nodoc:
+        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)}"
         end
@@ -412,7 +414,7 @@ module ActiveRecord
           OracleEnhanced::ReferenceDefinition.new(ref_name, **options).add_to(update_table_definition(table_name, self))
         end
 
-        def add_column(table_name, column_name, type, **options) #:nodoc:
+        def add_column(table_name, column_name, type, **options) # :nodoc:
           type = aliased_types(type.to_s, type)
           at = create_alter_table table_name
           at.add_column(column_name, type, **options)
@@ -429,14 +431,14 @@ module ActiveRecord
           fallback
         end
 
-        def change_column_default(table_name, column_name, default_or_changes) #:nodoc:
+        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:
+        def change_column_null(table_name, column_name, null, default = nil) # :nodoc:
           column = column_for(table_name, column_name)
 
           unless null || default.nil?
@@ -446,7 +448,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
@@ -470,19 +472,27 @@ module ActiveRecord
           clear_table_columns_cache(table_name)
         end
 
-        def rename_column(table_name, column_name, new_column_name) #:nodoc:
+        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)}"
           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:
+        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)
         end
 
+        def remove_columns(table_name, *column_names, type: nil, **options) # :nodoc:
+          quoted_column_names = column_names.map { |column_name| quote_column_name(column_name) }.join(", ")
+
+          execute "ALTER TABLE #{quote_table_name(table_name)} DROP (#{quoted_column_names}) CASCADE CONSTRAINTS"
+        ensure
+          clear_table_columns_cache(table_name)
+        end
+
         def change_table_comment(table_name, comment_or_changes)
           clear_cache!
           comment = extract_new_comment_value(comment_or_changes)
@@ -499,7 +509,7 @@ module ActiveRecord
           execute "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column_name)} IS '#{comment}'"
         end
 
-        def table_comment(table_name) #:nodoc:
+        def table_comment(table_name) # :nodoc:
           # TODO
           (_owner, table_name) = @connection.describe(table_name)
           select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name)])
@@ -515,7 +525,7 @@ module ActiveRecord
           end
         end
 
-        def column_comment(table_name, column_name) #:nodoc:
+        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, "SCHEMA", [bind_string("table_name", table_name), bind_string("column_name", column_name.upcase)])
@@ -527,7 +537,7 @@ module ActiveRecord
         end
 
         # Maps logical Rails types to Oracle-specific data types.
-        def type_to_sql(type, limit: nil, precision: nil, scale: nil, **) #:nodoc:
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, **) # :nodoc:
           # Ignore options for :text, :ntext and :binary columns
           return super(type) if ["text", "ntext", "binary"].include?(type.to_s)
 
@@ -544,7 +554,7 @@ module ActiveRecord
         end
 
         # get table foreign keys for schema dump
-        def foreign_keys(table_name) #:nodoc:
+        def foreign_keys(table_name) # :nodoc:
           (_owner, desc_table_name) = @connection.describe(table_name)
 
           fk_info = select_all(<<~SQL.squish, "SCHEMA", [bind_string("desc_table_name", desc_table_name)])
@@ -588,7 +598,7 @@ module ActiveRecord
 
         # REFERENTIAL INTEGRITY ====================================
 
-        def disable_referential_integrity(&block) #:nodoc:
+        def disable_referential_integrity(&block) # :nodoc:
           old_constraints = select_all(<<~SQL.squish, "SCHEMA")
             SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ constraint_name, owner, table_name
               FROM all_constraints
@@ -661,7 +671,7 @@ module ActiveRecord
                              type_metadata,
                              field["nullable"] == "Y",
                              comment: field["column_comment"]
-                      )
+            )
           end
 
           def fetch_type_metadata(sql_type, virtual = nil)

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

@@ -1,13 +1,13 @@
 # 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:
+        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
@@ -30,11 +30,11 @@ 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, "SCHEMA")
+            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}'
+              WHERE table_name = :table_name
               AND owner = SYS_CONTEXT('userenv', 'current_schema')
               ORDER BY column_id
             SQL
@@ -60,7 +60,7 @@ module ActiveRecord #:nodoc:
             structure_dump_views
         end
 
-        def structure_dump_column(column) #:nodoc:
+        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}"
@@ -75,8 +75,8 @@ module ActiveRecord #:nodoc:
           col
         end
 
-        def structure_dump_virtual_column(column, data_default) #:nodoc:
-          data_default = data_default.gsub(/"/, "")
+        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}"
@@ -89,7 +89,7 @@ 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.squish, "SCHEMA")
             SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ a.constraint_name, a.column_name, a.position
@@ -108,7 +108,7 @@ 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.squish, "SCHEMA")
             SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ a.constraint_name, a.column_name, a.position
@@ -129,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 }
@@ -145,7 +145,7 @@ module ActiveRecord #:nodoc:
           end
         end
 
-        def structure_dump_fk_constraints #:nodoc:
+        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
@@ -174,9 +174,10 @@ module ActiveRecord #:nodoc:
 
         def structure_dump_column_comments(table_name)
           comments = []
-          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
+          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|
@@ -189,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")
@@ -206,7 +207,7 @@ module ActiveRecord #:nodoc:
         end
 
         # Extract all stored procedures, packages, synonyms.
-        def structure_dump_db_stored_code #:nodoc:
+        def structure_dump_db_stored_code # :nodoc:
           structure = []
           all_source = select_all(<<~SQL.squish, "SCHEMA")
             SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ DISTINCT name, type
@@ -217,11 +218,11 @@ module ActiveRecord #:nodoc:
           SQL
           all_source.each do |source|
             ddl = +"CREATE OR REPLACE   \n"
-            texts = select_all(<<~SQL.squish, "all source at structure dump")
+            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
@@ -238,7 +239,7 @@ module ActiveRecord #:nodoc:
           join_with_statement_token(structure)
         end
 
-        def structure_dump_views #:nodoc:
+        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
@@ -250,7 +251,7 @@ module ActiveRecord #:nodoc:
           join_with_statement_token(structure)
         end
 
-        def structure_dump_synonyms #:nodoc:
+        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
@@ -264,7 +265,7 @@ module ActiveRecord #:nodoc:
           join_with_statement_token(structure)
         end
 
-        def structure_drop #:nodoc:
+        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
@@ -287,7 +288,7 @@ module ActiveRecord #:nodoc:
           join_with_statement_token(statements)
         end
 
-        def temp_table_drop #:nodoc:
+        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')
@@ -299,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")
@@ -322,12 +323,12 @@ module ActiveRecord #:nodoc:
         # Called only if `supports_virtual_columns?` returns true
         # return [{'column_name' => 'FOOS', 'data_default' => '...'}, ...]
         def virtual_columns_for(table)
-          select_all(<<~SQL.squish, "SCHEMA")
+          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', 'current_schema')
-            AND table_name = '#{table.upcase}'
+            AND table_name = :table_name
           SQL
         end
 

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveRecord
-  module ConnectionAdapters #:nodoc:
+  module ConnectionAdapters # :nodoc:
     module OracleEnhanced
       class TypeMetadata < DelegateClass(ActiveRecord::ConnectionAdapters::SqlTypeMetadata) # :nodoc:
         include Deduplicable