Changeset 64589

Timestamp:

10/20/2026 05:49:16 AM (25 hours ago)

Author:

westonruter

Message:

Posts, Post Types: Add pre_wp_count_attachments filter.

Introduces the pre_wp_count_attachments filter to wp_count_attachments(), the counterpart of pre_wp_count_posts. Returning a stdClass object short-circuits the function, skipping the object cache lookup and both of its queries. Since the counts cache group is non-persistent, those queries otherwise run on every request that needs the counts, and on a site with millions of attachments the GROUP BY post_mime_type aggregate alone can take several seconds. The filter allows the counts to be served instead from a value pre-computed in the background.

Unlike post statuses, the set of MIME types is not known ahead of time, so only a missing trash count is filled in with zero. The filtered value should therefore contain a count for every MIME type matching $mime_type, and only those types. As with pre_wp_count_posts, the value is not cached and is passed through the wp_count_attachments filter.

The pre_wp_count_posts filter introduced in r64245 is brought in line with the new one. A filtered value now short-circuits only when it is a stdClass object: any other non-null value was previously cast to an object, turning false into a nonsensical result, and filling in missing counts on another class can trigger a dynamic property deprecation. Both filters also clone the returned object, so that a callback which keeps it, such as in a static variable, does not have it modified by core or by later callbacks on the wp_count_posts and wp_count_attachments filters.

Developed in ​https://github.com/WordPress/wordpress-develop/pull/14210.
Follow-up to r64245.

Props jdeep, westonruter, peterwilsoncc.
See #66098.
Fixes #66291.

Location:

trunk

Files:

• src/wp-includes/post.php (modified) (3 diffs)
• tests/phpunit/tests/post/wpCountAttachments.php (modified) (1 diff)
• tests/phpunit/tests/post/wpCountPosts.php (modified) (2 diffs)

trunk/src/wp-includes/post.php

@@ -3545 +3545 @@
          * Filters the post counts before the query is run.
          *
-         * Returning a non-null value short-circuits wp_count_posts(), skipping both
-         * the object cache lookup and the database query. This allows the counts to
-         * be served from another source, such as a value pre-computed in the
-         * background, when an exact real-time count is not required.
-         *
-         * Any registered post status missing from the filtered value are added
+         * Returning a stdClass object short-circuits wp_count_posts(), skipping
+         * both the object cache lookup and the database query. This allows the
+         * counts to be served from another source, such as a value pre-computed in
+         * the background, when an exact real-time count is not required.
+         *
+         * Any registered post status missing from the filtered value is added
          * to the result and set to zero.
          *
@@ -3566 +3566 @@
         $counts = apply_filters( 'pre_wp_count_posts', null, $type, $perm );
 
