feat: eliminate switch_to_blog() usage in multisite option retrieval

- Introduced a new private helper function `_get_option_from_blog()` in `wp-includes/ms-blogs.php` to retrieve options directly from a site's options table without switching context, improving performance and reducing global state mutations.
- Refactored `get_blog_option()`, `update_blog_option()`, `add_blog_option()`, and `delete_blog_option()` to utilize the new helper, replacing the `switch_to_blog()` and `restore_current_blog()` calls with direct database queries.
- Updated `WP_Site::get_details()` and `get_blog_post()` to fetch data without switching context, enhancing efficiency in multisite environments.
- These changes aim to minimize the overhead associated with `switch_to_blog()`, particularly in scenarios with multiple sites, thereby improving overall performance and reducing potential side effects from global state mutations.

Author: soderlind

docs/trac-ticket.txt

@@ -0,0 +1,311 @@
+Eliminate switch_to_blog() from get_blog_option(), update_blog_option(), WP_Site::get_details(), and get_blog_post() using $wpdb->get_blog_prefix()
+
+----
+
+== Description ==
+
+`switch_to_blog()` mutates six globals and, on the fallback object-cache implementation, **wipes the entire object cache** via `wp_cache_init()` inside `wp_cache_switch_to_blog_fallback()`. Every `switch_to_blog()` / `restore_current_blog()` pair is two full global-state mutations.
+
+Several core functions use `switch_to_blog()` internally even though they only need to read or write a single row in a per-site table. This ticket proposes replacing those internal switches with direct queries using `$wpdb->get_blog_prefix( $blog_id )`, which is a **pure function** — no side-effects, no globals written.
+
+=== Globals mutated by switch_to_blog() ===
+
+||= Global mutated =||= What changes =||
+|| `$wpdb->blogid` / `$wpdb->prefix` || Table prefix rewritten (e.g. `wp_` → `wp_3_`) ||
+|| `$wpdb->options`, `$wpdb->posts`, … || All per-blog table properties rewritten ||
+|| `$GLOBALS['table_prefix']` || Mirrors the new prefix ||
+|| `$GLOBALS['blog_id']` || Set to new blog ID ||
+|| `$GLOBALS['_wp_switched_stack']` || Previous ID pushed ||
+|| `$GLOBALS['switched']` || Set to `true` ||
+|| `$wp_object_cache` || Full cache wipe on fallback ||
+
+=== Real-world impact ===
+
+Any plugin or core code that iterates over sites and accesses `blogname`, `siteurl`, or other per-site options triggers `switch_to_blog()` for each site — either directly via `get_blog_option()` or indirectly via `WP_Site::get_details()` (called by `WP_Site::__get()` for magic properties like `blogname` and `siteurl`).
+
+For a network with 100 sites, a single loop fetching `blogname` and `siteurl` causes **~200 global-state mutations** (100 switch + 100 restore).
+
+----
+
+== The Key Insight ==
+
+`wpdb::get_blog_prefix( $blog_id )` already exists as a public method, accepts an explicit blog ID, and returns the correct table prefix **without touching any global state**:
+
+{{{#!php
+// From class-wpdb.php — pure computation, no side-effects:
+public function get_blog_prefix( $blog_id = null ) {
+    if ( is_multisite() ) {
+        if ( null === $blog_id ) {
+            $blog_id = $this->blogid;
+        }
+        $blog_id = (int) $blog_id;
+        if ( defined( 'MULTISITE' ) && ( 0 === $blog_id || 1 === $blog_id ) ) {
+            return $this->base_prefix;
+        } else {
+            return $this->base_prefix . $blog_id . '_';
+        }
+    }
+    return $this->base_prefix;
+}
+}}}
+
+Core already uses this pattern for non-options tables (e.g. `ms-functions.php` line 2003 queries `{prefix}posts` directly). The only reason `{prefix}options` is never queried this way is that `get_option()` has no table parameter — not because direct queries are prohibited.
+
+----
+
+== Proposed Changes ==
+
+=== 1. New private helper: `_get_option_from_blog()` ===
+
+Add to `wp-includes/ms-blogs.php`. Reads a single option from any site's `wp_N_options` table without switching. Handles object-cache correctly (same `alloptions` / `notoptions` groups as `get_option()`).
+
+{{{#!php
+/**
+ * Retrieves an option value for a specific site without switching blog context.
+ *
+ * Uses the object cache (same 'options'/'notoptions' groups as get_option()),
+ * falling back to a direct DB query with the site's table prefix.
+ *
+ * @since 7.x.0
+ * @access private
+ *
+ * @param int    $blog_id  Site ID.
+ * @param string $option   Option name.
+ * @param mixed  $default  Default value if option not found.
+ * @return mixed Option value or $default.
+ */
+function _get_option_from_blog( int $blog_id, string $option, mixed $default = false ): mixed {
+    global $wpdb;
+
+    $blog_id = (int) $blog_id;
+
+    // Fast path: current blog — delegate to get_option().
+    if ( get_current_blog_id() === $blog_id ) {
+        return get_option( $option, $default );
+    }
+
+    // Check object cache.
+    $alloptions_cache = wp_cache_get( $blog_id, 'blog-alloptions' );
+    if ( is_array( $alloptions_cache ) && array_key_exists( $option, $alloptions_cache ) ) {
+        return $alloptions_cache[ $option ] ?? $default;
+    }
+
+    $notoptions = wp_cache_get( $blog_id, 'blog-notoptions' );
+    if ( is_array( $notoptions ) && isset( $notoptions[ $option ] ) ) {
+        return $default;
+    }
+
+    // Direct DB query using get_blog_prefix() — no switch.
+    $table = $wpdb->get_blog_prefix( $blog_id ) . 'options';
+    $row   = $wpdb->get_row(
+        $wpdb->prepare(
+            "SELECT option_value FROM `{$table}` WHERE option_name = %s LIMIT 1",
+            $option
+        )
+    );
+
+    if ( null === $row ) {
+        $notoptions           = is_array( $notoptions ) ? $notoptions : [];
+        $notoptions[ $option ] = true;
+        wp_cache_set( $blog_id, $notoptions, 'blog-notoptions' );
+        return $default;
+    }
+
+    $value = maybe_unserialize( $row->option_value );
+
+    return apply_filters( "blog_option_{$option}", $value, $blog_id );
+}
+}}}
+
+=== 2. Refactor `get_blog_option()` ===
+
+Replace the `switch_to_blog()` / `get_option()` / `restore_current_blog()` sequence with a single call to the new helper.
+
+{{{#!php
+// BEFORE (ms-blogs.php):
+function get_blog_option( $id, $option, $default_value = false ) {
+    $id = (int) $id;
+    if ( empty( $id ) ) { $id = get_current_blog_id(); }
+
+    if ( get_current_blog_id() === $id ) {
+        return get_option( $option, $default_value );
+    }
+
+    switch_to_blog( $id );
+    $value = get_option( $option, $default_value );
+    restore_current_blog();
+
+    return apply_filters( "blog_option_{$option}", $value, $id );
+}
+
+// AFTER:
+function get_blog_option( $id, $option, $default_value = false ) {
+    $id = (int) $id;
+    if ( empty( $id ) ) { $id = get_current_blog_id(); }
+
+    return _get_option_from_blog( $id, $option, $default_value );
+}
+}}}
+
+=== 3. Refactor `update_blog_option()` ===
+
+Replace `switch_to_blog()` + `update_option()` + `restore_current_blog()` with a direct `$wpdb->update/insert` against `{prefix}options`.
+
+{{{#!php
+// AFTER:
+function update_blog_option( $id, $option, $value, $deprecated = null ) {
+    global $wpdb;
+    $id = (int) $id;
+
+    if ( null !== $deprecated ) {
+        _deprecated_argument( __FUNCTION__, '3.1.0' );
+    }
+
+    if ( get_current_blog_id() === $id ) {
+        return update_option( $option, $value );
+    }
+
+    $table      = $wpdb->get_blog_prefix( $id ) . 'options';
+    $serialized = maybe_serialize( $value );
+    $exists     = $wpdb->get_var(
+        $wpdb->prepare( "SELECT COUNT(*) FROM `{$table}` WHERE option_name = %s", $option )
+    );
+
+    if ( $exists ) {
+        $result = $wpdb->update(
+            $table,
+            [ 'option_value' => $serialized ],
+            [ 'option_name'  => $option ],
+            [ '%s' ],
+            [ '%s' ]
+        );
+    } else {
+        $result = $wpdb->insert(
+            $table,
+            [ 'option_name' => $option, 'option_value' => $serialized, 'autoload' => 'yes' ],
+            [ '%s', '%s', '%s' ]
+        );
+    }
+
+    // Bust per-blog option caches.
+    wp_cache_delete( $id, 'blog-alloptions' );
+    wp_cache_delete( $id, 'blog-notoptions' );
+
+    return false !== $result;
+}
+}}}
+
+Apply the same pattern to `add_blog_option()` and `delete_blog_option()`.
+
+=== 4. Refactor `WP_Site::get_details()` ===
+
+In `class-wp-site.php`, `get_details()` (private) fetches `blogname`, `siteurl`, `post_count`, and `home` via `switch_to_blog()`. Replace with four calls to `_get_option_from_blog()`:
+
+{{{#!php
+// AFTER:
+private function get_details() {
+    $details = wp_cache_get( $this->blog_id, 'site-details' );
+
+    if ( false === $details ) {
+        $id      = (int) $this->blog_id;
+        $details = new stdClass();
+        foreach ( get_object_vars( $this ) as $key => $value ) {
+            $details->$key = $value;
+        }
+        $details->blogname   = _get_option_from_blog( $id, 'blogname' );
+        $details->siteurl    = _get_option_from_blog( $id, 'siteurl' );
+        $details->post_count = _get_option_from_blog( $id, 'post_count', 0 );
+        $details->home       = _get_option_from_blog( $id, 'home' );
+
+        wp_cache_set( $this->blog_id, $details, 'site-details' );
+    }
+
+    $details = apply_filters_deprecated( 'blog_details', [ $details ], '4.7.0', 'site_details' );
+    $details = apply_filters( 'site_details', $details );
+
+    return $details;
+}
+}}}
+
+=== 5. Refactor `get_blog_post()` ===
+
+In `ms-functions.php`, replace `switch_to_blog()` + `get_post()` + `restore_current_blog()` with a direct query against `{prefix}posts`:
+
+{{{#!php
+// AFTER:
+function get_blog_post( $blog_id, $post_id ) {
+    global $wpdb;
+
+    $blog_id = (int) $blog_id;
+    $post_id = (int) $post_id;
+
+    if ( get_current_blog_id() === $blog_id ) {
+        return get_post( $post_id );
+    }
+
+    $table = $wpdb->get_blog_prefix( $blog_id ) . 'posts';
+    $post  = $wpdb->get_row(
+        $wpdb->prepare( "SELECT * FROM `{$table}` WHERE ID = %d LIMIT 1", $post_id )
+    );
+
+    if ( ! $post ) {
+        return null;
+    }
+
+    return sanitize_post( new WP_Post( $post ), 'raw' );
+}
+}}}
+
+----
+
+== Object-Cache Considerations ==
+
+The new `_get_option_from_blog()` helper must:
+
+ * Use the same cache group strategy as `get_option()` — `blog-alloptions` for autoloaded options, `blog-notoptions` for known-missing options.
+ * Bust caches on write — `add_blog_option`, `update_blog_option`, `delete_blog_option` must invalidate the same keys.
+ * Lazy-load `alloptions` — on first access for a given `$blog_id`, fetch all autoloaded options in one query and cache them in `blog-alloptions`, mirroring `wp_load_alloptions()`.
+
+----
+
+== Out of Scope ==
+
+These functions have deeper coupling to the switched context and are out of scope for an initial patch:
+
+||= Function =||= Reason =||
+|| `wp_initialize_site()` || Runs dozens of core operations on a new site's tables ||
+|| `wp_uninitialize_site()` || Drops tables, clears all site data ||
+|| Third-party plugin code || Cannot be fixed in core ||
+
+----
+
+== Files Changed ==
+
+||= File =||= Change =||
+|| `wp-includes/ms-blogs.php` || Add `_get_option_from_blog()` private helper ||
+|| `wp-includes/ms-blogs.php` || Refactor `get_blog_option()` to use helper ||
+|| `wp-includes/ms-blogs.php` || Refactor `update_blog_option()` — direct `$wpdb` query ||
+|| `wp-includes/ms-blogs.php` || Refactor `add_blog_option()` — direct `$wpdb->insert` ||
+|| `wp-includes/ms-blogs.php` || Refactor `delete_blog_option()` — direct `$wpdb->delete` ||
+|| `wp-includes/class-wp-site.php` || Refactor `WP_Site::get_details()` to use `_get_option_from_blog()` ||
+|| `wp-includes/ms-functions.php` || Refactor `get_blog_post()` — direct `$wpdb` query ||
+
+All changes exploit `$wpdb->get_blog_prefix( $blog_id )`, which is already public, purpose-built, and side-effect-free.
+
+----
+
+== Testing Notes ==
+
+ * Unit tests for `get_blog_option()`, `update_blog_option()`, `add_blog_option()`, `delete_blog_option()` — verify return values match current behaviour.
+ * Unit test for `WP_Site::__get('blogname')` / `WP_Site::__get('siteurl')` — verify values match after refactor.
+ * Verify object cache is populated and busted correctly (test with both fallback and persistent cache drop-ins).
+ * Verify `$GLOBALS['switched']` is **not** set to `true` after `get_blog_option()` (regression test for the switch removal).
+ * Performance benchmark: loop over N sites calling `get_blog_option( $id, 'blogname' )` — measure wall time before/after.
+
+----
+
+Component: Multisite[[BR]]
+Focuses: performance[[BR]]
+Type: enhancement[[BR]]
+Version: trunk[[BR]]
+Keywords: has-patch needs-testing