Changeset 36566

Timestamp:

02/17/2016 10:57:33 PM (8 years ago)

Author:

boonebgorges

Message:

More performance improvements to metadata lazyloading.

Comment and term meta lazyloading for WP_Query loops, introduced in 4.4,
depended on filter callback methods belonging to WP_Query objects. This meant
storing WP_Query objects in the $wp_filter global (via add_filter()),
requiring that PHP retain the objects in memory, even when the local variables
would typically be expunged during normal garbage collection. In cases where a
large number of WP_Query objects were instantiated on a single pageload,
and/or where the contents of the WP_Query objects were quite large, serious
performance issues could result.

We skirt this problem by moving metadata lazyloading out of WP_Query. The
new WP_Metadata_Lazyloader class acts as a lazyload queue. Query instances
register items whose metadata should be lazyloaded - such as post terms, or
comments - and a WP_Metadata_Lazyloader method will intercept comment and
term meta requests to perform the cache priming. Since WP_Metadata_Lazyloader
instances are far smaller than WP_Query (containing only object IDs), and
clean up after themselves far better than the previous WP_Query methods (bp
only running their callbacks a single time for a given set of queued objects),
the resource use is decreased dramatically.

See [36525] for an earlier step in this direction.

Props lpawlik, stevegrunwell, boonebgorges.
Fixes #35816.

Location:

trunk

Files:

• src/wp-includes/class-wp-metadata-lazyloader.php (added)
• src/wp-includes/comment-template.php (modified) (2 diffs)
• src/wp-includes/comment.php (modified) (1 diff)
• src/wp-includes/meta.php (modified) (1 diff)
• src/wp-includes/post.php (modified) (1 diff)
• src/wp-includes/query.php (modified) (4 diffs)
• src/wp-settings.php (modified) (1 diff)
• tests/phpunit/tests/term/meta.php (modified) (5 diffs)

trunk/src/wp-includes/comment-template.php

@@ -1393 +1393 @@
      */
     $wp_query->comments = apply_filters( 'comments_array', $comments_flat, $post->ID );
-
-    // Set up lazy-loading for comment metadata.
-    add_action( 'get_comment_metadata', array( $wp_query, 'lazyload_comment_meta' ), 10, 2 );
 
     $comments = &$wp_query->comments;
@@ -2030 +2027 @@
     if ( null === $r['reverse_top_level'] )
         $r['reverse_top_level'] = ( 'desc' == get_option('comment_order') );
