activerecord-oracle_enhanced-adapter 6.0.4 → 6.1.1

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

@@ -4,6 +4,8 @@ module ActiveRecord
   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

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -30,6 +30,9 @@
 # contribution.
 # portions Copyright 2005 Graham Jenkins
 
+require "arel/visitors/oracle"
+require "arel/visitors/oracle12"
+require "active_record/connection_adapters"
 require "active_record/connection_adapters/abstract_adapter"
 require "active_record/connection_adapters/statement_pool"
 require "active_record/connection_adapters/oracle_enhanced/connection"
@@ -213,13 +216,24 @@ module ActiveRecord
       cattr_accessor :use_shorter_identifier
       self.use_shorter_identifier = false
 
+      ##
+      # :singleton-method:
+      # By default, OracleEnhanced adapter will grant unlimited tablespace, create session, create table, create view,
+      # and create sequence when running the rake task db:create.
+      #
+      # If you wish to change these permissions you can add the following line to your initializer file:
+      #
+      #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.permissions =
+      #   ["create session", "create table", "create view", "create sequence", "create trigger", "ctxapp"]
+      cattr_accessor :permissions
+      self.permissions = ["create session", "create table", "create view", "create sequence"]
+
       ##
       # :singleton-method:
       # Specify default sequence start with value (by default 1 if not explicitly set), e.g.:
 
       class StatementPool < ConnectionAdapters::StatementPool
         private
-
           def dealloc(stmt)
             stmt.close
           end
@@ -238,6 +252,14 @@ module ActiveRecord
         ADAPTER_NAME
       end
 
+      # Oracle enhanced adapter has no implementation because
+      # Oracle Database cannot detect `NoDatabaseError`.
+      # Please refer to the following discussion for details.
+      # https://github.com/rsim/oracle-enhanced/pull/1900
+      def self.database_exists?(config)
+        raise NotImplementedError
+      end
+
       def arel_visitor # :nodoc:
         if supports_fetch_first_n_rows_and_offset?
           Arel::Visitors::Oracle12.new(self)
@@ -266,6 +288,10 @@ module ActiveRecord
         true
       end
 
+      def supports_common_table_expressions?
+        true
+      end
+
       def supports_views?
         true
       end
@@ -438,6 +464,7 @@ module ActiveRecord
       end
 
       def discard!
+        super
         @connection = nil
       end
 
@@ -449,9 +476,9 @@ module ActiveRecord
       # when inserting a new database record (see #prefetch_primary_key?).
       def next_sequence_value(sequence_name)
         # if sequence_name is set to :autogenerated then it means that primary key will be populated by trigger
-        raise ArgumentError "Trigger based primary key is not supported" if sequence_name == AUTOGENERATED_SEQUENCE_NAME
+        raise ArgumentError.new "Trigger based primary key is not supported" if sequence_name == AUTOGENERATED_SEQUENCE_NAME
         # call directly connection method to avoid prepared statement which causes fetching of next sequence value twice
-        select_value(<<~SQL.squish, "next sequence value")
+        select_value(<<~SQL.squish, "SCHEMA")
           SELECT #{quote_table_name(sequence_name)}.NEXTVAL FROM dual
         SQL
       end
@@ -489,7 +516,7 @@ module ActiveRecord
         end
 
         if primary_key && sequence_name
