Taxonomy: Improve performance of term recounting database queries.

When modifying terms assigned to an object, replace full term recounts with incrementing/decrementing the count as appropriate. This provides a significant performance boost on sites with a high number of term/object relationships and/or posts.

Introduces the functions `wp_increment_term_count()`, `wp_decrement_term_count()`, `wp_modify_term_count_by()` and `wp_modify_term_count_by_now()` for updating the term count.

Introduces the function `_wp_prevent_term_counting()` for preventing double counting on posts that are about to transition.

Adds the parameter `update_count_by_callback` to `register_taxonomy()` to allow developers to use a custom callback for incrementing or decrementing a term count.

Props boonebgorges, davidbaumwald, hellofromTonya, johnbillion, lcyh78, mattoperry, peterwilsoncc, rebasaurus, whyisjake.
Fixes #40351.


Built from https://develop.svn.wordpress.org/trunk@49141


git-svn-id: http://core.svn.wordpress.org/trunk@48903 1a063a9b-81f0-0310-95a4-ce76da25c4cd

wp-includes/class-wp-taxonomy.php

@@ -180,6 +180,14 @@ final class WP_Taxonomy {
 	 */
 	public $update_count_callback;
 
+	/**
+	 * Function that will be called when the count is modified by an amount.
+	 *
+	 * @since 5.6.0
+	 * @var callable
+	 */
+	public $update_count_by_callback;
+
 	/**
 	 * Whether this taxonomy should appear in the REST API.
 	 *
@@ -294,6 +302,7 @@ final class WP_Taxonomy {
 			'rewrite'                  => true,
 			'query_var'                => $this->name,
 			'update_count_callback'    => '',
+			'update_count_by_callback' => '',
 			'show_in_rest'             => false,
 			'rest_base'                => false,
 			'rest_controller_class'    => false,
@@ -411,6 +420,17 @@ final class WP_Taxonomy {
 			);
 		}
 
+		// If generic update callback is defined but increment/decrement callback is not.
+		if (
+			! empty( $args['update_count_callback'] ) &&
+			is_callable( $args['update_count_callback'] ) &&
+			empty( $args['update_count_by_callback'] )
+		) {
+			$args['update_count_by_callback'] = function( $tt_ids, $taxonomy, $modify_by ) {
+				return call_user_func( $args['update_count_callback'], $tt_ids, $taxonomy );
+			};
+		}
+
 		foreach ( $args as $property_name => $property_value ) {
 			$this->$property_name = $property_value;
 		}

wp-includes/post.php

@@ -4071,6 +4071,8 @@ function wp_insert_post( $postarr, $wp_error = false ) {
 		clean_post_cache( $post_ID );
 	}
 
+	// Allow term counts to be handled by transitioning post type.
+	_wp_prevent_term_counting( true );
 	if ( is_object_in_taxonomy( $post_type, 'category' ) ) {
 		wp_set_post_categories( $post_ID, $post_category );
 	}
@@ -4127,6 +4129,8 @@ function wp_insert_post( $postarr, $wp_error = false ) {
 			}
 		}
 	}
+	// Restore term counting.
+	_wp_prevent_term_counting( false );
 
 	if ( ! empty( $postarr['meta_input'] ) ) {
 		foreach ( $postarr['meta_input'] as $field => $value ) {
@@ -4436,7 +4440,9 @@ function wp_publish_post( $post ) {
 		if ( ! $default_term_id ) {
 			continue;
 		}
+		_wp_prevent_term_counting( true );
 		wp_set_post_terms( $post->ID, array( $default_term_id ), $taxonomy );
+		_wp_prevent_term_counting( false );
 	}
 
 	$wpdb->update( $wpdb->posts, array( 'post_status' => 'publish' ), array( 'ID' => $post->ID ) );
@@ -7312,11 +7318,91 @@ function wp_queue_posts_for_term_meta_lazyload( $posts ) {
  * @param WP_Post $post       Post object.
  */
 function _update_term_count_on_transition_post_status( $new_status, $old_status, $post ) {
-	// Update counts for the post's terms.
+	if ( 'inherit' === $new_status ) {
+		$new_status = get_post_status( $post->post_parent );
+	}
+
+	if ( 'inherit' === $old_status ) {
+		$old_status = get_post_status( $post->post_parent );
+	}
+
+	$count_new = 'publish' === $new_status;
+	$count_old = 'publish' === $old_status;
+
+	if ( $count_new === $count_old ) {
+		// Nothing to do.
+		return;
+	}
+
+	/*
+	 * Update counts for the post's terms.
+	 *
+	 * Term counting is deferred while incrementing/decrementing the counts to
+	 * reduce the number of database queries required. Once the counts are
+	 * complete the updates are performed if term counting wasn't previously
+	 * deferred.
+	 */
+	$previous_deferred_setting = wp_defer_term_counting();
+	wp_defer_term_counting( true );
 	foreach ( (array) get_object_taxonomies( $post->post_type ) as $taxonomy ) {
 		$tt_ids = wp_get_object_terms( $post->ID, $taxonomy, array( 'fields' => 'tt_ids' ) );
-		wp_update_term_count( $tt_ids, $taxonomy );
+
+		if ( empty( $tt_ids ) ) {
+			// No terms for this taxonomy on object.
+			continue;
 		}
+
+		$object_types = (array) get_taxonomy( $taxonomy )->object_type;
+
+		foreach ( $object_types as &$object_type ) {
+			list( $object_type ) = explode( ':', $object_type );
+		}
+
+		$object_types = array_unique( $object_types );
+
+		if ( ! in_array( $post->post_type, $object_types, true ) ) {
+			$modify_by = 0;
+		} elseif ( $count_new && ! $count_old ) {
+			$modify_by = 1;
+		} elseif ( $count_old && ! $count_new ) {
+			$modify_by = -1;
+		}
+
+		if ( 'attachment' === $post->post_type ) {
+			wp_modify_term_count_by( $tt_ids, $taxonomy, $modify_by );
+			continue;
+		}
+
+		$check_attachments = array_search( 'attachment', $object_types, true );
+		if ( false !== $check_attachments ) {
+			unset( $object_types[ $check_attachments ] );
+			$check_attachments = true;
+		}
+
+		wp_modify_term_count_by( $tt_ids, $taxonomy, $modify_by );
+		if ( ! $check_attachments ) {
+			continue;
+		}
+
+		/*
+		 * For non-attachments, check if there are any attachment children
+		 * with 'inherited' post status -- if so those will need to be counted.
+		 */
+		$attachments = get_children(
+			array(
+				'post_parent'            => $post->ID,
+				'post_status'            => 'inherit',
+				'post_type'              => 'attachment',
+				'update_post_meta_cache' => false,
+				'update_post_term_cache' => true,
+			)
+		);
+
+		foreach ( $attachments as $attachment ) {
+			_update_term_count_on_transition_post_status( $new_status, $old_status, $attachment );
+		}
+	}
+	wp_defer_term_counting( $previous_deferred_setting );
 }
 
 /**

wp-includes/taxonomy.php

@@ -336,6 +336,7 @@ function is_taxonomy_hierarchical( $taxonomy ) {
  * @since 5.1.0 Introduced `meta_box_sanitize_cb` argument.
  * @since 5.4.0 Added the registered taxonomy object as a return value.
  * @since 5.5.0 Introduced `default_term` argument.
+ * @since 5.6.0 Introduced `update_count_by_callback` argument.
  *
  * @global array $wp_taxonomies Registered taxonomies.
  *
@@ -407,6 +408,9 @@ function is_taxonomy_hierarchical( $taxonomy ) {
  *                                                   to post types, which confirms that the objects are published before
  *                                                   counting them. Default _update_generic_term_count() for taxonomies
  *                                                   attached to other object types, such as users.
+ *     @type callable      $update_count_by_callback Works much like a hook, in that it will be called when the count is
+ *                                                   incremented or decremented. Defaults to the value of `$update_count_callback` if
+ *                                                   a custom callack is defined, otherwise uses wp_modify_term_count_by().
  *     @type string|array  $default_term {
  *         Default term to be used for the taxonomy.
  *
@@ -2561,6 +2565,25 @@ function wp_set_object_terms( $object_id, $terms, $taxonomy, $append = false ) {
 		return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
 	}
 
+	$taxonomy_object = get_taxonomy( $taxonomy );
+
+	$object_types = (array) $taxonomy_object->object_type;
+	foreach ( $object_types as &$object_type ) {
+		if ( 0 === strpos( $object_type, 'attachment:' ) ) {
+			list( $object_type ) = explode( ':', $object_type );
+		}
+	}
+
+	if ( array_filter( $object_types, 'post_type_exists' ) !== $object_types ) {
+		// This taxonomy applies to non-posts, count changes now.
+		$do_recount = ! _wp_prevent_term_counting();
+	} elseif ( 'publish' === get_post_status( $object_id ) ) {
+		// Published post, count changes now.
+		$do_recount = ! _wp_prevent_term_counting();
+	} else {
+		$do_recount = false;
+	}
+
 	if ( ! is_array( $terms ) ) {
 		$terms = array( $terms );
 	}
@@ -2646,8 +2669,8 @@ function wp_set_object_terms( $object_id, $terms, $taxonomy, $append = false ) {
 		$new_tt_ids[] = $tt_id;
 	}
 
-	if ( $new_tt_ids ) {
+	if ( $new_tt_ids && $do_recount ) {
-		wp_update_term_count( $new_tt_ids, $taxonomy );
+		wp_increment_term_count( $new_tt_ids, $taxonomy );
 	}
 
 	if ( ! $append ) {
@@ -2665,9 +2688,7 @@ function wp_set_object_terms( $object_id, $terms, $taxonomy, $append = false ) {
 		}
 	}
 
-	$t = get_taxonomy( $taxonomy );
+	if ( ! $append && isset( $taxonomy_object->sort ) && $taxonomy_object->sort ) {
-
-	if ( ! $append && isset( $t->sort ) && $t->sort ) {
 		$values     = array();
 		$term_order = 0;
 
@@ -2748,6 +2769,31 @@ function wp_remove_object_terms( $object_id, $terms, $taxonomy ) {
 		return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
 	}
 
+	$taxonomy_object = get_taxonomy( $taxonomy );
+
+	$object_types = (array) $taxonomy_object->object_type;
+	foreach ( $object_types as &$object_type ) {
+		if ( 0 === strpos( $object_type, 'attachment:' ) ) {
+			list( $object_type ) = explode( ':', $object_type );
+		}
+	}
+
+	if ( array_filter( $object_types, 'post_type_exists' ) !== $object_types ) {
+		// This taxonomy applies to non-posts, count changes now.
+		$do_recount = ! _wp_prevent_term_counting();
+	} elseif (
+		'publish' === get_post_status( $object_id ) ||
+		(
+			'inherit' === get_post_status( $object_id ) &&
+			'publish' === get_post_status( wp_get_post_parent_id( $object_id ) )
+		)
+	) {
+		// Published post, count changes now.
+		$do_recount = ! _wp_prevent_term_counting();
+	} else {
+		$do_recount = false;
+	}
+
 	if ( ! is_array( $terms ) ) {
 		$terms = array( $terms );
 	}
@@ -2806,7 +2852,9 @@ function wp_remove_object_terms( $object_id, $terms, $taxonomy ) {
 		 */
 		do_action( 'deleted_term_relationships', $object_id, $tt_ids, $taxonomy );
 
-		wp_update_term_count( $tt_ids, $taxonomy );
+		if ( $do_recount ) {
+			wp_decrement_term_count( $tt_ids, $taxonomy );
+		}
 
 		return (bool) $deleted;
 	}
