Move visit_Arel_Nodes_UpdateStatement into Arel::Visitors::OracleCommon

The implementation in oracle.rb and oracle12.rb was byte-identical:
both strip ORDER BY from an UPDATE that has orders but no limit
(Oracle does not allow ORDER BY in UPDATE), and dup the statement
before mutating so the caller's AST stays intact. Moving the method
into OracleCommon removes the duplication and keeps the UPDATE/DELETE
ORDER BY handling alongside the IN-list variants already there.

Adds a direct visitor spec at
spec/active_record/connection_adapters/oracle_enhanced/arel/update_statement_spec.rb
covering each branch:

- UPDATE with orders and no limit strips ORDER BY before super emits SQL.
- UPDATE with orders and a limit keeps ORDER BY (Oracle returns the
  error at execute time; the visitor does not try to smooth that over).
- The original UpdateStatement's `orders` attribute is unmodified
  after compilation (dup-before-mutate is preserved).
- Arel::Visitors::Oracle (legacy ROWNUM) and Oracle12 produce the
  same stripped SQL.

Refs #2663 (task B).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: yahonda

lib/arel/visitors/oracle.rb

@@ -107,18 +107,6 @@ def value_before_type_cast(expr)
           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

lib/arel/visitors/oracle12.rb

@@ -55,18 +55,6 @@ def visit_Arel_Nodes_Except(o, collector)
           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
-
         def is_distinct_from(o, collector)
           collector << "DECODE("
           collector = visit [o.left, o.right, 0, 1], collector

lib/arel/visitors/oracle_common.rb

@@ -145,6 +145,18 @@ def visit_Arel_Nodes_HomogeneousIn(o, collector)
           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
+
         def visit_Arel_Nodes_In(o, collector)
           attr, values = o.left, o.right
           return super unless values.is_a?(Array)

spec/active_record/connection_adapters/oracle_enhanced/arel/update_statement_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+RSpec.describe "Arel::Visitors::OracleCommon#visit_Arel_Nodes_UpdateStatement" do
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+  end
+
+  before(:each) do
+    @visitor = Arel::Visitors::Oracle12.new(ActiveRecord::Base.connection)
+    @table = Arel::Table.new(:users)
+  end
+
+  def compile(node, visitor: @visitor)
+    visitor.accept(node, Arel::Collectors::SQLString.new).value
+  end
+
+  def build_update(orders: [], limit: nil)
+    stmt = Arel::Nodes::UpdateStatement.new
+    stmt.relation = @table
+    stmt.values = [Arel::Nodes::Assignment.new(@table[:name], Arel.sql("'foo'"))]
+    stmt.orders = orders
+    stmt.limit = limit
+    stmt
+  end
+
+  it "drops ORDER BY when no LIMIT is set" do
+    stmt = build_update(orders: [Arel.sql("id ASC")])
+    sql = compile(stmt)
+    expect(sql).not_to match(/ORDER BY/i)
+  end
+
+  it "keeps ORDER BY when a LIMIT is set (letting Oracle return the execute-time error)" do
+    stmt = build_update(orders: [Arel.sql("id ASC")], limit: Arel::Nodes::Limit.new(10))
+    sql = compile(stmt)
+    expect(sql).to match(/ORDER BY\s+id ASC/i)
+  end
+
+  it "leaves the original UpdateStatement's orders unmodified" do
+    orders = [Arel.sql("id ASC")]
+    stmt = build_update(orders: orders)
+    compile(stmt)
+    expect(stmt.orders).to eq(orders)
+  end
+
+  it "strips ORDER BY the same way via Arel::Visitors::Oracle" do
+    oracle = Arel::Visitors::Oracle.new(ActiveRecord::Base.connection)
+    stmt = build_update(orders: [Arel.sql("id ASC")])
+    sql = compile(stmt, visitor: oracle)
+    expect(sql).not_to match(/ORDER BY/i)
+  end
+end