activerecord-oracle_enhanced-adapter 6.0.0.rc3 → 6.1.0.rc1

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

@@ -18,13 +18,12 @@ module ActiveRecord #:nodoc:
         module ClassMethods
           def lob_columns
             columns.select do |column|
-              column.sql_type_metadata.sql_type =~ /LOB$/
+              column.sql_type_metadata.sql_type.end_with?("LOB")
             end
           end
         end
 
         private
-
           def enhanced_write_lobs
             if self.class.connection.is_a?(ConnectionAdapters::OracleEnhancedAdapter) &&
                 !(self.class.custom_create_method || self.class.custom_update_method)

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

@@ -97,6 +97,10 @@ module ActiveRecord
           @raw_connection.exec(sql, *bindvars, &block)
         end
 
+        def with_retry(&block)
+          @raw_connection.with_retry(&block)
+        end
+
         def prepare(sql)
           Cursor.new(self, @raw_connection.parse(sql))
         end
@@ -265,7 +269,6 @@ module ActiveRecord
         end
 
       private
-
         def date_without_time?(value)
           case value
           when OraDate
@@ -319,9 +322,9 @@ module ActiveRecord
           # connection using host, port and database name
           elsif host || port
             host ||= "localhost"
-            host = "[#{host}]" if host =~ /^[^\[].*:/  # IPv6
+            host = "[#{host}]" if /^[^\[].*:/.match?(host)  # IPv6
             port ||= 1521
-            database = "/#{database}" unless database.match(/^\//)
+            database = "/#{database}" unless database.start_with?("/")
             "//#{host}:#{port}#{database}"
           # if no host is specified then assume that
           # database parameter is TNS alias or TNS connection string
@@ -423,13 +426,11 @@ class OCI8EnhancedAutoRecover < DelegateClass(OCI8) #:nodoc:
   LOST_CONNECTION_ERROR_CODES = [ 28, 1012, 3113, 3114, 3135 ] #:nodoc:
 
   # Adds auto-recovery functionality.
-  #
-  # See: http://www.jiubao.org/ruby-oci8/api.en.html#label-11
-  def exec(sql, *bindvars, &block) #:nodoc:
+  def with_retry #:nodoc:
     should_retry = self.class.auto_retry? && autocommit?
 
     begin
-      @connection.exec(sql, *bindvars, &block)
+      yield
     rescue OCIException => e
       raise unless e.is_a?(OCIError) && LOST_CONNECTION_ERROR_CODES.include?(e.code)
       @active = false
@@ -439,5 +440,9 @@ class OCI8EnhancedAutoRecover < DelegateClass(OCI8) #:nodoc:
       retry
     end
   end
+
+  def exec(sql, *bindvars, &block) #:nodoc:
+    with_retry { @connection.exec(sql, *bindvars, &block) }
+  end
 end
 #:startdoc:

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

@@ -97,7 +97,6 @@ module ActiveRecord #:nodoc:
     end
 
     private
-
       # Creates a record with custom create method
       # and returns its id.
       def _create_record

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

@@ -132,8 +132,43 @@ module ActiveRecord
           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?
             /[a-z]/.match?(column_name) ? column_name : column_name.downcase
@@ -143,8 +178,8 @@ module ActiveRecord
   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
@@ -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

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

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

@@ -4,7 +4,15 @@ 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
@@ -51,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
@@ -72,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
 
@@ -107,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
@@ -168,7 +180,7 @@ module ActiveRecord #:nodoc:
 
           def extract_expression_for_virtual_column(column)
             column_name = column.name
-            @connection.select_value(<<~SQL.squish, "Table comment", [bind_string("table_name", table_name.upcase), bind_string("column_name", column_name.upcase)]).inspect
+            @connection.select_value(<<~SQL.squish, "SCHEMA", [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', 'current_schema')
               and table_name = :table_name

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

@@ -11,7 +11,7 @@ module ActiveRecord
         # see: abstract/schema_statements.rb
 
         def tables #:nodoc:
-          select_values(<<~SQL.squish, "tables")
+          select_values(<<~SQL.squish, "SCHEMA")
             SELECT DECODE(table_name, UPPER(table_name), LOWER(table_name), table_name)
             FROM all_tables
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -43,7 +43,7 @@ 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_values(<<~SQL.squish, "SCHEMA", [bind_string("owner", table_owner), bind_string("table_name", table_name)]).any?
             SELECT owner, table_name
             FROM all_tables
             WHERE owner = :owner
@@ -59,20 +59,20 @@ module ActiveRecord
         end
 
         def views # :nodoc:
-          select_values(<<~SQL.squish, "views")
+          select_values(<<~SQL.squish, "SCHEMA")
             SELECT 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_values(<<~SQL.squish, "SCHEMA")
             SELECT LOWER(mview_name) FROM all_mviews WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
         end
 
         # get synonyms for schema dump
         def synonyms
-          result = select_all(<<~SQL.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,7 +87,7 @@ 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)])
+          result = select_all(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name)])
             SELECT LOWER(i.table_name) AS table_name, LOWER(i.index_name) AS index_name, i.uniqueness,
               i.index_type, i.ityp_owner, i.ityp_name, i.parameters,
               LOWER(i.tablespace_name) AS tablespace_name,
@@ -117,7 +117,7 @@ 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
+                source = select_values(<<~SQL.squish, "SCHEMA", [bind_string("procedure_name", procedure_name.upcase)]).join
                   SELECT text
                   FROM all_source
                   WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -196,19 +196,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 +226,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 +237,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 +253,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,8 +292,8 @@ module ActiveRecord
           end
         end
 
-        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)
+        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"
             unless /\(.*\)/.match?(quoted_column_names)
