Changeset 60941

Timestamp:

10/15/2025 11:56:57 PM (11 months ago)

Author:

peterwilsoncc

Message:

Users: Add caching to count_many_users_posts().

Introduces object caching to the count_many_users_posts() function.

Argument equivalency is checked prior to generating the cache key to ensure that the same cache is hit regardless of array order for users and post types. For example count_many_users_posts( [ 1, 2 ] ) will hit the same cache as count_many_users_posts( [ 2, 1 ] ).

Props adamsilverstein, flixos90, kalpeshh, rollybueno, sachinrajcp123, shailu25, sirlouen, spacedmonkey, westonruter, wildworks.
Fixes #63045.

Location:

trunk

Files:

• src/wp-includes/user.php (modified) (3 diffs)
• tests/phpunit/tests/user.php (modified) (2 diffs)

trunk/src/wp-includes/user.php

@@ -650 +650 @@
  *
  * @since 3.0.0
+ * @since 6.9.0 The results are now cached.
  *
  * @global wpdb $wpdb WordPress database abstraction object.
@@ -656 +657 @@
  * @param string|string[] $post_type   Optional. Single post type or array of post types to check. Defaults to 'post'.
  * @param bool            $public_only Optional. Only return counts for public posts.  Defaults to false.
- * @return string[] Amount of posts each user has written, as strings, keyed by user ID.
+ * @return array<int, string> Amount of posts each user has written, as strings, keyed by user ID.
  */
 function count_many_users_posts( $users, $post_type = 'post', $public_only = false ) {
@@ -683 +684 @@
         }
 