@@ -3226,6 +3274,7 @@ function wp_defer_term_counting( $defer = null ) {
 		$_defer = $defer;
 		// Flush any deferred counts.
 		if ( ! $defer ) {
+			wp_modify_term_count_by( null, null, null, true );
 			wp_update_term_count( null, null, true );
 		}
 	}
@@ -3233,6 +3282,193 @@ function wp_defer_term_counting( $defer = null ) {
 	return $_defer;
 }
 
+/**
+ * Prevents add/removing a term from modifying a term count.
+ *
+ * This is used by functions calling wp_transition_post_status() to indicate the
+ * term count will be handled during the post's transition.
+ *
+ * @private
+ * @since 5.6.0
+ *
+ * @param bool $new_setting The new setting for preventing term counts.
+ * @return bool Whether term count prevention is enabled or disabled.
+ */
+function _wp_prevent_term_counting( $new_setting = null ) {
+	static $prevent = false;
+
+	if ( is_bool( $new_setting ) ) {
+		$prevent = $new_setting;
+	}
+
+	return $prevent;
+}
+
+/**
+ * Increments the amount of terms in taxonomy.
+ *
+ * If there is a taxonomy callback applied, then it will be called for updating
+ * the count.
+ *
+ * The default action is to increment the count by one and update the database.
+ *
+ * @since 5.6.0
+ *
+ * @param int|array $tt_ids       The term_taxonomy_id of the terms.
+ * @param string    $taxonomy     The context of the term.
+ * @param int       $increment_by By how many the term count is to be incremented. Default 1.
+ * @param bool      $do_deferred  Whether to flush the deferred term counts too. Default false.
+ * @return bool If no terms will return false, and if successful will return true.
+ */
+function wp_increment_term_count( $tt_ids, $taxonomy, $increment_by = 1, $do_deferred = false ) {
+	return wp_modify_term_count_by( $tt_ids, $taxonomy, $increment_by, $do_deferred );
+}
+
+/**
+ * Decrements the amount of terms in taxonomy.
+ *
+ * If there is a taxonomy callback applied, then it will be called for updating
+ * the count.
+ *
+ * The default action is to decrement the count by one and update the database.
+ *
+ * @since 5.6.0
+ *
+ * @param int|array $tt_ids       The term_taxonomy_id of the terms.
+ * @param string    $taxonomy     The context of the term.
+ * @param int       $decrement_by By how many the term count is to be decremented. Default 1.
+ * @param bool      $do_deferred  Whether to flush the deferred term counts too. Default false.
+ * @return bool If no terms will return false, and if successful will return true.
+ */
+function wp_decrement_term_count( $tt_ids, $taxonomy, $decrement_by = 1, $do_deferred = false ) {
+	return wp_modify_term_count_by( $tt_ids, $taxonomy, $decrement_by * -1, $do_deferred );
+}
+
+/**
+ * Modifies the amount of terms in taxonomy.
+ *
+ * If there is a taxonomy callback applied, then it will be called for updating
+ * the count.
+ *
+ * The default action is to decrement the count by one and update the database.
+ *
+ * @since 5.6.0
+ *
+ * @param int|array $tt_ids      The term_taxonomy_id of the terms.
+ * @param string    $taxonomy    The context of the term.
+ * @param int       $modify_by   By how many the term count is to be modified.
+ * @param bool      $do_deferred Whether to flush the deferred term counts too. Default false.
+ * @return bool If no terms will return false, and if successful will return true.
+ */
+function wp_modify_term_count_by( $tt_ids, $taxonomy, $modify_by, $do_deferred = false ) {
+	static $_deferred = array();
+
+	if ( $do_deferred ) {
+		foreach ( (array) $_deferred as $taxonomy_name => $modifications ) {
+			$tax_by_count = array_reduce(
+				array_keys( $modifications ),
+				function( $by_count, $tt_id ) use ( $modifications ) {
+					if ( ! isset( $by_count[ $modifications[ $tt_id ] ] ) ) {
+						$by_count[ $modifications[ $tt_id ] ] = array();
+					}
+					$by_count[ $modifications[ $tt_id ] ][] = $tt_id;
+					return $by_count;
+				},
+				array()
+			);
+
+			foreach ( $tax_by_count as $_modify_by => $_tt_ids ) {
+				wp_modify_term_count_by_now( $_tt_ids, $taxonomy_name, $_modify_by );
+			}
+			unset( $_deferred[ $taxonomy_name ] );
+		}
+	}
+
+	if ( empty( $tt_ids ) ) {
+		return false;
+	}
+
+	if ( ! is_array( $tt_ids ) ) {
+		$tt_ids = array( $tt_ids );
+	}
+
+	if ( wp_defer_term_counting() ) {
+		foreach ( $tt_ids as $tt_id ) {
+			if ( ! isset( $_deferred[ $taxonomy ][ $tt_id ] ) ) {
+				$_deferred[ $taxonomy ][ $tt_id ] = 0;
+			}
+			$_deferred[ $taxonomy ][ $tt_id ] += $modify_by;
+		}
+		return true;
+	}
+
+	return wp_modify_term_count_by_now( $tt_ids, $taxonomy, $modify_by );
+}
+
+/**
+ * Modifies the amount of terms in taxonomy immediately
+ *
+ * If there is a taxonomy callback applied, then it will be called for updating
+ * the count.
+ *
+ * The default action is to decrement the count by one and update the database.
+ *
+ * @since 5.6.0
+ *
+ * @param int|array $tt_ids      The term_taxonomy_id of the terms.
+ * @param string    $taxonomy    The context of the term.
+ * @param int       $modify_by   By how many the term count is to be modified.
+ * @return bool If no terms will return false, and if successful will return true.
+ */
+function wp_modify_term_count_by_now( $tt_ids, $taxonomy, $modify_by ) {
+	global $wpdb;
+
+	if ( 0 === $modify_by ) {
+		return false;
+	}
+
+	$tt_ids = array_filter( array_map( 'intval', (array) $tt_ids ) );
+
+	if ( empty( $tt_ids ) ) {
+		return false;
+	}
+
+	$taxonomy = get_taxonomy( $taxonomy );
+	if ( ! empty( $taxonomy->update_count_by_callback ) ) {
+		call_user_func( $taxonomy->update_count_by_callback, $tt_ids, $taxonomy, $modify_by );
+		clean_term_cache( $tt_ids, '', false );
+		return true;
+	}
+
+	$tt_ids_string = '(' . implode( ',', $tt_ids ) . ')';
+
+	foreach ( $tt_ids as $tt_id ) {
+		/** This action is documented in wp-includes/taxonomy.php */
+		do_action( 'edit_term_taxonomy', $tt_id, $taxonomy );
+	}
+
+	$result = $wpdb->query(
+		$wpdb->prepare(
+			// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared
+			"UPDATE {$wpdb->term_taxonomy} AS tt SET tt.count = GREATEST( 0, tt.count + %d ) WHERE tt.term_taxonomy_id IN $tt_ids_string",
+			$modify_by
+		)
+	);
+
+	if ( ! $result ) {
+		return false;
+	}
+
+	foreach ( $tt_ids as $tt_id ) {
+		/** This action is documented in wp-includes/taxonomy.php */
+		do_action( 'edited_term_taxonomy', $tt_id, $taxonomy );
+	}
+
+	clean_term_cache( $tt_ids, '', false );
+
+	return true;
+}
+
 /**
  * Updates the amount of terms in taxonomy.
  *

wp-includes/version.php

@@ -13,7 +13,7 @@
  *
  * @global string $wp_version
  */
-$wp_version = '5.6-alpha-49140';
+$wp_version = '5.6-alpha-49141';
 
 /**
  * Holds the WordPress DB revision, increments when changes are made to the WordPress DB schema.