Respect the database's CURSOR_SHARING setting by default

Stops the adapter from issuing `ALTER SESSION SET cursor_sharing = force`
at session login. Introduces :default as the new effective default for
the :cursor_sharing connection option; with :default (or unset) the
adapter does not run any ALTER SESSION and the database's instance-level
setting is what the session sees. Explicit values ('exact', 'force')
continue to issue the corresponding ALTER SESSION.

Oracle's documented software default for CURSOR_SHARING is EXACT
(https://docs.oracle.com/en/database/oracle/oracle-database/26/refrn/CURSOR_SHARING.html).
Most installations have not changed it, and many users have not been
aware that oracle_enhanced has been silently overriding it to FORCE at
the session level since 2009 (commit ebb60f3).

The implicit `force` made sense at the time it was added: ActiveRecord
did not yet bind literals, so the adapter sent SQL with literals inlined
and `force` was the only way the server could collapse that into a
single shared cursor. That premise no longer holds:

  * The AbstractAdapter default for prepared_statements is true since
    Rails 7.1 (rails/rails#45945, commit a0fd15ee7e), inherited by
    oracle_enhanced. Application SQL is bound at the AR layer, so 'force'
    has nothing left to rewrite for that traffic.
  * All all_* / user_* dictionary queries inside oracle_enhanced are
    now bind-driven (rsim#2629 finished the last four), so dictionary
    access doesn't depend on 'force' for shared-cursor reuse either.
  * Keeping 'force' on by default also keeps connections exposed to the
    rsim#2619 hang combination on amd64 Oracle Database (cached cursor +
    a literal the server rewrites + RETURNING ... INTO). rsim#2620 already
    removed the exposure for the typical Rails ORM path; dropping the
    implicit force default removes it for raw-SQL callers as well.

After this PR, sessions run with whatever CURSOR_SHARING the database
is configured with — for almost all installations that means Oracle's
documented default EXACT, which is what users were already (unknowingly)
running on the server side. The adapter simply stops imposing its own
value on top.

Anyone who relied on FORCE — typically connections still configured
with prepared_statements: false, where AR interpolates application-SQL
literals at the visitor level — can opt back in with
cursor_sharing: 'force' in database.yml.

Tests use a separate SYSTEM AR connection (SystemObserver) only to read
v$parameter / v$ses_optimizer_env (normalized to upper-case to match
across the two views); the test sessions themselves use the regular
CONNECTION_PARAMS user.

Refs rsim#2622.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: yahonda

lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -99,7 +99,17 @@ module ConnectionAdapters # :nodoc:
     # * <tt>:privilege</tt> - set "SYSDBA" if you want to connect with this privilege
     # * <tt>:allow_concurrency</tt> - set to "true" if non-blocking mode should be enabled (just for OCI client)
     # * <tt>:prefetch_rows</tt> - how many rows should be fetched at one time to increase performance, defaults to 100
-    # * <tt>:cursor_sharing</tt> - cursor sharing mode to minimize amount of unique statements, no default value
+    # * <tt>:cursor_sharing</tt> - cursor sharing mode. Accepts "exact" or "force"
+    #   (per Oracle's documented values), or <tt>:default</tt> (the new effective default).
+    #   With <tt>:default</tt> (or unset) the adapter does not run <tt>ALTER SESSION SET
+    #   cursor_sharing</tt> and the database's instance-level setting (Oracle's documented
+    #   software default is <tt>EXACT</tt>) is what the session sees. Pass an explicit
+    #   value to issue the corresponding <tt>ALTER SESSION</tt>.
+    #
+    #   NOTE: Connections still configured with <tt>prepared_statements: false</tt> have AR
+    #   interpolate application-SQL literals at the visitor level, so each unique value
+    #   produces a fresh shared cursor on the server. Such installs can keep the legacy
+    #   behavior by setting <tt>:cursor_sharing => 'force'</tt> explicitly here.
     # * <tt>:time_zone</tt> - database session time zone
     #   (it is recommended to set it using ENV['TZ'] which will be then also used for database session time zone)
     # * <tt>:schema</tt> - database schema which holds schema objects.
@@ -856,11 +866,14 @@ def check_version # :nodoc:
       private def configure_connection
         super
 
-        cursor_sharing = (@config[:cursor_sharing] || "force").to_s.upcase
-        unless CURSOR_SHARING_VALUES.include?(cursor_sharing)
-          raise ArgumentError, "Invalid :cursor_sharing value #{@config[:cursor_sharing].inspect}; allowed: #{CURSOR_SHARING_VALUES.join(', ')}"
+        cursor_sharing = @config[:cursor_sharing]
+        unless cursor_sharing.nil? || cursor_sharing == :default
+          cursor_sharing = cursor_sharing.to_s.upcase
+          unless CURSOR_SHARING_VALUES.include?(cursor_sharing)
+            raise ArgumentError, "Invalid :cursor_sharing value #{@config[:cursor_sharing].inspect}; allowed: #{CURSOR_SHARING_VALUES.join(', ')} or :default"
+          end
+          execute("alter session set cursor_sharing = #{cursor_sharing}", "SCHEMA")
         end
-        execute("alter session set cursor_sharing = #{cursor_sharing}", "SCHEMA")
 
         if ORACLE_ENHANCED_CONNECTION == :oci
           time_zone = @config[:time_zone] || ENV["TZ"]

spec/active_record/connection_adapters/oracle_enhanced/connection_spec.rb

@@ -36,20 +36,58 @@
     expect(ActiveRecord::Base.lease_connection).to be_active
   end
 
-  it "should use database default cursor_sharing parameter value force by default" do
-    # Use `SYSTEM_CONNECTION_PARAMS` to query v$parameter
-    ActiveRecord::Base.establish_connection(SYSTEM_CONNECTION_PARAMS)
-    expect(ActiveRecord::Base.lease_connection.select_value("select value from v$parameter where name = 'cursor_sharing'")).to eq("FORCE")
-  end
+  describe "cursor_sharing" do
+    # The test session uses CONNECTION_PARAMS (regular oracle_enhanced user,
+    # no v$ access); SystemObserver is a separate AR connection on SYSTEM used
+    # only to read v$parameter / v$ses_optimizer_env for assertions.
+    class SystemObserver < ActiveRecord::Base
+      self.abstract_class = true
+    end
 
-  it "should use modified cursor_sharing value exact" do
-    ActiveRecord::Base.establish_connection(SYSTEM_CONNECTION_PARAMS.merge(cursor_sharing: :exact))
-    expect(ActiveRecord::Base.lease_connection.select_value("select value from v$parameter where name = 'cursor_sharing'")).to eq("EXACT")
-  end
+    before(:each) { SystemObserver.establish_connection(SYSTEM_CONNECTION_PARAMS) }
+    after(:each)  { SystemObserver.remove_connection rescue nil }
+
+    let(:server_default_cursor_sharing) do
+      SystemObserver.connection.select_value(
+        "select upper(value) from v$parameter where name = 'cursor_sharing'"
+      )
+    end
 
-  it "should raise ArgumentError for an unsupported cursor_sharing value" do
-    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS.merge(cursor_sharing: "not_a_valid_mode"))
-    expect { ActiveRecord::Base.lease_connection }.to raise_error(ArgumentError, /Invalid :cursor_sharing value/)
+    # v$ses_optimizer_env returns the value lowercase; v$parameter returns it
+    # uppercase. Normalize to uppercase so comparisons are stable across views.
+    def session_cursor_sharing(connection)
+      sid = connection.select_value("select sys_context('userenv', 'sid') from dual").to_i
+      SystemObserver.connection.select_value(
+        "select upper(value) from v$ses_optimizer_env where sid = #{sid} and name = 'cursor_sharing'"
+      )
+    end
+
+    it "does not run ALTER SESSION when :cursor_sharing is unset" do
+      expected = server_default_cursor_sharing
+      ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+      expect(session_cursor_sharing(ActiveRecord::Base.lease_connection)).to eq(expected)
+    end
+
+    it "does not run ALTER SESSION when :cursor_sharing is :default" do
+      expected = server_default_cursor_sharing
+      ActiveRecord::Base.establish_connection(CONNECTION_PARAMS.merge(cursor_sharing: :default))
+      expect(session_cursor_sharing(ActiveRecord::Base.lease_connection)).to eq(expected)
+    end
+
+    it "applies the explicit :cursor_sharing value when set to :force" do
+      ActiveRecord::Base.establish_connection(CONNECTION_PARAMS.merge(cursor_sharing: :force))
+      expect(session_cursor_sharing(ActiveRecord::Base.lease_connection)).to eq("FORCE")
+    end
+
+    it "applies the explicit :cursor_sharing value when set to :exact" do
+      ActiveRecord::Base.establish_connection(CONNECTION_PARAMS.merge(cursor_sharing: :exact))
+      expect(session_cursor_sharing(ActiveRecord::Base.lease_connection)).to eq("EXACT")
+    end
+
+    it "raises ArgumentError for an unsupported cursor_sharing value" do
+      ActiveRecord::Base.establish_connection(CONNECTION_PARAMS.merge(cursor_sharing: "not_a_valid_mode"))
+      expect { ActiveRecord::Base.lease_connection }.to raise_error(ArgumentError, /Invalid :cursor_sharing value/)
+    end
   end
 
   it "should not use JDBC statement caching" do