-        if ( null !== $counts ) {
-                $counts = (object) $counts;
+        if ( $counts instanceof stdClass ) {
+                $counts = clone $counts;
 
                 foreach ( get_post_stati() as $status ) {
@@ -3669 +3669 @@
 function wp_count_attachments( $mime_type = '' ) {
         global $wpdb;
+
+        /**
+         * Filters the attachment counts before the query is run.
+         *
+         * Returning a stdClass object short-circuits wp_count_attachments(),
+         * skipping both the object cache lookup and the database queries. This
+         * allows the counts to be served from another source, such as a value
+         * pre-computed in the background, when an exact real-time count is not
+         * required.
+         *
+         * If the filtered value does not contain a trash count, one is added to the
+         * result and set to zero. Missing MIME types are not added, as they depend on
+         * the attachments that exist. The filtered value should therefore contain a
+         * count for every MIME type matching `$mime_type` that has attachments,
+         * including types first uploaded after the value was computed, as callers
+         * may read the count for any MIME type that exists. It should also contain
+         * only MIME types matching `$mime_type`, with a trash count limited to
+         * attachments of those types, as the default query does.
+         *
+         * The returned value is not cached and passed through the
+         * {@see 'wp_count_attachments'} filter.
+         *
+         * @since 7.2.0
+         *
+         * @param stdClass|null   $counts    An object containing the attachment counts by
+         *                                   mime type, or null to run the default query.
+         *                                   Default null.
+         * @param string|string[] $mime_type Array or comma-separated list of MIME patterns.
+         */
+        $counts = apply_filters( 'pre_wp_count_attachments', null, $mime_type );
+
+        if ( $counts instanceof stdClass ) {
+                $counts = clone $counts;
+
+                if ( ! isset( $counts->trash ) ) {
+                        $counts->trash = 0;
+                }
+
+                /** This filter is documented in wp-includes/post.php */
+                return apply_filters( 'wp_count_attachments', $counts, $mime_type );
+        }
 
         $cache_key = sprintf(

trunk/tests/phpunit/tests/post/wpCountAttachments.php

@@ -32 +32 @@
                 $this->assertEquals( $expected, $actual );
         }
+
+        /**
+         * @ticket 66291
+         */
+        public function test_pre_wp_count_attachments_short_circuits_query() {
+                self::factory()->post->create_many(
+                        3,
+                        array(
+                                'post_type'      => 'attachment',
+                                'post_mime_type' => 'image/jpeg',
+                        )
+                );
+
+                $mime_type  = 'image/jpeg';
+                $mock_count = 42;
+                add_filter(
+                        'pre_wp_count_attachments',
+                        static function () use ( $mime_type, $mock_count ) {
+                                return (object) array( $mime_type => $mock_count );
+                        }
+                );
+
+                $start_num_queries = get_num_queries();
+                $counts            = wp_count_attachments();
+
+                $this->assertSame( 0, get_num_queries() - $start_num_queries, 'No database query should run when the filter returns a value.' );
+                $this->assertObjectHasProperty( $mime_type, $counts );
+                $this->assertSame( $mock_count, $counts->$mime_type, 'Count is expected to be filtered value.' );
+                $this->assertObjectHasProperty( 'trash', $counts );
+                $this->assertSame( 0, $counts->trash, 'Expected trash to be set to zero.' );
+        }
+
+        /**
+         * @ticket 66291
+         */
+        public function test_pre_wp_count_attachments_takes_precedence_over_cached_counts() {
+                self::factory()->post->create_many(
+                        3,
+                        array(
+                                'post_type'      => 'attachment',
+                                'post_mime_type' => 'image/jpeg',
+                        )
+                );
+
+                wp_count_attachments();
+                $this->assertNotFalse( wp_cache_get( 'attachments', 'counts' ), 'Expected the counts to be cached before the filter is added.' );
+
+                $mime_type  = 'image/jpeg';
+                $mock_count = 42;
+                add_filter(
+                        'pre_wp_count_attachments',
+                        static function () use ( $mime_type, $mock_count ) {
+                                return (object) array( $mime_type => $mock_count );
+                        }
+                );
+
+                $this->assertSame( $mock_count, wp_count_attachments()->$mime_type, 'The filtered value should be returned instead of the cached counts.' );
+        }
+
+        /**
+         * @ticket 66291
+         */
+        public function test_pre_wp_count_attachments_null_runs_default_query() {
+                self::factory()->post->create_many(
+                        3,
+                        array(
+                                'post_type'      => 'attachment',
+                                'post_mime_type' => 'image/jpeg',
+                        )
+                );
+
+                add_filter( 'pre_wp_count_attachments', '__return_null' );
+                $start_num_queries = get_num_queries();
+
+                $this->assertSame( '3', wp_count_attachments()->{'image/jpeg'}, 'Attachment count is expected to be set.' );
+                $this->assertGreaterThan( 0, get_num_queries() - $start_num_queries, 'wp_count_attachments() is expected to trigger database queries.' );
+        }
+
+        /**
+         * @ticket 66291
+         *
+         * @dataProvider data_non_stdclass_values
+         *
+         * @param mixed $value Filtered value.
+         */
+        public function test_pre_wp_count_attachments_non_stdclass_runs_default_query( $value ) {
+                self::factory()->post->create_many(
+                        3,
+                        array(
+                                'post_type'      => 'attachment',
+                                'post_mime_type' => 'image/jpeg',
+                        )
+                );
+
+                add_filter(
+                        'pre_wp_count_attachments',
+                        static function () use ( $value ) {
+                                return $value;
+                        }
+                );
+                $start_num_queries = get_num_queries();
+
+                $this->assertSame( '3', wp_count_attachments()->{'image/jpeg'}, 'A filtered value that is not a stdClass object is expected to be ignored.' );
+                $this->assertGreaterThan( 0, get_num_queries() - $start_num_queries, 'wp_count_attachments() is expected to trigger database queries.' );
+        }
+
+        /**
+         * Data provider for {@see self::test_pre_wp_count_attachments_non_stdclass_runs_default_query()}.
+         *
+         * @return array<non-falsy-string, array{ 0: mixed }>
+         */
+        public function data_non_stdclass_values(): array {
+                return array(
+                        'array'       => array( array( 'image/jpeg' => 42 ) ),
+                        'false'       => array( false ),
+                        'ArrayObject' => array( new ArrayObject( array( 'image/jpeg' => 42 ) ) ),
+                );
+        }
+
+        /**
+         * @ticket 66291
+         */
+        public function test_pre_wp_count_attachments_receives_mime_type() {
+                $filter = new MockAction();
+                add_filter( 'pre_wp_count_attachments', array( $filter, 'filter' ), 10, 2 );
+
+                wp_count_attachments( array( 'image/jpeg', 'image/png' ) );
+
+                $args = $filter->get_args();
+                $this->assertSame( array( null, array( 'image/jpeg', 'image/png' ) ), $args[0] );
+        }
+
+        /**
+         * @ticket 66291
+         */
+        public function test_pre_wp_count_attachments_keeps_filtered_trash_count() {
+                $trash_count = 7;
+                add_filter(
+                        'pre_wp_count_attachments',
+                        static function () use ( $trash_count ) {
+                                return (object) array( 'trash' => $trash_count );
+                        }
+                );
+
+                $this->assertSame( $trash_count, wp_count_attachments()->trash, 'Expected trash count to be the filtered value.' );
+        }
+
+        /**
+         * @ticket 66291
+         */
+        public function test_pre_wp_count_attachments_value_is_passed_to_wp_count_attachments_filter() {
+                add_filter(
+                        'pre_wp_count_attachments',
+                        static function () {
+                                return (object) array( 'image/jpeg' => 5 );
+                        }
+                );
+                $filter = new MockAction();
+                add_filter( 'wp_count_attachments', array( $filter, 'filter' ), 10, 2 );
+
+                wp_count_attachments( 'image' );
+
+                $args = $filter->get_args();
+                $this->assertSame( 1, $filter->get_call_count(), 'Expected the wp_count_attachments filter to run once.' );
+                $this->assertEquals(
+                        array(
+                                (object) array(
+                                        'image/jpeg' => 5,
+                                        'trash'      => 0,
+                                ),
+                                'image',
+                        ),
+                        $args[0],
+                        'Expected the wp_count_attachments filter to receive the filtered counts and MIME type.'
+                );
+        }
+
+        /**
+         * @ticket 66291
+         */
+        public function test_pre_wp_count_attachments_does_not_modify_filtered_object() {
+                $stored_counts = (object) array( 'image/jpeg' => 5 );
+                add_filter(
+                        'pre_wp_count_attachments',
+                        static function () use ( $stored_counts ) {
+                                return $stored_counts;
+                        }
+                );
+
+                $counts = wp_count_attachments();
+
+                $this->assertSame( 0, $counts->trash, 'Expected trash to be set to zero.' );
+                $this->assertEquals( (object) array( 'image/jpeg' => 5 ), $stored_counts, 'The object returned by the filter should not be modified.' );
+        }
+
+        /**
+         * @ticket 66291
+         */
+        public function test_pre_wp_count_attachments_result_is_not_cached() {
+                self::factory()->post->create_many(
+                        3,
+                        array(
+                                'post_type'      => 'attachment',
+                                'post_mime_type' => 'image/jpeg',
+                        )
+                );
+
+                $filter = static function () {
+                        return (object) array( 'image/jpeg' => 99 );
+                };
+                add_filter( 'pre_wp_count_attachments', $filter );
+
+                $this->assertSame( 99, wp_count_attachments( 'image/jpeg' )->{'image/jpeg'}, 'Expected the filtered count.' );
+                $this->assertFalse( wp_cache_get( 'attachments:image_jpeg', 'counts' ), 'Expected the filtered counts not to be cached.' );
+
+                remove_filter( 'pre_wp_count_attachments', $filter );
+                $start_num_queries = get_num_queries();
+
+                $this->assertSame( '3', wp_count_attachments( 'image/jpeg' )->{'image/jpeg'}, 'Expected the real count once the filter is removed.' );
+                $this->assertGreaterThan( 0, get_num_queries() - $start_num_queries, 'Expected database queries since nothing should have been cached.' );
+        }
 }

trunk/tests/phpunit/tests/post/wpCountPosts.php

@@ -45 +45 @@
         /**
          * @ticket 66098
+         *
+         * @dataProvider data_non_stdclass_values
+         *
+         * @param mixed $value Filtered value.
+         */
+        public function test_pre_wp_count_posts_non_stdclass_runs_default_query( $value ) {
+                self::factory()->post->create_many( 3 );
+
+                add_filter(
+                        'pre_wp_count_posts',
+                        static function () use ( $value ) {
+                                return $value;
+                        }
+                );
+                $start_num_queries = get_num_queries();
+
+                $this->assertSame( '3', wp_count_posts()->publish, 'A filtered value that is not a stdClass object is expected to be ignored.' );
+                $this->assertGreaterThan( 0, get_num_queries() - $start_num_queries, 'wp_count_posts() is expected to trigger database queries.' );
+        }
+
+        /**
+         * Data provider for {@see self::test_pre_wp_count_posts_non_stdclass_runs_default_query()}.
+         *
+         * @return array<non-falsy-string, array{ 0: mixed }>
+         */
+        public function data_non_stdclass_values(): array {
+                return array(
+                        'array'       => array( array( 'publish' => 42 ) ),
+                        'false'       => array( false ),
+                        'ArrayObject' => array( new ArrayObject( array( 'publish' => 42 ) ) ),
+                );
+        }
+
+        /**
+         * @ticket 66098
          */
         public function test_pre_wp_count_posts_receives_type_and_perm() {
@@ -106 +141 @@
          * @ticket 66098
          */
+        public function test_pre_wp_count_posts_value_is_passed_to_wp_count_posts_filter() {
+                add_filter(
+                        'pre_wp_count_posts',
+                        static function () {
+                                return (object) array( 'publish' => 5 );
+                        }
+                );
+                $filter = new MockAction();
+                add_filter( 'wp_count_posts', array( $filter, 'filter' ), 10, 3 );
+
+                wp_count_posts( 'page', 'readable' );
+
+                $expected_counts = (object) array_merge(
+                        array_fill_keys( get_post_stati(), 0 ),
+                        array( 'publish' => 5 )
+                );
+
+                $args = $filter->get_args();
+                $this->assertSame( 1, $filter->get_call_count(), 'Expected the wp_count_posts filter to run once.' );
+                $this->assertEquals( array( $expected_counts, 'page', 'readable' ), $args[0], 'Expected the wp_count_posts filter to receive the filtered counts, type, and permission.' );
+        }
+
+        /**
+         * @ticket 66098
+         */
+        public function test_pre_wp_count_posts_does_not_modify_filtered_object() {
+                $stored_counts = (object) array( 'publish' => 5 );
+                add_filter(
+                        'pre_wp_count_posts',
+                        static function () use ( $stored_counts ) {
+                                return $stored_counts;
+                        }
+                );
+
+                $counts = wp_count_posts();
+
+                $this->assertSame( 0, $counts->draft, 'A status missing from the filtered value should default to 0.' );
+                $this->assertEquals( (object) array( 'publish' => 5 ), $stored_counts, 'The object returned by the filter should not be modified.' );
+        }
+
+        /**
+         * @ticket 66098
+         */
         public function test_pre_wp_count_posts_result_is_not_cached() {
-                add_filter(
-                        'pre_wp_count_posts',
-                        static function () {
-                                return (object) array( 'publish' => 99 );
-                        }
-                );
-
-                wp_count_posts();
-
-                $this->assertFalse( wp_cache_get( _count_posts_cache_key( 'post' ), 'counts' ) );
+                self::factory()->post->create_many( 3 );
+
+                $filter = static function () {
+                        return (object) array( 'publish' => 99 );
+                };
+                add_filter( 'pre_wp_count_posts', $filter );
+
+                $this->assertSame( 99, wp_count_posts()->publish, 'Expected the filtered count.' );
+                $this->assertFalse( wp_cache_get( _count_posts_cache_key( 'post' ), 'counts' ), 'Expected the filtered counts not to be cached.' );
+
+                remove_filter( 'pre_wp_count_posts', $filter );
+                $start_num_queries = get_num_queries();
+
+                $this->assertSame( '3', wp_count_posts()->publish, 'Expected the real count once the filter is removed.' );
+                $this->assertGreaterThan( 0, get_num_queries() - $start_num_queries, 'Expected database queries since nothing should have been cached.' );
         }
 }