-        $userlist = implode( ',', array_map( 'absint', $users ) );
-        $where    = get_posts_by_author_sql( $post_type, true, null, $public_only );
-
-        $result = $wpdb->get_results( "SELECT post_author, COUNT(*) FROM $wpdb->posts $where AND post_author IN ($userlist) GROUP BY post_author", ARRAY_N );
-
-        $count = array_fill_keys( $users, 0 );
-        foreach ( $result as $row ) {
-                $count[ $row[0] ] = $row[1];
+        // Cleanup the users array. Remove duplicates and sort for consistent ordering.
+        $users = array_unique( array_filter( array_map( 'intval', $users ) ) );
+        sort( $users );
+
+        // Cleanup the post type argument. Remove duplicates and sort for consistent ordering.
+        $post_type = array_unique( (array) $post_type );
+        sort( $post_type );
+
+        $userlist    = implode( ',', $users );
+        $where       = get_posts_by_author_sql( $post_type, true, null, $public_only );
+        $query       = "SELECT post_author, COUNT(*) FROM $wpdb->posts $where AND post_author IN ($userlist) GROUP BY post_author";
+        $cache_key   = 'count_many_users_posts:' . md5( $query );
+        $cache_salts = array( wp_cache_get_last_changed( 'posts' ), wp_cache_get_last_changed( 'users' ) );
+        $count       = wp_cache_get_salted( $cache_key, 'post-queries', $cache_salts );
+
+        if ( false === $count ) {
+                $where  = get_posts_by_author_sql( $post_type, true, null, $public_only );
+                $result = $wpdb->get_results( "SELECT post_author, COUNT(*) FROM $wpdb->posts $where AND post_author IN ($userlist) GROUP BY post_author", ARRAY_N );
+
+                $count = array_fill_keys( $users, 0 );
+                foreach ( $result as $row ) {
+                        $count[ $row[0] ] = $row[1];
+                }
+
+                wp_cache_set_salted( $cache_key, $count, 'post-queries', $cache_salts, HOUR_IN_SECONDS );
         }
 

trunk/tests/phpunit/tests/user.php

@@ -574 +574 @@
         /**
          * @ticket 21431
+         *
+         * @covers ::count_many_users_posts
          */
         public function test_count_many_users_posts() {
@@ -603 +605 @@
                 $this->assertSame( '1', $counts[ self::$author_id ] );
                 $this->assertSame( '1', $counts[ $user_id_b ] );
+        }
+
+        /**
+         * Ensure the second and subsequent calls to count_many_users_posts() are cached.
+         *
+         * @ticket 63045
+         *
+         * @covers ::count_many_users_posts
+         */
+        public function test_count_many_users_posts_is_cached() {
+                $user_1 = self::$user_ids[0];
+                $user_2 = self::$user_ids[1];
+
+                // Create posts for both users.
+                self::factory()->post->create( array( 'post_author' => $user_1 ) );
+                self::factory()->post->create( array( 'post_author' => $user_2 ) );
+
+                // Warm the cache.
+                $count1 = count_many_users_posts( array( $user_1, $user_2 ), 'post', false );
+
+                // Ensure cache is hit for second call.
+                $start_queries = get_num_queries();
+                $count2        = count_many_users_posts( array( $user_1, $user_2 ), 'post', false );
+                $end_queries   = get_num_queries();
+                $this->assertSame( 0, $end_queries - $start_queries, 'No database queries expected for second call to count_many_users_posts()' );
+                $this->assertSameSetsWithIndex( $count1, $count2, 'Expected same results from both calls to count_many_users_posts()' );
+        }
+
+        /**
+         * Ensure equivalent arguments hit the same cache in count_many_users_posts().
+         *
+         * @ticket 63045
+         *
+         * @covers ::count_many_users_posts
+         *
+         * @dataProvider data_count_many_users_posts_cached_for_equivalent_arguments
+         *
+         * @param array $first_args  First set of arguments to pass to count_many_users_posts().
+         * @param array $second_args Second set of arguments to pass to count_many_users_posts().
+         */
+        public function test_count_many_users_posts_cached_for_equivalent_arguments( $first_args, $second_args ) {
+                // Replace placeholder user IDs with real ones.
+                $first_args[0]  = array_map(
+                        static function ( $user ) {
+                                return self::$user_ids[ $user ];
+                        },
+                        $first_args[0]
+                );
+                $second_args[0] = array_map(
+                        static function ( $user ) {
+                                return self::$user_ids[ $user ];
+                        },
+                        $second_args[0]
+                );
+
+                // Warm the cache with the first set of arguments.
+                $count1 = count_many_users_posts( ...$first_args );
+
+                // Ensure the cache is hit for the second set of equivalent arguments.
+                $start_queries = get_num_queries();
+                $count2        = count_many_users_posts( ...$second_args );
+                $end_queries   = get_num_queries();
+                $this->assertSame( 0, $end_queries - $start_queries, 'No database queries expected for second call to count_many_users_posts() with equivalent arguments' );
+                $this->assertSameSetsWithIndex( $count1, $count2, 'Expected same results from both calls to count_many_users_posts()' );
+        }
+
+        /**
+         * Data provider for test_count_many_users_posts_cached_for_equivalent_arguments().
+         *
+         * @return array[] Data provider.
+         */
+        public function data_count_many_users_posts_cached_for_equivalent_arguments(): array {
+                return array(
+                        'single post string vs array'  => array(
+                                array( array( 0 ), 'post' ),
+                                array( array( 0 ), array( 'post' ) ),
+                        ),
+                        'duplicate post type in array' => array(
+                                array( array( 0 ), array( 'post', 'post' ) ),
+                                array( array( 0 ), array( 'post' ) ),
+                        ),
+                        'different post type order'    => array(
+                                array( array( 0 ), array( 'post', 'page' ) ),
+                                array( array( 0 ), array( 'page', 'post' ) ),
+                        ),
+                        'duplicate user IDs in array'  => array(
+                                array( array( 0, 1, 1 ), 'post' ),
+                                array( array( 0, 1 ), 'post' ),
+                        ),
+                        'different user order'         => array(
+                                array( array( 0, 1 ), 'post' ),
+                                array( array( 1, 0 ), 'post' ),
+                        ),
+                        'integer vs string user IDs'   => array(
+                                array( array( 0, 1 ), 'post' ),
+                                array( array( '0', '1' ), 'post' ),
+                        ),
+                );
+        }
+
+        /**
+         * Test cache invalidation for count_many_users_posts().
+         *
+         * @ticket 63045
+         *
+         * @covers ::count_many_users_posts
+         */
+        public function test_count_many_users_posts_cache_invalidation() {
+                $user_1 = self::$user_ids[0];
+                $user_2 = self::$user_ids[1];
+
+                // Create posts for both users.
+                self::factory()->post->create( array( 'post_author' => $user_1 ) );
+                self::factory()->post->create( array( 'post_author' => $user_2 ) );
+
+                $counts1 = count_many_users_posts( array( $user_1, $user_2 ), 'post', false );
+                $this->assertSame(
+                        array(
+                                $user_1 => '1',
+                                $user_2 => '1',
+                        ),
+                        $counts1,
+                        'Initial call is expected to have one post for each user.'
+                );
+
+                // Create another post for user 1.
+                self::factory()->post->create( array( 'post_author' => $user_1 ) );
+
+                $counts2 = count_many_users_posts( array( $user_1, $user_2 ), 'post', false );
+                $this->assertSame(
+                        array(
+                                $user_1 => '2',
+                                $user_2 => '1',
+                        ),
+                        $counts2,
+                        'Second call is expected to have two posts for user 1 and one post for user 2.'
+                );
+        }
+
+        /**
+         * Ensure different post types use different caches in count_many_users_posts().
+         *
+         * @ticket 63045
+         *
+         * @covers ::count_many_users_posts
+         */
+        public function test_different_post_types_use_different_caches() {
+                $user_id = self::$user_ids[0];
+
+                // Create one post and two pages for the user.
+                self::factory()->post->create(
+                        array(
+                                'post_author' => $user_id,
+                                'post_type'   => 'post',
+                        )
+                );
+                self::factory()->post->create(
+                        array(
+                                'post_author' => $user_id,
+                                'post_type'   => 'page',
+                        )
+                );
+                self::factory()->post->create(
+                        array(
+                                'post_author' => $user_id,
+                                'post_type'   => 'page',
+                        )
+                );
+
+                $start_queries = get_num_queries();
+                $count1        = count_many_users_posts( array( $user_id ), 'post', false );
+                $end_queries   = get_num_queries();
+                $this->assertSame( 1, $end_queries - $start_queries, 'Expected to hit database for first call to count_many_users_posts() with post type "post".' );
+                $this->assertSame( '1', $count1[ $user_id ], 'Expected to have one post for user with post type "post".' );
+
+                $start_queries = get_num_queries();
+                $count2        = count_many_users_posts( array( $user_id ), 'page', false );
+                $end_queries   = get_num_queries();
+                $this->assertSame( 1, $end_queries - $start_queries, 'Expected to hit database for first call to count_many_users_posts() with post type "page".' );
+                $this->assertSame( '2', $count2[ $user_id ], 'Expected to have two pages for user with post type "page".' );
+        }
+
+        /**
+         * Ensure different users use different caches in count_many_users_posts().
+         *
+         * @ticket 63045
+         *
+         * @covers ::count_many_users_posts
+         */
+        public function test_different_users_use_different_caches() {
+                $user_1 = self::$user_ids[0];
+                $user_2 = self::$user_ids[1];
+
+                // Create one post for user 1, two for user 2.
+                self::factory()->post->create(
+                        array(
+                                'post_author' => $user_1,
+                                'post_type'   => 'post',
+                        )
+                );
+                self::factory()->post->create(
+                        array(
+                                'post_author' => $user_2,
+                                'post_type'   => 'post',
+                        )
+                );
+                self::factory()->post->create(
+                        array(
+                                'post_author' => $user_2,
+                                'post_type'   => 'post',
+                        )
+                );
+
+                $start_queries = get_num_queries();
+                $count1        = count_many_users_posts( array( $user_1 ), 'post', false );
+                $end_queries   = get_num_queries();
+                $this->assertSame( 1, $end_queries - $start_queries, 'Expected to hit database for first call to count_many_users_posts() with user 1.' );
+                $this->assertSame( '1', $count1[ $user_1 ], 'Expected to have one post for user 1 with post type "post".' );
+
+                $start_queries = get_num_queries();
+                $count2        = count_many_users_posts( array( $user_2 ), 'post', false );
+                $end_queries   = get_num_queries();
+                $this->assertSame( 1, $end_queries - $start_queries, 'Expected to hit database for first call to count_many_users_posts() with user 2.' );
+                $this->assertSame( '2', $count2[ $user_2 ], 'Expected to have two posts for user 2 with post type "post".' );
         }