Ticket #34848: 34848.6.diff

src/wp-includes/meta.php

@@ -132 +132 @@
         return $mid;
 }
 
+/**
+ * Add multiple metadatas for the specified object. Similar to calling add_metadata for each metadata individually,
+ * and is only applicable for unique meta data. If a meta key already exists for an object it will not be stored.
+ *
+ * @since x.x.x
+ *
+ * @global wpdb $wpdb WordPress database abstraction object.
+ *
+ * @param string $meta_type  Type of object metadata is for (e.g., comment, post, or user)
+ * @param int    $object_id  ID of the object metadata is for
+ * @param array  $meta_data  Metadata as a key/value pair array. Values must be serializable if non-scalar.
+ * @return int|false The meta ID on success, false on failure.
+ */
+function add_metadatas( $meta_type, $object_id, $meta_data ) {
+        global $wpdb;
+
+        if ( ! $meta_type || ! is_numeric( $object_id ) || ! is_array( $meta_data ) ) {
+                return false;
+        }
+
+        $object_id = absint( $object_id );
+        if ( ! $object_id ) {
+                return false;
+        }
+
+        $table = _get_meta_table( $meta_type );
+        if ( ! $table ) {
+                return false;
+        }
+
+        $column = sanitize_key( $meta_type . '_id' );
+
+        /**
+         * Filters whether to add metadata of a specific type.
+         *
+         * The dynamic portion of the hook, `$meta_type`, refers to the meta
+         * object type (comment, post, or user). Returning a non-null value
+         * will effectively short-circuit the function.
+         *
+         * @since 3.1.0
+         *
+         * @param null|bool $check      Whether to allow adding metadata for the given type.
+         * @param int       $object_id  Object ID.
+         * @param array     $meta_data  Meta data, an array of meta keys and meta datas, meta values must be serializable
+         *                              if non-scalar.
+         */
+        $check = apply_filters( "add_{$meta_type}_metadatas", null, $object_id, $meta_data );
+        if ( null !== $check ) {
+                return $check;
+        }
+
+        $_meta_data = array();
+        foreach ( $meta_data as $key => $value ) {
+   $check = apply_filters( "add_{$meta_type}_metadata", null, $object_id, $key, $value );
+   if ( null !== $check )
+       continue;
+
+                if ( 0 == absint( $wpdb->get_var(
+                                $wpdb->prepare( "SELECT COUNT(*) FROM $table WHERE meta_key = %s AND $column = %d", $key, $object_id )
+                        ) ) ) {
+                        $key = wp_unslash( $key );
+                        $value = wp_unslash( sanitize_meta( $key, $value, $meta_type ) );
+
+                        $_meta_data[ $key ] = maybe_serialize( $value );
+
+                        /**
+                         * Fires immediately before meta of a specific type is added.
+                         *
+                         * The dynamic portion of the hook, `$meta_type`, refers to the meta
+                         * object type (comment, post, or user).
+                         *
+                         * @since 3.1.0
+                         *
+                         * @param int    $object_id  Object ID.
+                         * @param string $meta_key   Meta key.
+                         * @param mixed  $meta_value Meta value.
+                         */
+                        do_action( "add_{$meta_type}_meta", $object_id, $key, $value );
+
+                }
+        }
+
+        $rows = array();
+        if ( ! empty( $_meta_data ) ) {
+                $sql = "INSERT INTO {$table} ({$column}, meta_key, meta_value) VALUES ";
+
+                $comma = false;
+                foreach ( $_meta_data as $key => $value ) {
+                        if ( true == $comma ) {
+                                $sql .= ',';
+                        }
+
+                        $sql = $wpdb->prepare( $sql . " (%d, %s, %s)", $object_id, $key, $value );
+                        $comma = true;
+                }
+        }
+
+        $result = $wpdb->query( $sql );
+
+        if ( ! $result ) {
+                return false;
+        }
+
+        wp_cache_delete($object_id, $meta_type . '_meta');
+
+        return true;
+}
+
 /**
  * Update metadata for the specified object. If no value already exists for the specified object
  * ID and metadata key, the metadata will be added.
@@ -462 +566 @@
         return true;
 }
 
+/**
+ * Delete metadatas for the specified object.
+ *
+ * @since x.x.x
+ *
+ * @global wpdb $wpdb WordPress database abstraction object.
+ *
+ * @param string $meta_type  Type of object metadata is for (e.g., comment, post, or user)
+ * @param int    $object_id  ID of the object metadata is for
+ * @param array  $meta_keys  Metadata keys to be deleted.
+ * @return bool  True on successful delete, false on failure.
+ */
+function delete_metadatas( $meta_type, $object_id, $meta_keys ) {
+        global $wpdb;
+
+        if ( ! $meta_type || ! is_numeric( $object_id ) && ! is_array( $meta_keys ) ) {
+                return false;
+        }
+
+        $object_id = absint( $object_id );
+        if ( ! $object_id ) {
+                return false;
+        }
+
+        $table = _get_meta_table( $meta_type );
+        if ( ! $table ) {
+                return false;
+        }
+
+        $type_column = sanitize_key( $meta_type . '_id' );
+        $id_column   = 'user' == $meta_type ? 'umeta_id' : 'meta_id';
+        // expected_slashed ($meta_key)
+        $meta_key = array_map( 'wp_unslash', $meta_keys );
+
+        /**
+         * Filters whether to delete metadata of a specific type.
+         *
+         * The dynamic portion of the hook, `$meta_type`, refers to the meta
+         * object type (comment, post, or user). Returning a non-null value
+         * will effectively short-circuit the function.
+         *
+         * @since x.x.x
+         *
+         * @param null|bool $delete     Whether to allow metadata deletion of the given type.
+         * @param int       $object_id  Object ID.
+         * @param array     $meta_keys  Meta keys.
+         */
+        $check = apply_filters( "delete_{$meta_type}_metadatas", null, $object_id, $meta_keys );
+        if ( null !== $check ) {
+                return (bool) $check;
+        }
+
+        /**
+         * Fires immediately before deleting metadata of a specific type.
+         *
+         * The dynamic portion of the hook, `$meta_type`, refers to the meta
+         * object type (comment, post, or user).
+         *
+         * @since x.x.x
+         *
+         * @param int    $object_id  Object ID.
+         * @param string $meta_keys  Meta keys.
+         */
+        do_action( "delete_{$meta_type}_metas", $object_id, $meta_keys );
+        $sql = $wpdb->prepare( "DELETE FROM {$table} WHERE {$type_column} = %d and meta_key IN( ", $object_id );
+        $comma = false;
+        foreach ( $meta_keys as $meta_key ) {
+                if ( true == $comma ) {
+                        $sql .= ', ';
+                }
 
+                $sql = $wpdb->prepare( $sql . " %s", $meta_key );
+                $comma = true;
+        }
+        $sql .= " )";
+        $count = $wpdb->query( $sql );
+
+        if ( ! $count ) {
+                return false;
+        }
+        wp_cache_delete($object_id, $meta_type . '_meta');
+
+        /**
+         * Fires immediately after deleting metadata of a specific type.
+         *
+         * The dynamic portion of the hook name, `$meta_type`, refers to the meta
+         * object type (comment, post, or user).
+         *
+         * @since x.x.x
+         *
+         * @param int    $object_id  Object ID.
+         * @param string $meta_keys  Meta key.
+         */
+        do_action( "deleted_{$meta_type}_metas", $object_id, $meta_keys );
+
+        return true;
+}
+
 /**
  * Retrieve metadata for the specified object.

src/wp-includes/post.php

@@ -1823 +1823 @@
         return $added;
 }
 
+/**
+ * Add meta datas to a post.
+ *
+ * Post meta data is called "Custom Fields" on the Administration Screen.
+ *
+ * @since x.x.x
+ *
+ * @param int    $post_id    Post ID.
+ * @param array  $meta_data  Metadata as a key/value pair array. Values must be serializable if non-scalar.
+ * @return bool  Was the data inserted
+ */
+function add_post_metas( $post_id, $meta_data ) {
+        // Make sure meta is added to the post, not a revision.
+        if ( $the_post = wp_is_post_revision( $post_id ) ) {
+                $post_id = $the_post;
+        }
+
+        $added = add_metadatas( 'post', $post_id, $meta_data );
+        if ( $added ) {
+                wp_cache_set( 'last_changed', microtime(), 'posts' );
+        }
+        return $added;
+}
+
 /**
  * Remove metadata matching criteria from a post.
  *
@@ -1851 +1875 @@
         return $deleted;
 }
 
+/**
+ * Remove metadatas matching criteria from a post.
+ *
+ * @since x.x.x
+ *
+ * @param int    $post_id    Post ID.
+ * @param array $meta_keys  Meta keys that should be deleted.
+ * @return bool True on success, false on failure.
+ */
+function delete_post_metas( $post_id, $meta_keys ) {
+        // Make sure meta is added to the post, not a revision.
+        if ( $the_post = wp_is_post_revision( $post_id ) ) {
+                $post_id = $the_post;
+        }
+
+        $deleted = delete_metadatas( 'post', $post_id, $meta_keys );
+        if ( $deleted ) {
+                wp_cache_set( 'last_changed', microtime(), 'posts' );
+        }
+        return $deleted;
+}
+
 /**
  * Retrieve post meta field for a post.
  *
@@ -1900 +1946 @@
         return $updated;
 }
 
+/**
+ * Update metadatas on a post. This is done by deleting all the post meta and then re-inserting it.
+ *
+ * To update post meta another way it would require two calls of update_post_meta
+ * Each update_post_meta call creates 1 select and 1 update mysql query
+ * 2 update_post_meta calls creates 2 select and 2 update queries
+ * update_post_metas creates 1 delete query, 1 insert query, and 1 select for every post meta being added
+ *
+ * Updating X metas:
+ * update_post_meta  = X selects, X updates
+ * update_post_metas = X selects, 1 delete, 1 insert
+ *
+ * The benefits of update_post_metas grows the more post metas being updated.
+ *
+ * Example: Updating 22 address metas on a post
+ * update_post_meta  = 22 selects, 22 updates
+ * update_post_metas = 22 selects, 1 delete, 1 insert
+ *
+ * @since x.x.x
+ *
+ * @param int    $post_id    Post ID.
+ * @param array  $meta_data  Metadata as a key/value pair array. Values must be serializable if non-scalar.
+ * @return int|bool Meta ID if the key didn't exist, true on successful update, false on failure.
+ */
+function update_post_metas( $post_id, $meta_data ) {
+        // Make sure meta is added to the post, not a revision.
+        if ( $the_post = wp_is_post_revision( $post_id ) ) {
+                $post_id = $the_post;
+        }
+
+        delete_post_metas( $post_id, array_keys( $meta_data ) );
+
+        $updated = add_post_metas( $post_id, $meta_data );
+        if ( $updated ) {
+                wp_cache_set( 'last_changed', microtime(), 'posts' );
+        }
+        return $updated;
+}
+
 /**
  * Delete everything from post meta matching meta key.
  *

new file tests/phpunit/tests/meta/BulkMetadata.php

@@ +1 @@
+<?php
+
+/**
+ * @group meta
+ * @covers ::update_metadata
+ */
+class Tests_Meta_BulkMetadata extends WP_UnitTestCase {
+
+        /**
+         * @ticket 34848
+         */
+        public function test_adding_bulk_metadata() {
+                add_post_metas( 123, array(
+                        'foo'   => 'bar',
+                        'bar'   => 'foo',
+                        'array' => array(
+                                'foobar' => 'barfoo'
+                        )
+                ) );
+
+                $foo = get_post_meta( 123, 'foo', true );
+                $this->assertSame( $foo, 'bar' );
+
+                $bar = get_post_meta( 123, 'bar', true );
+                $this->assertSame( $bar, 'foo' );
+
+                $array = get_post_meta( 123, 'array', true );
+                $this->assertSame( $array, array(
+                        'foobar' => 'barfoo'
+                ) );
+        }
+
+        /**
+         * @ticket 34848
+         */
+        public function test_updating_bulk_metadata() {
+                add_post_metas( 123, array(
+                        'foo'   => 'bar',
+                        'bar'   => 'foo',
+                        'array' => array(
+                                'foobar' => 'barfoo'
+                        )
+                ) );
+
+                $foo = get_post_meta( 123, 'foo', true );
+                $this->assertSame( $foo, 'bar' );
+
+                $bar = get_post_meta( 123, 'bar', true );
+                $this->assertSame( $bar, 'foo' );
+
+                $array = get_post_meta( 123, 'array', true );
+                $this->assertSame( $array, array(
+                        'foobar' => 'barfoo'
+                ) );
+
+                update_post_metas( 123, array(
+                        'foo'   => 'foo',
+                        'bar'   => 'bar',
+                        'array' => array(
+                                'foobar' => 'foobar'
+                        )
+                ) );
+
+                $foo = get_post_meta( 123, 'foo', true );
+                $this->assertSame( $foo, 'foo' );
+
+                $bar = get_post_meta( 123, 'bar', true );
+                $this->assertSame( $bar, 'bar' );
+
+                $array = get_post_meta( 123, 'array', true );
+                $this->assertSame( $array, array(
+                        'foobar' => 'foobar'
+                ) );
+        }
+
+        /**
+         * @ticket 34848
+         */
+        public function test_deleting_bulk_metadata() {
+                add_post_metas( 123, array(
+                        'foo'   => 'bar',
+                        'bar'   => 'foo',
+                        'array' => array(
+                                'foobar' => 'barfoo'
+                        )
+                ) );
+
+                $foo = get_post_meta( 123, 'foo', true );
+                $this->assertSame( $foo, 'bar' );
+
+                $bar = get_post_meta( 123, 'bar', true );
+                $this->assertSame( $bar, 'foo' );
+
+                $array = get_post_meta( 123, 'array', true );
+                $this->assertSame( $array, array(
+                        'foobar' => 'barfoo'
+                ) );
+
+                delete_post_metas( 123, array(
+                        'foo',
+                        'bar',
+                    'array'
+                ) );
+
+                $foo = get_post_meta( 123, 'foo', true );
+                $this->assertSame( $foo, '' );
+
+                $bar = get_post_meta( 123, 'bar', true );
+                $this->assertSame( $bar, '' );
+
+                $array = get_post_meta( 123, 'array', true );
+                $this->assertSame( $array, '' );
+        }
+
+}