-          new_start_value = select_value(<<~SQL.squish, "new start value")
+          new_start_value = select_value(<<~SQL.squish, "SCHEMA")
             select NVL(max(#{quote_column_name(primary_key)}),0) + 1 from #{quote_table_name(table_name)}
           SQL
 
@@ -500,33 +527,33 @@ module ActiveRecord
 
       # Current database name
       def current_database
-        select_value(<<~SQL.squish, "current database on CDB ")
+        select_value(<<~SQL.squish, "SCHEMA")
           SELECT SYS_CONTEXT('userenv', 'con_name') FROM dual
         SQL
       rescue ActiveRecord::StatementInvalid
-        select_value(<<~SQL.squish, "current database")
+        select_value(<<~SQL.squish, "SCHEMA")
           SELECT SYS_CONTEXT('userenv', 'db_name') FROM dual
         SQL
       end
 
       # Current database session user
       def current_user
-        select_value(<<~SQL.squish, "current user")
+        select_value(<<~SQL.squish, "SCHEMA")
           SELECT SYS_CONTEXT('userenv', 'session_user') FROM dual
         SQL
       end
 
       # Current database session schema
       def current_schema
-        select_value(<<~SQL.squish, "current schema")
+        select_value(<<~SQL.squish, "SCHEMA")
           SELECT SYS_CONTEXT('userenv', 'current_schema') FROM dual
         SQL
       end
 
       # Default tablespace name of current user
       def default_tablespace
-        select_value(<<~SQL.squish, "default tablespace")
-          SELECT LOWER(default_tablespace) FROM user_users
+        select_value(<<~SQL.squish, "SCHEMA")
+          SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ LOWER(default_tablespace) FROM user_users
           WHERE username = SYS_CONTEXT('userenv', 'current_schema')
         SQL
       end
@@ -534,8 +561,8 @@ module ActiveRecord
       def column_definitions(table_name)
         (owner, desc_table_name) = @connection.describe(table_name)
 
-        select_all(<<~SQL.squish, "Column definitions")
-          SELECT cols.column_name AS name, cols.data_type AS sql_type,
+        select_all(<<~SQL.squish, "SCHEMA")
+          SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ cols.column_name AS name, cols.data_type AS sql_type,
                  cols.data_default, cols.nullable, cols.virtual_column, cols.hidden_column,
                  cols.data_type_owner AS sql_type_owner,
                  DECODE(cols.data_type, 'NUMBER', data_precision,
@@ -566,16 +593,16 @@ module ActiveRecord
       def pk_and_sequence_for(table_name, owner = nil, desc_table_name = nil) #:nodoc:
         (owner, desc_table_name) = @connection.describe(table_name)
 
-        seqs = select_values(<<~SQL.squish, "Sequence")
-          select us.sequence_name
+        seqs = select_values(<<~SQL.squish, "SCHEMA")
+          select /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ us.sequence_name
           from all_sequences us
           where us.sequence_owner = '#{owner}'
           and us.sequence_name = upper(#{quote(default_sequence_name(desc_table_name))})
         SQL
 
         # changed back from user_constraints to all_constraints for consistency
-        pks = select_values(<<~SQL.squish, "Primary Key")
-          SELECT cc.column_name
+        pks = select_values(<<~SQL.squish, "SCHEMA")
+          SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ cc.column_name
             FROM all_constraints c, all_cons_columns cc
            WHERE c.owner = '#{owner}'
              AND c.table_name = #{quote(desc_table_name)}
@@ -608,8 +635,8 @@ module ActiveRecord
       def primary_keys(table_name) # :nodoc:
         (_owner, desc_table_name) = @connection.describe(table_name)
 
-        pks = select_values(<<~SQL.squish, "Primary Keys", [bind_string("table_name", desc_table_name)])
-          SELECT cc.column_name
+        pks = select_values(<<~SQL.squish, "SCHEMA", [bind_string("table_name", desc_table_name)])
+          SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ cc.column_name
             FROM all_constraints c, all_cons_columns cc
            WHERE c.owner = SYS_CONTEXT('userenv', 'current_schema')
              AND c.table_name = :table_name
@@ -628,7 +655,7 @@ module ActiveRecord
         #
         # It does not construct DISTINCT clause. Just return column names for distinct.
         order_columns = orders.reject(&:blank?).map { |s|
-            s = s.to_sql unless s.is_a?(String)
+            s = visitor.compile(s) unless s.is_a?(String)
             # remove any ASC/DESC modifiers
             s.gsub(/\s+(ASC|DESC)\s*?/i, "")
           }.reject(&:blank?).map.with_index { |column, i|
@@ -638,8 +665,9 @@ module ActiveRecord
       end
 
       def temporary_table?(table_name) #:nodoc:
-        select_value(<<~SQL.squish, "temporary table", [bind_string("table_name", table_name.upcase)]) == "Y"
-          SELECT temporary FROM all_tables WHERE table_name = :table_name and owner = SYS_CONTEXT('userenv', 'current_schema')
+        select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name.upcase)]) == "Y"
+          SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */
+          temporary FROM all_tables WHERE table_name = :table_name and owner = SYS_CONTEXT('userenv', 'current_schema')
         SQL
       end
 
@@ -746,3 +774,18 @@ require "active_record/connection_adapters/oracle_enhanced/version"
 module ActiveRecord
   autoload :OracleEnhancedProcedures, "active_record/connection_adapters/oracle_enhanced/procedures"
 end
+
+# Workaround for https://github.com/jruby/jruby/issues/6267
+if RUBY_ENGINE == "jruby"
+  require "jruby"
+
+  class org.jruby::RubyObjectSpace::WeakMap
+    field_reader :map
+  end
+
+  class ObjectSpace::WeakMap
+    def values
+      JRuby.ref(self).map.values.reject(&:nil?)
+    end
+  end
+end

data/lib/active_record/type/oracle_enhanced/boolean.rb

@@ -5,7 +5,6 @@ module ActiveRecord
     module OracleEnhanced
       class Boolean < ActiveModel::Type::Boolean # :nodoc:
         private
-
           def cast_value(value)
             # Kind of adding 'n' and 'N' to  `FALSE_VALUES`
             if ["n", "N"].include?(value)

data/lib/active_record/type/oracle_enhanced/integer.rb

@@ -5,7 +5,6 @@ module ActiveRecord
     module OracleEnhanced
       class Integer < ActiveModel::Type::Integer # :nodoc:
         private
-
           def max_value
             ("9" * 38).to_i
           end

data/lib/arel/visitors/oracle.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class Oracle < Arel::Visitors::ToSql
+      private
+        def visit_Arel_Nodes_SelectStatement(o, collector)
+          o = order_hacks(o)
+
+          # if need to select first records without ORDER BY and GROUP BY and without DISTINCT
+          # then can use simple ROWNUM in WHERE clause
+          if o.limit && o.orders.empty? && o.cores.first.groups.empty? && !o.offset && !o.cores.first.set_quantifier.class.to_s.match?(/Distinct/)
+            o.cores.last.wheres.push Nodes::LessThanOrEqual.new(
+              Nodes::SqlLiteral.new("ROWNUM"), o.limit.expr
+            )
+            return super
+          end
+
+          if o.limit && o.offset
+            o        = o.dup
+            limit    = o.limit.expr
+            offset   = o.offset
+            o.offset = nil
+            collector << "
+                SELECT * FROM (
+                  SELECT raw_sql_.*, rownum raw_rnum_
+                  FROM ("
+
+            collector = super(o, collector)
+
+            if offset.expr.is_a? Nodes::BindParam
+              collector << ") raw_sql_ WHERE rownum <= ("
+              collector = visit offset.expr, collector
+              collector << " + "
+              collector = visit limit, collector
+              collector << ") ) WHERE raw_rnum_ > "
+              collector = visit offset.expr, collector
+              return collector
+            else
+              collector << ") raw_sql_
+                  WHERE rownum <= #{offset.expr.to_i + limit}
+                )
+                WHERE "
+              return visit(offset, collector)
+            end
+          end
+
+          if o.limit
+            o       = o.dup
+            limit   = o.limit.expr
+            collector << "SELECT * FROM ("
+            collector = super(o, collector)
+            collector << ") WHERE ROWNUM <= "
+            return visit limit, collector
+          end
+
+          if o.offset
+            o        = o.dup
+            offset   = o.offset
+            o.offset = nil
+            collector << "SELECT * FROM (
+                  SELECT raw_sql_.*, rownum raw_rnum_
+                  FROM ("
+            collector = super(o, collector)
+            collector << ") raw_sql_
+                )
+                WHERE "
+            return visit offset, collector
+          end
+
+          super
+        end
+
+        def visit_Arel_Nodes_Limit(o, collector)
+          collector
+        end
+
+        def visit_Arel_Nodes_Offset(o, collector)
+          collector << "raw_rnum_ > "
+          visit o.expr, collector
+        end
+
+        def visit_Arel_Nodes_Except(o, collector)
+          collector << "( "
+          collector = infix_value o, collector, " MINUS "
+          collector << " )"
+        end
+
+        ##
+        # To avoid ORA-01795: maximum number of expressions in a list is 1000
+        # tell ActiveRecord to limit us to 1000 ids at a time
+        def visit_Arel_Nodes_HomogeneousIn(o, collector)
+          in_clause_length = @connection.in_clause_length
+          values = o.casted_values.map { |v| @connection.quote(v) }
+          column_name = quote_table_name(o.table_name) + "." + quote_column_name(o.column_name)
+          operator =
+            if o.type == :in
+              " IN ("
+            else
+              " NOT IN ("
+            end
+
+          if !Array === values || values.length <= in_clause_length
+            collector << column_name
+            collector << operator
+
+            expr =
+              if values.empty?
+                @connection.quote(nil)
+              else
+                values.join(",")
+              end
+
+            collector << expr
+            collector << ")"
+          else
+            separator =
+              if o.type == :in
+                " OR "
+              else
+                " AND "
+              end
+            collector << "("
+            values.each_slice(in_clause_length).each_with_index do |valuez, i|
+              collector << separator unless i == 0
+              collector << column_name
+              collector << operator
+              collector << valuez.join(",")
+              collector << ")"
+            end
+            collector << ")"
+          end
+
+          collector
+        end
+
+        def visit_Arel_Nodes_UpdateStatement(o, collector)
+          # Oracle does not allow ORDER BY/LIMIT in UPDATEs.
+          if o.orders.any? && o.limit.nil?
+            # However, there is no harm in silently eating the ORDER BY clause if no LIMIT has been provided,
+            # otherwise let the user deal with the error
+            o = o.dup
+            o.orders = []
+          end
+
+          super
+        end
+
+        ###
+        # Hacks for the order clauses specific to Oracle
+        def order_hacks(o)
+          return o if o.orders.empty?
+          return o unless o.cores.any? do |core|
+            core.projections.any? do |projection|
+              /FIRST_VALUE/ === projection
+            end
+          end
+          # Previous version with join and split broke ORDER BY clause
+          # if it contained functions with several arguments (separated by ',').
+          #
+          # orders   = o.orders.map { |x| visit x }.join(', ').split(',')
+          orders   = o.orders.map do |x|
+            string = visit(x, Arel::Collectors::SQLString.new).value
+            if string.include?(",")
+              split_order_string(string)
+            else
+              string
+            end
+          end.flatten
+          o.orders = []
+          orders.each_with_index do |order, i|
+            o.orders <<
+              Nodes::SqlLiteral.new("alias_#{i}__#{' DESC' if /\bdesc$/i.match?(order)}")
+          end
+          o
+        end
+
+        # Split string by commas but count opening and closing brackets
+        # and ignore commas inside brackets.
+        def split_order_string(string)
+          array = []
+          i = 0
+          string.split(",").each do |part|
+            if array[i]
+              array[i] << "," << part
+            else
+              # to ensure that array[i] will be String and not Arel::Nodes::SqlLiteral
+              array[i] = part.to_s
+            end
+            i += 1 if array[i].count("(") == array[i].count(")")
+          end
+          array
+        end
+
+        def visit_Arel_Nodes_BindParam(o, collector)
+          collector.add_bind(o.value) { |i| ":a#{i}" }
+        end
+
+        def is_distinct_from(o, collector)
+          collector << "DECODE("
+          collector = visit [o.left, o.right, 0, 1], collector
+          collector << ")"
+        end
+
+        # Oracle will occur an error `ORA-00907: missing right parenthesis`
+        # when using `ORDER BY` in `UPDATE` or `DELETE`'s subquery.
+        #
+        # This method has been overridden based on the following code.
+        # https://github.com/rails/rails/blob/v6.1.0.rc1/activerecord/lib/arel/visitors/to_sql.rb#L815-L825
+        def build_subselect(key, o)
+          stmt             = super
+          stmt.orders      = [] # `orders` will never be set to prevent `ORA-00907`.
+          stmt
+        end
+    end
+  end
+end