activerecord-oracle_enhanced-adapter 6.0.6 → 6.1.0.rc1

data/lib/arel/visitors/oracle.rb

@@ -0,0 +1,253 @@
+# 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
+            collector << "("
+            values.each_slice(in_clause_length).each_with_index do |valuez, i|
+              collector << " OR " unless i == 0
+              collector << column_name
+              collector << operator
+              collector << valuez.join(",")
+              collector << ")"
+            end
+            collector << ")"
+          end
+
+          collector
+        end
+
+        def visit_Arel_Nodes_In(o, collector)
+          attr, values = o.left, o.right
+
+          if Array === values
+            unless values.empty?
+              values.delete_if { |value| unboundable?(value) }
+            end
+
+            return collector << "1=0" if values.empty?
+          end
+
+          in_clause_length = @connection.in_clause_length
+
+          if !Array === values || values.length <= in_clause_length
+            visit(attr, collector) << " IN ("
+            visit(values, collector) << ")"
+          else
+            collector << "("
+            values.each_slice(in_clause_length).each_with_index do |valuez, i|
+              collector << " OR " unless i == 0
+              visit(attr, collector) << " IN ("
+              visit(valuez, collector) << ")"
+            end
+            collector << ")"
+          end
+        end
+
+        def visit_Arel_Nodes_NotIn(o, collector)
+          attr, values = o.left, o.right
+
+          if Array === values
+            unless values.empty?
+              values.delete_if { |value| unboundable?(value) }
+            end
+
+            return collector << "1=1" if values.empty?
+          end
+
+          in_clause_length = @connection.in_clause_length
+
+          if !Array === values || values.length <= in_clause_length
+            visit(attr, collector) << " NOT IN ("
+            visit(values, collector) << ")"
+          else
+            values.each_slice(in_clause_length).each_with_index do |valuez, i|
+              collector << " AND " unless i == 0
+              visit(attr, collector) << " NOT IN ("
+              visit(valuez, 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
+
+        ###
+        # 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
+    end
+  end
+end

data/lib/arel/visitors/oracle12.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class Oracle12 < Arel::Visitors::ToSql
+      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) }
+          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
+            collector << "("
+            values.each_slice(in_clause_length).each_with_index do |valuez, i|
+              collector << " OR " unless i == 0
+              collector << column_name
+              collector << operator
+              collector << valuez.join(",")
+              collector << ")"
+            end
+            collector << ")"
+          end
+
+          collector
+        end
+
+        def visit_Arel_Nodes_In(o, collector)
+          attr, values = o.left, o.right
+
+          if Array === values
+            unless values.empty?
+              values.delete_if { |value| unboundable?(value) }
+            end
+
+            return collector << "1=0" if values.empty?
+          end
+
+          in_clause_length = @connection.in_clause_length
+
+          if !Array === values || values.length <= in_clause_length
+            visit(attr, collector) << " IN ("
+            visit(values, collector) << ")"
+          else
+            collector << "("
+            values.each_slice(in_clause_length).each_with_index do |valuez, i|
+              collector << " OR " unless i == 0
+              visit(attr, collector) << " IN ("
+              visit(valuez, collector) << ")"
+            end
+            collector << ")"
+          end
+        end
+
+        def visit_Arel_Nodes_NotIn(o, collector)
+          attr, values = o.left, o.right
+
+          if Array === values
+            unless values.empty?
+              values.delete_if { |value| unboundable?(value) }
+            end
+
+            return collector << "1=1" if values.empty?
+          end
+
+          in_clause_length = @connection.in_clause_length
+
+          if !Array === values || values.length <= in_clause_length
+            visit(attr, collector) << " NOT IN ("
+            visit(values, collector) << ")"
+          else
+            values.each_slice(in_clause_length).each_with_index do |valuez, i|
+              collector << " AND " unless i == 0
+              visit(attr, collector) << " NOT IN ("
+              visit(valuez, 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 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
+    end
+  end
+end

data/spec/active_record/connection_adapters/oracle_enhanced/connection_spec.rb

@@ -40,6 +40,12 @@ describe "OracleEnhancedAdapter establish connection" do
     ActiveRecord::Base.establish_connection(SYSTEM_CONNECTION_PARAMS.merge(cursor_sharing: :exact))
     expect(ActiveRecord::Base.connection.select_value("select value from v$parameter where name = 'cursor_sharing'")).to eq("EXACT")
   end
+
+  it "should connect to database using service_name" do
+    ActiveRecord::Base.establish_connection(SERVICE_NAME_CONNECTION_PARAMS)
+    expect(ActiveRecord::Base.connection).not_to be_nil
+    expect(ActiveRecord::Base.connection.class).to eq(ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter)
+  end
 end
 
 describe "OracleEnhancedConnection" do
@@ -81,13 +87,13 @@ describe "OracleEnhancedConnection" do
       expect(ActiveRecord::Base.connection).to be_active
     end
 
-    it "should swith to specified schema" do
+    it "should switch to specified schema" do
       ActiveRecord::Base.establish_connection(CONNECTION_WITH_SCHEMA_PARAMS)
       expect(ActiveRecord::Base.connection.current_schema).to eq(CONNECTION_WITH_SCHEMA_PARAMS[:schema].upcase)
       expect(ActiveRecord::Base.connection.current_user).to eq(CONNECTION_WITH_SCHEMA_PARAMS[:username].upcase)
     end
 
-    it "should swith to specified schema after reset" do
+    it "should switch to specified schema after reset" do
       ActiveRecord::Base.connection.reset!
       expect(ActiveRecord::Base.connection.current_schema).to eq(CONNECTION_WITH_SCHEMA_PARAMS[:schema].upcase)
     end
@@ -180,7 +186,7 @@ describe "OracleEnhancedConnection" do
   describe "with slash-prefixed database name (service name)" do
     before(:all) do
       params = CONNECTION_PARAMS.dup
-      params[:database] = "/#{params[:database]}" unless params[:database].match(/^\//)
+      params[:database] = "/#{params[:database]}" unless params[:database].start_with?("/")
       @conn = ActiveRecord::ConnectionAdapters::OracleEnhanced::Connection.create(params)
     end