activerecord-oracle_enhanced-adapter 5.2.8 → 7.0.3

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

@@ -7,29 +7,28 @@ module ActiveRecord
         # QUOTING ==================================================
         #
         # see: abstract/quoting.rb
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
 
-        def quote_column_name(name) #:nodoc:
+        def quote_column_name(name) # :nodoc:
           name = name.to_s
-          @quoted_column_names[name] ||= begin
-            # if only valid lowercase column characters in name
-            if name =~ /\A[a-z][a-z_0-9\$#]*\Z/
-              "\"#{name.upcase}\""
-            else
-              # remove double quotes which cannot be used inside quoted identifier
-              "\"#{name.gsub('"', '')}\""
-            end
+          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.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
@@ -38,18 +37,6 @@ module ActiveRecord
           end
         end
 
-        # Used only for quoting database links as the naming rules for links
-        # differ from the rules for column names. Specifically, link names may
-        # include periods.
-        def quote_database_link(name)
-          case name
-          when NONQUOTED_DATABASE_LINK
-            %Q("#{name.upcase}")
-          else
-            name
-          end
-        end
-
         # Names must be from 1 to 30 bytes long with these exceptions:
         # * Names of databases are limited to 8 bytes.
         # * Names of database links can be as long as 128 bytes.
@@ -61,18 +48,16 @@ module ActiveRecord
         #
         # Nonquoted identifiers can contain only alphanumeric characters from
         # your database character set and the underscore (_), dollar sign ($),
-        # 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   = /[[: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/
+        # and pound sign (#).
+        # Oracle strongly discourages you from using $ and # in nonquoted identifiers.
+        NONQUOTED_OBJECT_NAME = /[[:alpha:]][\w$#]{0,29}/
+        VALID_TABLE_NAME = /\A(?:#{NONQUOTED_OBJECT_NAME}\.)?#{NONQUOTED_OBJECT_NAME}?\Z/
 
         # unescaped table name should start with letter and
         # 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
@@ -82,19 +67,21 @@ module ActiveRecord
           !!(object_name =~ /[A-Z]/ && object_name =~ /[a-z]/)
         end
 
-        def quote_table_name(name) #:nodoc:
-          name, link = name.to_s.split("@")
-          @quoted_table_names[name] ||= [name.split(".").map { |n| quote_column_name(n) }.join("."), quote_database_link(link)].compact.join("@")
+        def quote_table_name(name) # :nodoc:
+          name, _link = name.to_s.split("@")
+          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)}'"
           when Type::OracleEnhanced::NationalCharacterString::Data then
-            "N".dup << "'#{quote_string(value.to_s)}'"
+            +"N" << "'#{quote_string(value.to_s)}'"
           when ActiveModel::Type::Binary::Data then
             "empty_blob()"
           when Type::OracleEnhanced::Text::Data then
@@ -106,55 +93,92 @@ module ActiveRecord
           end
         end
 
-        def quoted_true #:nodoc:
+        def quoted_true # :nodoc:
           return "'Y'" if emulate_booleans_from_strings
-          "1".freeze
+          "1"
         end
 
-        def unquoted_true #:nodoc:
+        def unquoted_true # :nodoc:
           return "Y" if emulate_booleans_from_strings
-          "1".freeze
+          "1"
         end
 
-        def quoted_false #:nodoc:
+        def quoted_false # :nodoc:
           return "'N'" if emulate_booleans_from_strings
-          "0".freeze
+          "0"
         end
 
-        def unquoted_false #:nodoc:
+        def unquoted_false # :nodoc:
           return "N" if emulate_booleans_from_strings
-          "0".freeze
+          "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
             end
           when Type::OracleEnhanced::NationalCharacterString::Data
             value.to_s
+          when Type::OracleEnhanced::CharacterString::Data
+            value
           else
             super
           end
         end
 
-        private
+        def column_name_matcher
+          COLUMN_NAME
+        end
 
+        def column_name_with_order_matcher
+          COLUMN_NAME_WITH_ORDER
+        end
+
+        COLUMN_NAME = /
+          \A
+          (
+            (?:
+              # "table_name"."column_name" | function(one or no argument)
+              ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+")) | \w+\((?:|\g<2>)\)
+            )
+            (?:(?:\s+AS)?\s+(?:\w+|"\w+"))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        COLUMN_NAME_WITH_ORDER = /
+          \A
+          (
+            (?:
+              # "table_name"."column_name" | function(one or no argument)
+              ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+")) | \w+\((?:|\g<2>)\)
+            )
+            (?:\s+ASC|\s+DESC)?
+            (?:\s+NULLS\s+(?:FIRST|LAST))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+        private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
+
+        private
           def oracle_downcase(column_name)
             return nil if column_name.nil?
-            column_name =~ /[a-z]/ ? column_name : column_name.downcase
+            /[a-z]/.match?(column_name) ? column_name : column_name.downcase
           end
       end
     end
   end
 end
 
-# if MRI or YARV
-if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby"
+# if MRI or YARV or TruffleRuby
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby" || RUBY_ENGINE == "truffleruby"
   require "active_record/connection_adapters/oracle_enhanced/oci_quoting"
 # if JRuby
 elsif RUBY_ENGINE == "jruby"

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

@@ -3,11 +3,10 @@
 module ActiveRecord
   module ConnectionAdapters
     module OracleEnhanced
-      class SchemaCreation < AbstractAdapter::SchemaCreation
+      class SchemaCreation < SchemaCreation
         private
-
           def visit_ColumnDefinition(o)
-            if [:blob, :clob, :nclob].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
@@ -17,12 +16,12 @@ module ActiveRecord
           end
 
           def visit_TableDefinition(o)
-            create_sql = "CREATE#{' GLOBAL TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} ".dup
+            create_sql = +"CREATE#{' GLOBAL TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} "
             statements = o.columns.map { |c| accept c }
             statements << accept(o.primary_keys) if o.primary_keys
 
-            if supports_foreign_keys_in_create?
-              statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
+            if supports_foreign_keys?
+              statements.concat(o.foreign_keys.map { |fk| accept fk })
             end
 
             create_sql << "(#{statements.join(', ')})" if statements.present?
@@ -36,7 +35,7 @@ module ActiveRecord
                 create_sql << " TABLESPACE #{tablespace}"
               end
             end
-            add_table_options!(create_sql, table_options(o))
+            add_table_options!(create_sql, o)
             create_sql << " AS #{to_sql(o.as)}" if o.as
             create_sql
           end
@@ -75,18 +74,18 @@ module ActiveRecord
 
           def action_sql(action, dependency)
             if action == "UPDATE"
-              raise ArgumentError, <<-MSG.strip_heredoc
-              '#{action}' is not supported by Oracle
-            MSG
+              raise ArgumentError, <<~MSG
+                '#{action}' is not supported by Oracle
+              MSG
             end
             case dependency
             when :nullify then "ON #{action} SET NULL"
             when :cascade  then "ON #{action} CASCADE"
             else
-              raise ArgumentError, <<-MSG.strip_heredoc
-              '#{dependency}' is not supported for #{action}
-              Supported values are: :nullify, :cascade
-            MSG
+              raise ArgumentError, <<~MSG
+                '#{dependency}' is not supported for #{action}
+                Supported values are: :nullify, :cascade
+              MSG
             end
           end
       end

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

@@ -17,7 +17,7 @@ module ActiveRecord
         ].each do |column_type|
           module_eval <<-CODE, __FILE__, __LINE__ + 1
             def #{column_type}(*args, **options)
-              args.each { |name| column(name, :#{column_type}, options) }
+              args.each { |name| column(name, :#{column_type}, **options) }
             end
           CODE
         end
@@ -35,7 +35,7 @@ module ActiveRecord
         end
       end
 
-      class SynonymDefinition < Struct.new(:name, :table_owner, :table_name, :db_link) #:nodoc:
+      class SynonymDefinition < Struct.new(:name, :table_owner, :table_name) # :nodoc:
       end
 
       class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition
@@ -53,10 +53,20 @@ module ActiveRecord
         include OracleEnhanced::ColumnMethods
 
         attr_accessor :tablespace, :organization
-        def initialize(name, temporary = false, options = nil, as = nil, tablespace = nil, organization = nil, comment: nil)
+        def initialize(
+          conn,
+          name,
+          temporary: false,
+          options: nil,
+          as: nil,
+          tablespace: nil,
+          organization: nil,
+          comment: nil,
+          **
+        )
           @tablespace = tablespace
           @organization = organization
-          super(name, temporary, options, as, comment: comment)
+          super(conn, name, temporary: temporary, options: options, as: as, comment: comment)
         end
 
         def new_column_definition(name, type, **options) # :nodoc:

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

@@ -1,10 +1,18 @@
 # 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
+
         private
+          def column_spec_for_primary_key(column)
+            spec = super
+            spec.except!(:precision) if prepare_column_options(column) == DEFAULT_PRIMARY_KEY_COLUMN_SPEC
+            spec
+          end
 
           def tables(stream)
             # do not include materialized views in schema dump - they should be created separately after schema creation
@@ -13,8 +21,6 @@ module ActiveRecord #:nodoc:
               # add table prefix or suffix for schema_migrations
               next if ignored? tbl
               table(tbl, stream)
-              # add primary key trigger if table has it
-              primary_key_trigger(tbl, stream)
             end
             # following table definitions
             # add foreign keys if table has them
@@ -27,22 +33,12 @@ module ActiveRecord #:nodoc:
             synonyms(stream)
           end
 
-          def primary_key_trigger(table_name, stream)
-            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"
-              stream.print "\n\n"
-            end
-          end
-
           def synonyms(stream)
             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
@@ -51,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
@@ -63,6 +59,7 @@ module ActiveRecord #:nodoc:
                   else
                     statement_parts = [ ("add_context_index " + remove_prefix_and_suffix(table).inspect) ]
                     statement_parts << index.columns.inspect
+                    statement_parts << ("sync: " + $1.inspect) if index.parameters =~ /SYNC\((.*?)\)/
                     statement_parts << ("name: " + index.name.inspect)
                   end
                 else
@@ -70,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?
 
@@ -84,7 +81,7 @@ module ActiveRecord #:nodoc:
               index_statements = indexes.map do |index|
                 "    t.index #{index_parts(index).join(', ')}" unless index.type == "CTXSYS.CONTEXT"
               end
-              stream.puts index_statements.sort.join("\n")
+              stream.puts index_statements.compact.sort.join("\n")
             end
           end
 
@@ -97,6 +94,8 @@ module ActiveRecord #:nodoc:
           def table(table, stream)
             columns = @connection.columns(table)
             begin
+              self.table_name = table
+
               tbl = StringIO.new
 
               # first dump primary key column
@@ -117,7 +116,10 @@ module ActiveRecord #:nodoc:
                 tbl.print ", primary_key: #{pk.inspect}" unless pk == "id"
                 pkcol = columns.detect { |c| c.name == pk }
                 pkcolspec = column_spec_for_primary_key(pkcol)
-                if pkcolspec.present?
+                unless pkcolspec.empty?
+                  if pkcolspec != pkcolspec.slice(:id, :default)
+                    pkcolspec = { id: { type: pkcolspec.delete(:id), **pkcolspec }.compact }
+                  end
                   tbl.print ", #{format_colspec(pkcolspec)}"
                 end
               when Array
@@ -156,6 +158,8 @@ module ActiveRecord #:nodoc:
               stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
               stream.puts "#   #{e.message}"
               stream.puts
+            ensure
+              self.table_name = nil
             end
           end
 
@@ -176,10 +180,9 @@ module ActiveRecord #:nodoc:
 
           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')
+            @connection.select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name.upcase), bind_string("column_name", column_name.upcase)]).inspect
+              select /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ data_default from all_tab_columns
+              where owner = SYS_CONTEXT('userenv', 'current_schema')
               and table_name = :table_name
               and column_name = :column_name
             SQL