+
+
 
     if ( empty( $r['walker'] ) ) {

trunk/src/wp-includes/comment.php

@@ -470 +470 @@
 
 /**
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
  * Sets the cookies used to store an unauthenticated commentator's identity. Typically used
  * to recall previous comments by this commentator that are still held in moderation.

trunk/src/wp-includes/meta.php

@@ -853 +853 @@
 
 /**
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
  * Given a meta query, generates SQL clauses to be appended to a main query.
  *

trunk/src/wp-includes/post.php

@@ -5949 +5949 @@
 
 /**
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
  * Update the custom taxonomies' term counts when a post's status is changed.
  *

trunk/src/wp-includes/query.php

@@ -3606 +3606 @@
             $this->posts = array_map( 'get_post', $this->posts );
 
-
-        if ( $q['update_post_term_cache'] ) {
-            add_filter( 'get_term_metadata', array( $this, 'lazyload_term_meta' ), 10, 2 );
-        }
-
         if ( ! $q['suppress_filters'] ) {
             /**
@@ -3739 +3734 @@
         // If comments have been fetched as part of the query, make sure comment meta lazy-loading is set up.
         if ( ! empty( $this->comments ) ) {
-            add_filter( 'get_comment_metadata', array( $this, 'lazyload_comment_meta' ), 10, 2 );
+             );
         }
 
@@ -3769 +3764 @@
             $this->post_count = 0;
             $this->posts = array();
+
+
+
+
         }
 
@@ -4835 +4834 @@
 
     /**
-     * Lazy-loads termmeta for located posts.
-     *
-     * As a rule, term queries (`get_terms()` and `wp_get_object_terms()`) prime the metadata cache for matched
-     * terms by default. However, this can cause a slight performance penalty, especially when that metadata is
-     * not actually used. In the context of a `WP_Query` instance, we're able to avoid this potential penalty.
-     * `update_object_term_cache()`, called from `update_post_caches()`, does not 'update_term_meta_cache'.
-     * Instead, the first time `get_term_meta()` is called from within a `WP_Query` loop, the current method
-     * detects the fact, and then primes the metadata cache for all terms attached to all posts in the loop,
-     * with a single database query.
-     *
-     * This method is public so that it can be used as a filter callback. As a rule, there is no need to invoke it
-     * directly, from either inside or outside the `WP_Query` object.
+     * Lazyload term meta for posts in the loop.
      *
      * @since 4.4.0
-     * @access public
-     *
-     * @param mixed $check  The `$check` param passed from the 'get_term_metadata' hook.
-     * @param int  $term_id ID of the term whose metadata is being cached.
-     * @return mixed In order not to short-circuit `get_metadata()`. Generally, this is `null`, but it could be
-     *               another value if filtered by a plugin.
+     * @deprecated 4.5.0 See wp_queue_posts_for_term_meta_lazyload().
+     *
+     * @param mixed $check
+     * @param int   $term_id
+     * @return mixed
      */
     public function lazyload_term_meta( $check, $term_id ) {
-        // We can only lazyload if the entire post object is present.
-        $posts = array();
-        foreach ( $this->posts as $post ) {
-            if ( $post instanceof WP_Post ) {
-                $posts[] = $post;
-            }
-        }
-
-        if ( ! empty( $posts ) ) {
-            // Fetch cached term_ids for each post. Keyed by term_id for faster lookup.
-            $term_ids = array();
-            foreach ( $posts as $post ) {
-                $taxonomies = get_object_taxonomies( $post->post_type );
-                foreach ( $taxonomies as $taxonomy ) {
-                    // Term cache should already be primed by 'update_post_term_cache'.
-                    $terms = get_object_term_cache( $post->ID, $taxonomy );
-                    if ( false !== $terms ) {
-                        foreach ( $terms as $term ) {
-                            if ( ! isset( $term_ids[ $term->term_id ] ) ) {
-                                $term_ids[ $term->term_id ] = 1;
-                            }
-                        }
-                    }
-                }
-            }
-
-            /*
-             * Only update the metadata cache for terms belonging to these posts if the term_id passed
-             * to `get_term_meta()` matches one of those terms. This prevents a single call to
-             * `get_term_meta()` from priming metadata for all `WP_Query` objects.
-             */
-            if ( isset( $term_ids[ $term_id ] ) ) {
-                update_termmeta_cache( array_keys( $term_ids ) );
-                remove_filter( 'get_term_metadata', array( $this, 'lazyload_term_meta' ), 10, 2 );
-            }
-        }
-
-        // If no terms were found, there's no need to run this again.
-        if ( empty( $term_ids ) ) {
-            remove_filter( 'get_term_metadata', array( $this, 'lazyload_term_meta' ), 10, 2 );
-        }
-
+        _deprecated_function( __METHOD__, '4.5.0' );
         return $check;
     }
 
     /**
-     * Lazy-load comment meta when inside of a `WP_Query` loop.
-     *
-     * This method is public so that it can be used as a filter callback. As a rule, there is no need to invoke it
-     * directly, from either inside or outside the `WP_Query` object.
+     * Lazyload comment meta for comments in the loop.
      *
      * @since 4.4.0
-     *
-     * @param mixed $check     The `$check` param passed from the 'get_comment_metadata' hook.
-     * @param int  $comment_id ID of the comment whose metadata is being cached.
-     * @return mixed The original value of `$check`, to not affect 'get_comment_metadata'.
+     * @deprecated 4.5.0 See wp_queue_comments_for_comment_meta_lazyload().
+     *
+     * @param mixed $check
+     * @param int   $comment_id
+     * @return mixed
      */
     public function lazyload_comment_meta( $check, $comment_id ) {
-        // Don't use `wp_list_pluck()` to avoid by-reference manipulation.
-        $comment_ids = array();
-        if ( is_array( $this->comments ) ) {
-            foreach ( $this->comments as $comment ) {
-                $comment_ids[] = $comment->comment_ID;
-            }
-        }
-
-        /*
-         * Only update the metadata cache for comments belonging to these posts if the comment_id passed
-         * to `get_comment_meta()` matches one of those comments. This prevents a single call to
-         * `get_comment_meta()` from priming metadata for all `WP_Query` objects.
-         */
-        if ( in_array( $comment_id, $comment_ids ) ) {
-            update_meta_cache( 'comment', $comment_ids );
-            remove_filter( 'get_comment_metadata', array( $this, 'lazyload_comment_meta' ), 10, 2 );
-        } elseif ( empty( $comment_ids ) ) {
-            remove_filter( 'get_comment_metadata', array( $this, 'lazyload_comment_meta' ), 10, 2 );
-        }
-
+        _deprecated_function( __METHOD__, '4.5.0' );
         return $check;
     }

trunk/src/wp-settings.php

@@ -136 +136 @@
 require( ABSPATH . WPINC . '/meta.php' );
 require( ABSPATH . WPINC . '/class-wp-meta-query.php' );
+
 require( ABSPATH . WPINC . '/general-template.php' );
 require( ABSPATH . WPINC . '/link-template.php' );

trunk/tests/phpunit/tests/term/meta.php

@@ -135 +135 @@
                 $num_queries = $wpdb->num_queries;
                 $this->assertSame( 'bar', get_term_meta( $terms[0], 'foo', true ) );
-                $this->assertSame( $num_queries + 1, $wpdb->num_queries );
+                $num_queries++;
+                $this->assertSame( $num_queries, $wpdb->num_queries );
 
                 // Second and third requests should be in cache.
                 $this->assertSame( 'bar', get_term_meta( $terms[1], 'foo', true ) );
                 $this->assertSame( 'bar', get_term_meta( $terms[2], 'foo', true ) );
-                $this->assertSame( $num_queries + 1, $wpdb->num_queries );
+                $this->assertSame( $num_queries, $wpdb->num_queries );
 
                 // Querying a term not primed should result in a hit.
+
                 $this->assertSame( 'bar', get_term_meta( $orphan_term, 'foo', true ) );
-                $this->assertSame( $num_queries + 2, $wpdb->num_queries );
+                $this->assertSame( $num_queries, $wpdb->num_queries );
             }
         }
     }
 
