Changeset 7467 for trunk/src/includes/core/abstraction.php

Timestamp:

09/10/2026 12:35:43 AM (2 weeks ago)

Author:

johnjamesjacoby

Message:

Counts: synchronize metadata across concurrent writes.

Introduce bbp_bump_count_meta() to update existing numeric metadata with bounded compare-and-swap retries while preserving WordPress metadata filters, actions, sanitization, and cache invalidation. Apply atomic differences to forum, topic, reply, ancestor, and user contribution counts.

Reconcile counts, engagements, and voices across status transitions, permanent deletion, author changes and reassignment, moderator move/merge/split operations, and repair recounts. Correct recursive forum totals and reply visibility, and preserve term-backed favorites and subscriptions during engagement rebuilds.

Document the count-hook compatibility changes and new helper arguments, and add regression coverage for single-site and multisite workflows.

In trunk, for 2.7.

Props alex-ye.
Fixes #2233.
Fixes #3678.

File:

• trunk/src/includes/core/abstraction.php (modified) (1 diff)

trunk/src/includes/core/abstraction.php

@@ -147 +147 @@
 function bbp_db() {
         return bbp_get_global_object( 'wpdb', 'WPDB' );
+}
+
+/**
+ * Atomically bump a numeric metadata value using compare-and-swap retries.
+ *
+ * Count updates normally require reading a value, changing it in PHP, and
+ * writing it back. Two requests can read the same value and overwrite one
+ * another's changes. This function avoids that lost update by making the write
+ * conditional on the value that was read. If another request changes the value
+ * first, the condition matches no rows, so the current value is read directly
+ * from the database and the calculation is retried.
+ *
+ * The first read uses the WordPress metadata API and its cache. Missing
+ * metadata is added through add_metadata() so its standard lifecycle continues
+ * to run. Existing metadata uses a conditional database update while preserving
+ * the standard update metadata short-circuit filter and before/after actions.
+ * Before actions run for every conditional attempt, while after actions run
+ * only after a successful write. Metadata caches are cleared between attempts
+ * and after successful writes. Values are sanitized through sanitize_meta(),
+ * cast to integers, and prevented from falling below zero.
+ *
+ * Retries are bounded and filterable. This function does not lock rows or hold
+ * a database transaction open, and returns false when there is no change, a
+ * database operation fails, or all attempts lose to concurrent writes. It is
+ * intended for uniquely keyed numeric count metadata; WordPress metadata tables
+ * do not enforce uniqueness during simultaneous first-time inserts.
+ *
+ * @since 2.6.16
+ *
+ * @see https://bbpress.trac.wordpress.org/ticket/3678
+ *
+ * @param string $meta_type  Type of object metadata is for.
+ * @param int    $object_id  ID of the object metadata is for.
+ * @param string $meta_key   Metadata key.
+ * @param int    $difference Amount to add to the stored value.
+ * @param int    $default    Existing value to use when metadata is missing.
+ * @return bool True on success, false on failure or no change.
+ */
+function bbp_bump_count_meta( $meta_type = '', $object_id = 0, $meta_key = '', $difference = 1, $default = 0 ) {
+
+        $object_id  = (int) $object_id;
+        $difference = (int) $difference;
+        $default    = (int) $default;
+
+        // Bail if required values are missing
+        if ( empty( $object_id ) || empty( $meta_key ) || empty( $difference ) ) {
+                return false;
+        }
+
+        /**
+         * Short-circuits bumping numeric metadata.
+         *
+         * Returning a non-null value prevents the normal metadata update.
+         *
+         * @since 2.6.16
+         *
+         * @param null|bool $check      Whether to short-circuit the metadata update.
+         * @param string    $meta_type  Type of object metadata is for.
+         * @param int       $object_id  ID of the object metadata is for.
+         * @param string    $meta_key   Metadata key.
+         * @param int       $difference Amount to add to the stored value.
+         * @param int       $default    Existing value to use when metadata is missing.
+         */
+        $check = apply_filters( 'bbp_pre_bump_count_meta', null, $meta_type, $object_id, $meta_key, $difference, $default );
+        if ( null !== $check ) {
+                return (bool) $check;
+        }
+
+        /**
+         * Filters the metadata types that support atomic count updates.
+         *
+         * @since 2.6.16
+         *
+         * @param array  $meta_types Supported metadata types.
+         * @param string $meta_type  Requested metadata type.
+         * @param int    $object_id  ID of the object metadata is for.
+         * @param string $meta_key   Metadata key.
+         */
+        $meta_types = (array) apply_filters( 'bbp_bump_count_meta_types', array( 'post', 'user', 'term', 'comment' ), $meta_type, $object_id, $meta_key );
+
+        // Bail if the metadata type is unsupported
+        if ( ! in_array( $meta_type, $meta_types, true ) ) {
+                return false;
+        }
+
+        $bbp_db     = bbp_db();
+        $table_name = sanitize_key( $meta_type . 'meta' );
+        $table      = isset( $bbp_db->{$table_name} ) ? $bbp_db->{$table_name} : '';
+        $column     = sanitize_key( $meta_type . '_id' );
+        $id_column  = ( 'user' === $meta_type ) ? 'umeta_id' : 'meta_id';
+
+        // Bail if the metadata table does not exist
+        if ( empty( $table ) ) {
+                return false;
+        }
+
+        /**
+         * Filters the maximum number of conditional metadata write attempts.
+         *
+         * @since 2.6.16
+         *
+         * @param int    $max_attempts Maximum number of attempts.
+         * @param string $meta_type    Type of object metadata is for.
+         * @param int    $object_id    ID of the object metadata is for.
+         * @param string $meta_key     Metadata key.
+         * @param int    $difference   Amount to add to the stored value.
+         * @param int    $default      Existing value to use when metadata is missing.
+         */
+        $max_attempts = (int) apply_filters( 'bbp_bump_count_meta_max_attempts', 5, $meta_type, $object_id, $meta_key, $difference, $default );
+        $max_attempts = max( 1, $max_attempts );
+        $checked      = false;
+        $subtype      = get_object_subtype( $meta_type, $object_id );
+        $count_query  = $bbp_db->prepare( "SELECT meta_value FROM {$table} WHERE meta_key = %s AND {$column} = %d LIMIT 1", $meta_key, $object_id );
+
+        // Retry when another request updates the same value first
+        for ( $attempt = 0; $attempt < $max_attempts; $attempt++ ) {
+                if ( empty( $attempt ) ) {
+                        $exists = metadata_exists( $meta_type, $object_id, $meta_key );
+                        $count  = $exists
+                                ? (int) get_metadata( $meta_type, $object_id, $meta_key, true )
+                                : $default;
+                } else {
+                        $stored = $bbp_db->get_var( $count_query );
+
+                        // Bail on a database error
+                        if ( ! empty( $bbp_db->last_error ) ) {
+                                return false;
+                        }
+
+                        $exists = null !== $stored;
+                        $count  = $exists ? (int) $stored : $default;
+                }
+
+                $new_count = sanitize_meta( $meta_key, bbp_number_not_negative( $count + $difference ), $meta_type, $subtype );
+                $new_count = (int) $new_count;
+
+                // Allow metadata updates to be short-circuited as usual
+                if ( ! $checked ) {
+                        $checked = true;
+                        $check   = apply_filters( "update_{$meta_type}_metadata", null, $object_id, $meta_key, $new_count, '' );
+
+                        if ( null !== $check ) {
+                                return (bool) $check;
+                        }
+                }
+
+                // Bail if the count is already at its lower bound
+                if ( $new_count === $count ) {
+                        if ( ! empty( $attempt ) ) {
+                                return false;
+                        }
+
+                        $stored = $bbp_db->get_var( $count_query );
+
+                        // Bail on a database error
+                        if ( ! empty( $bbp_db->last_error ) ) {
+                                return false;
+                        }
+
+                        $current_exists = null !== $stored;
+                        $current_count  = $current_exists ? (int) $stored : $default;
+
+                        if ( ( $current_exists === $exists ) && ( $current_count === $count ) ) {
+                                return false;
+                        }
+
+                        wp_cache_delete( $object_id, $meta_type . '_meta' );
+                        continue;
+                }
+
+                // Add missing metadata using the standard WordPress lifecycle
+                if ( ! $exists ) {
+                        if ( ! empty( add_metadata( $meta_type, $object_id, $meta_key, $new_count, true ) ) ) {
+                                return true;
+                        }
+
+                        $stored = $bbp_db->get_var( $count_query );
+
+                        // Bail if the add failed without a concurrent insert or on a database error
+                        if ( ! empty( $bbp_db->last_error ) || ( null === $stored ) ) {
+                                return false;
+                        }
+
+                        wp_cache_delete( $object_id, $meta_type . '_meta' );
+                        continue;
+                }
+
+                $meta_ids = $bbp_db->get_col( $bbp_db->prepare( "SELECT {$id_column} FROM {$table} WHERE meta_key = %s AND {$column} = %d", $meta_key, $object_id ) );
+
+                // Bail on a database error
+                if ( ! empty( $bbp_db->last_error ) ) {
+                        return false;
+                }
+
+                // Retry if metadata was removed after the cached existence check
+                if ( empty( $meta_ids ) ) {
+                        wp_cache_delete( $object_id, $meta_type . '_meta' );
+                        continue;
+                }
+
+                // Run the standard actions immediately before the conditional update
+                foreach ( $meta_ids as $meta_id ) {
+                        do_action( "update_{$meta_type}_meta", $meta_id, $object_id, $meta_key, $new_count );
+
+                        if ( 'post' === $meta_type ) {
+                                do_action( 'update_postmeta', $meta_id, $object_id, $meta_key, $new_count );
+                        }
+                }
+
+                // Compare count metadata numerically to normalize stored numeric strings
+                $updated = $bbp_db->update(
+                        $table,
+                        array( 'meta_value' => $new_count ),
+                        array(
+                                $column      => $object_id,
+                                'meta_key'   => $meta_key,
+                                'meta_value' => $count
+                        ),
+                        array( '%d' ),
+                        array( '%d', '%s', '%d' )
+                );
+
+                // Bail on a database error
+                if ( false === $updated ) {
+                        return false;
+                }
+
+                wp_cache_delete( $object_id, $meta_type . '_meta' );
+
+                // Retry when another request updated the count first
+                if ( empty( $updated ) ) {
+                        continue;
+                }
+
+                // Run the standard actions immediately after the conditional update
+                foreach ( $meta_ids as $meta_id ) {
+                        do_action( "updated_{$meta_type}_meta", $meta_id, $object_id, $meta_key, $new_count );
+
+                        if ( 'post' === $meta_type ) {
+                                do_action( 'updated_postmeta', $meta_id, $object_id, $meta_key, $new_count );
+                        }
+                }
+
+                return true;
+        }
+
+        return false;
 }