activerecord-oracle_enhanced-adapter 8.1.0-java

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    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)
+              false
+            else
+              super
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_model/type/string"
+
+module ActiveRecord
+  module Type
+    module OracleEnhanced
+      class CharacterString < ActiveRecord::Type::OracleEnhanced::String # :nodoc:
+        def serialize(value)
+          return unless value
+          Data.new(super, self.limit)
+        end
+
+        class Data # :nodoc:
+          def initialize(value, limit)
+            @value = value
+            @limit = limit
+          end
+
+          def to_s
+            @value
+          end
+
+          def to_character_str
+            len = @value.to_s.length
+            if len < @limit
+              "%-#{@limit}s" % @value
+            else
+              @value
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    module OracleEnhanced
+      class Integer < ActiveModel::Type::Integer # :nodoc:
+        private
+          def max_value
+            ("9" * 38).to_i
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    module OracleEnhanced
+      class Json < ActiveRecord::Type::Json
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "active_model/type/string"
+
+module ActiveRecord
+  module Type
+    module OracleEnhanced
+      class NationalCharacterString < ActiveRecord::Type::OracleEnhanced::String # :nodoc:
+        def serialize(value)
+          return unless value
+          Data.new(super)
+        end
+
+        class Data # :nodoc:
+          def initialize(value)
+            @value = value
+          end
+
+          def to_s
+            @value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_model/type/string"
+
+module ActiveRecord
+  module Type
+    module OracleEnhanced
+      class NationalCharacterText < ActiveRecord::Type::Text # :nodoc:
+        def type
+          :ntext
+        end
+
+        def changed_in_place?(raw_old_value, new_value)
+          # TODO: Needs to find a way not to cast here.
+          raw_old_value = cast(raw_old_value)
+          super
+        end
+
+        def serialize(value)
+          return unless value
+          Data.new(super)
+        end
+
+        class Data # :nodoc:
+          def initialize(value)
+            @value = value
+          end
+
+          def to_s
+            @value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_model/type/string"
+
+module ActiveRecord
+  module Type
+    module OracleEnhanced
+      class Raw < ActiveModel::Type::String # :nodoc:
+        def type
+          :raw
+        end
+
+        def serialize(value)
+          # Encode a string or byte array as string of hex codes
+          if value.nil?
+            super
+          else
+            value = value.unpack("C*")
+            value.map { |x| "%02X" % x }.join
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "active_model/type/string"
+
+module ActiveRecord
+  module Type
+    module OracleEnhanced
+      class String < ActiveModel::Type::String # :nodoc:
+        def changed?(old_value, new_value, _new_value_before_type_cast)
+          if old_value.nil?
+            new_value = nil if new_value == ""
+            old_value != new_value
+          else
+            super
+          end
+        end
+
+        def changed_in_place?(raw_old_value, new_value)
+          if raw_old_value.nil?
+            new_value = nil if new_value == ""
+            raw_old_value != new_value
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "active_model/type/string"
+
+module ActiveRecord
+  module Type
+    module OracleEnhanced
+      class Text < ActiveRecord::Type::Text # :nodoc:
+        def changed_in_place?(raw_old_value, new_value)
+          # TODO: Needs to find a way not to cast here.
+          raw_old_value = cast(raw_old_value)
+          super
+        end
+
+        def serialize(value)
+          return unless value
+          Data.new(super)
+        end
+
+        class Data # :nodoc:
+          def initialize(value)
+            @value = value
+          end
+
+          def to_s
+            @value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    module OracleEnhanced
+      class TimestampLtz < ActiveRecord::Type::DateTime
+        def type
+          :timestampltz
+        end
+
+        class Data < DelegateClass(::Time) # :nodoc:
+        end
+
+        def serialize(value)
+          case value = super
+          when ::Time
+            Data.new(value)
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    module OracleEnhanced
+      class TimestampTz < ActiveRecord::Type::DateTime
+        def type
+          :timestamptz
+        end
+
+        class Data < DelegateClass(::Time) # :nodoc:
+        end
+
+        def serialize(value)
+          case value = super
+          when ::Time
+            Data.new(value)
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activerecord-oracle_enhanced-adapter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+if defined?(Rails)
+  module ActiveRecord
+    module ConnectionAdapters
+      class OracleEnhancedRailtie < ::Rails::Railtie
+        rake_tasks do
+          load "active_record/connection_adapters/oracle_enhanced/database_tasks.rb"
+        end
+
+        ActiveSupport.on_load(:active_record) do
+          require "active_record/connection_adapters/oracle_enhanced_adapter"
+
+          if ActiveRecord::ConnectionAdapters.respond_to?(:register)
+            ActiveRecord::ConnectionAdapters.register(
+              "oracle_enhanced",
+              "ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter",
+              "active_record/connection_adapters/oracle_enhanced_adapter"
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arel/visitors/oracle.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require_relative "oracle_common"
+
+module Arel # :nodoc: all
+  module Visitors
+    class Oracle < Arel::Visitors::ToSql
+      include OracleCommon
+
+      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.type.is_a? ActiveModel::Type::Value
+              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.value_before_type_cast + limit.value_before_type_cast}
+                )
+                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) }
+          operator =
+            if o.type == :in
+              " IN ("
+            else
+              " NOT IN ("
+            end
+
+          if !Array === values || values.length <= in_clause_length
+            visit o.left, collector
+            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
+              visit o.left, collector
+              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 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

data/lib/arel/visitors/oracle12.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "oracle_common"
+
+module Arel # :nodoc: all
+  module Visitors
+    class Oracle12 < Arel::Visitors::ToSql
+      include OracleCommon
+
+      private
+        def visit_Arel_Nodes_SelectStatement(o, collector)
+          # Oracle does not allow LIMIT clause with select for update
+          if o.limit && o.lock
+            raise ArgumentError, <<~MSG
+              Combination of limit and lock is not supported. Because generated SQL statements
+              `SELECT FOR UPDATE and FETCH FIRST n ROWS` generates ORA-02014.
+            MSG
+          end
+          super
+        end
+
+        def visit_Arel_Nodes_SelectOptions(o, collector)
+          collector = maybe_visit o.offset, collector
+          collector = maybe_visit o.limit, collector
+          maybe_visit o.lock, collector
+        end
+
+        def visit_Arel_Nodes_Limit(o, collector)
+          collector << "FETCH FIRST "
+          collector = visit o.expr, collector
+          collector << " ROWS ONLY"
+        end
+
+        def visit_Arel_Nodes_Offset(o, collector)
+          collector << "OFFSET "
+          visit o.expr, collector
+          collector << " ROWS"
+        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) }
+          operator =
+            if o.type == :in
+              " IN ("
+            else
+              " NOT IN ("
+            end
+
+          if !Array === values || values.length <= in_clause_length
+            visit o.left, collector
+            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
+              visit o.left, collector
+              collector << operator
+              collector << valuez.join(",")
+              collector << ")"
+            end
+            collector << ")"
+          end
+        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
+
+        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