-    /**
-     * @ticket 34073
-     */
-    public function test_term_meta_should_be_lazy_loaded_only_for_the_queries_in_which_the_term_has_posts() {
-        global $wpdb;
-
-        $posts = self::factory()->post->create_many( 3, array( 'post_status' => 'publish' ) );
-        register_taxonomy( 'wptests_tax', 'post' );
-        $terms = self::factory()->term->create_many( 6, array( 'taxonomy' => 'wptests_tax' ) );
-
-        wp_set_object_terms( $posts[0], array( $terms[0], $terms[1] ), 'wptests_tax' );
-        wp_set_object_terms( $posts[1], array( $terms[2], $terms[3] ), 'wptests_tax' );
-        wp_set_object_terms( $posts[2], array( $terms[0], $terms[4], $terms[5] ), 'wptests_tax' );
-
-        foreach ( $terms as $t ) {
-            add_term_meta( $t, 'foo', 'bar' );
-        }
-
-        $q0 = new WP_Query( array( 'p' => $posts[0], 'cache_results' => true ) );
-        $q1 = new WP_Query( array( 'p' => $posts[1], 'cache_results' => true ) );
-        $q2 = new WP_Query( array( 'p' => $posts[2], 'cache_results' => true ) );
-
-        /*
-         * $terms[0] belongs to both $posts[0] and $posts[2], so `get_term_meta( $terms[0] )` should prime
-         * the cache for term matched by $q0 and $q2.
-         */
-
-        // First request will hit the database.
-        $num_queries = $wpdb->num_queries;
-
-        // Prime caches.
-        $this->assertSame( 'bar', get_term_meta( $terms[0], 'foo', true ) );
-
-        // Two queries: one for $q0 and one for $q2.
-        $num_queries += 2;
-        $this->assertSame( $num_queries, $wpdb->num_queries );
-
-        // Next requests should be in cache.
-        $this->assertSame( 'bar', get_term_meta( $terms[1], 'foo', true ) );
-        $this->assertSame( 'bar', get_term_meta( $terms[4], 'foo', true ) );
-        $this->assertSame( 'bar', get_term_meta( $terms[5], 'foo', true ) );
-        $this->assertSame( $num_queries, $wpdb->num_queries );
-
-        // Querying for $terms[2] will prime $terms[3] as well.
-        $this->assertSame( 'bar', get_term_meta( $terms[2], 'foo', true ) );
-        $num_queries++;
-        $this->assertSame( $num_queries, $wpdb->num_queries );
-
-        $this->assertSame( 'bar', get_term_meta( $terms[3], 'foo', true ) );
-        $this->assertSame( $num_queries, $wpdb->num_queries );
-    }
-
-    public function test_adding_term_meta_should_bust_get_terms_cache() {
+    public function test_updating_term_meta_should_bust_get_terms_cache() {
         $terms = self::factory()->term->create_many( 2, array( 'taxonomy' => 'wptests_tax' ) );
 
         add_term_meta( $terms[0], 'foo', 'bar' );
+
 
         // Prime cache.
@@ -220 +171 @@
         $this->assertEqualSets( array( $terms[0] ), $found );
 
-        add_term_meta( $terms[1], 'foo', 'bar' );
+        _term_meta( $terms[1], 'foo', 'bar' );
 
         $found = get_terms( 'wptests_tax', array(
@@ -236 +187 @@
     }
 
-    public function test_updating_term_meta_should_bust_get_terms_cache() {
+    public function test_ting_term_meta_should_bust_get_terms_cache() {
         $terms = self::factory()->term->create_many( 2, array( 'taxonomy' => 'wptests_tax' ) );
 
         add_term_meta( $terms[0], 'foo', 'bar' );
-        add_term_meta( $terms[1], 'foo', 'baz' );
+        add_term_meta( $terms[1], 'foo', 'ba' );
 
         // Prime cache.
@@ -254 +205 @@
         ) );
 
-        $this->assertEqualSets( array( $terms[0] ), $found );
-
-        update_term_meta( $terms[1], 'foo', 'bar' );
+        $this->assertEqualSets( array( $terms[0] ), $found );
+
+        te_term_meta( $terms[1], 'foo', 'bar' );
 
         $found = get_terms( 'wptests_tax', array(
@@ -269 +220 @@
         ) );
 
-        $this->assertEqualSets( array( $terms[0], $terms[1] ), $found );
-    }
-
-    public function test_deleting_term_meta_should_bust_get_terms_cache() {
-        $terms = self::factory()->term->create_many( 2, array( 'taxonomy' => 'wptests_tax' ) );
-
-        add_term_meta( $terms[0], 'foo', 'bar' );
-        add_term_meta( $terms[1], 'foo', 'bar' );
-
-        // Prime cache.
-        $found = get_terms( 'wptests_tax', array(
-            'hide_empty' => false,
-            'fields' => 'ids',
-            'meta_query' => array(
-                array(
-                    'key' => 'foo',
-                    'value' => 'bar',
-                ),
-            ),
-        ) );
-
-        $this->assertEqualSets( array( $terms[0], $terms[1] ), $found );
-
-        delete_term_meta( $terms[1], 'foo', 'bar' );
-
-        $found = get_terms( 'wptests_tax', array(
-            'hide_empty' => false,
-            'fields' => 'ids',
-            'meta_query' => array(
-                array(
-                    'key' => 'foo',
-                    'value' => 'bar',
-                ),
-            ),
-        ) );
-
         $this->assertEqualSets( array( $terms[0] ), $found );
     }