@@ -306,13 +311,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 +326,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,7 +364,7 @@ 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")
+          result = select_value(<<~SQL.squish, "SCHEMA")
             SELECT 1 FROM all_indexes i
             WHERE i.owner = SYS_CONTEXT('userenv', 'current_schema')
                AND i.table_owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -402,14 +405,14 @@ module ActiveRecord
           execute "DROP SYNONYM #{quote_table_name(name)}"
         end
 
-        def add_reference(table_name, *args)
-          OracleEnhanced::ReferenceDefinition.new(*args).add_to(update_table_definition(table_name, self))
+        def add_reference(table_name, ref_name, **options)
+          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)
+          at.add_column(column_name, type, **options)
           add_column_sql = schema_creation.accept at
           add_column_sql << tablespace_for((type_to_sql(type).downcase.to_sym), nil, table_name, column_name)
           execute add_column_sql
@@ -440,7 +443,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
@@ -453,7 +456,7 @@ module ActiveRecord
           end
 
           td = create_table_definition(table_name)
-          cd = td.new_column_definition(column.name, type, options)
+          cd = td.new_column_definition(column.name, type, **options)
           change_column_stmt = schema_creation.accept cd
           change_column_stmt << tablespace_for((type_to_sql(type).downcase.to_sym), nil, options[:table_name], options[:column_name]) if type
           change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{change_column_stmt}"
@@ -494,8 +497,9 @@ 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_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name)])
             SELECT comments FROM all_tab_comments
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
               AND table_name = :table_name
@@ -511,7 +515,7 @@ 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_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name), bind_string("column_name", column_name.upcase)])
             SELECT comments FROM all_col_comments
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
               AND table_name = :table_name
@@ -528,7 +532,7 @@ module ActiveRecord
         end
 
         def tablespace(table_name)
-          select_value(<<~SQL.squish, "tablespace")
+          select_value(<<~SQL.squish, "SCHEMA")
             SELECT tablespace_name
             FROM all_tables
             WHERE table_name='#{table_name.to_s.upcase}'
@@ -540,7 +544,7 @@ 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)])
+          fk_info = select_all(<<~SQL.squish, "SCHEMA", [bind_string("desc_table_name", desc_table_name)])
             SELECT r.table_name to_table
                   ,rc.column_name references_column
                   ,cc.column_name
@@ -582,7 +586,7 @@ module ActiveRecord
         # REFERENTIAL INTEGRITY ====================================
 
         def disable_referential_integrity(&block) #:nodoc:
-          old_constraints = select_all(<<~SQL.squish, "Foreign Keys to disable and enable")
+          old_constraints = select_all(<<~SQL.squish, "SCHEMA")
             SELECT constraint_name, owner, table_name
               FROM all_constraints
               WHERE constraint_type = 'R'
@@ -614,13 +618,12 @@ module ActiveRecord
         end
 
         private
-
           def schema_creation
             OracleEnhanced::SchemaCreation.new self
           end
 
-          def create_table_definition(*args)
-            OracleEnhanced::TableDefinition.new(self, *args)
+          def create_table_definition(name, **options)
+            OracleEnhanced::TableDefinition.new(self, name, **options)
           end
 
           def new_column_from_field(table_name, field)
@@ -642,7 +645,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