Ticket #37198: 37198.3.diff

src/wp-includes/class-wp-term-query.php

@@ -100 +100 @@
          *
          * @since 4.6.0
          * @since 4.6.0 Introduced 'term_taxonomy_id' parameter.
+         * @since 4.7.0 Introduced 'object_ids' parameter.
          * @access public
          *
          * @param string|array $query {
@@ -107 +108 @@
          *
          *     @type string|array $taxonomy               Taxonomy name, or array of taxonomies, to which results should
          *                                                be limited.
+         *     @type int|array    $object_ids             Optional. Object ID, or array of object IDs. Results will be
+         *                                                limited to terms associated with these objects.
          *     @type string       $orderby                Field(s) to order terms by. Accepts term fields ('name',
          *                                                'slug', 'term_group', 'term_id', 'id', 'description'),
          *                                                'count' for term taxonomy count, 'include' to match the
@@ -130 +133 @@
          *                                                positive number. Default ''|0 (all).
          *     @type int          $offset                 The number by which to offset the terms query. Default empty.
          *     @type string       $fields                 Term fields to query for. Accepts 'all' (returns an array of
-         *                                                complete term objects), 'ids' (returns an array of ids),
-         *                                                'id=>parent' (returns an associative array with ids as keys,
-         *                                                parent term IDs as values), 'names' (returns an array of term
-         *                                                names), 'count' (returns the number of matching terms),
-         *                                                'id=>name' (returns an associative array with ids as keys,
-         *                                                term names as values), or 'id=>slug' (returns an associative
-         *                                                array with ids as keys, term slugs as values). Default 'all'.
+         *                                                complete term objects), 'all_with_object_id' (returns an
+         *                                                array of term objects with the 'object_id' param; only works
+         *                                                when the `$fields` parameter is 'object_ids' ), 'ids'
+         *                                                (returns an array of ids), 'tt_ids' (returns an array of
+         *                                                term taxonomy ids), 'id=>parent' (returns an associative
+         *                                                array with ids as keys, parent term IDs as values), 'names'
+         *                                                (returns an array of term names), 'count' (returns the number
+         *                                                of matching terms), 'id=>name' (returns an associative array
+         *                                                with ids as keys, term names as values), or 'id=>slug'
+         *                                                (returns an associative array with ids as keys, term slugs
+         *                                                as values). Default 'all'.
          *     @type bool         $count                  Whether to return a term count (true) or array of term objects
          *                                                (false). Will take precedence over `$fields` if true.
          *                                                Default false.
@@ -183 +190 @@
 
                 $this->query_var_defaults = array(
                         'taxonomy'               => null,
+                        'object_ids'             => null,
                         'orderby'                => 'name',
                         'order'                  => 'ASC',
                         'hide_empty'             => true,
@@ -397 +405 @@
                         $orderby = "ORDER BY $orderby";
                 }
 
-                $order = $this->parse_order( $this->query_vars['order'] );
+                // 'term_count' is a legal sort order only when joining the relationship table.
+                $_order = $this->query_vars['order'];
+                if ( 'term_count' === $_order && empty( $this->query_vars['object_ids'] ) ) {
+                        $_order = 'term_id';
+                }
+                $order = $this->parse_order( $_order );
 
                 if ( $taxonomies ) {
                         $this->sql_clauses['where']['taxonomy'] = "tt.taxonomy IN ('" . implode( "', '", array_map( 'esc_sql', $taxonomies ) ) . "')";
@@ -507 +520 @@
                         $this->sql_clauses['where']['description__like'] = $this->db->prepare( "tt.description LIKE %s", '%' . $this->db->esc_like( $args['description__like'] ) . '%' );
                 }
 
+                if ( ! empty( $args['object_ids'] ) ) {
+                        $object_ids = $args['object_ids'];
+                        if ( ! is_array( $object_ids ) ) {
+                                $object_ids = array( $object_ids );
+                        }
+
+                        $object_ids = implode( ', ', array_map( 'intval', $object_ids ) );
+                        $this->sql_clauses['where']['object_ids'] = "tr.object_id IN ($object_ids)";
+                }
+
+                /*
+                 * When query for object relationships, the 'count > 0' check
+                 * added by 'hide_empty' is superfluous.
+                 */
+                if ( ! empty( $args['object_ids'] ) ) {
+                        $args['hide_empty'] = false;
+                }
+
                 if ( '' !== $parent ) {
                         $parent = (int) $parent;
                         $this->sql_clauses['where']['parent'] = "tt.parent = '$parent'";
@@ -558 +589 @@
                 $selects = array();
                 switch ( $args['fields'] ) {
                         case 'all':
+                        case 'all_with_object_id' :
+                        case 'tt_ids' :
+                        case 'slugs' :
                                 $selects = array( 't.*', 'tt.*' );
+                                if ( 'all_with_object_id' === $args['fields'] && ! empty( $args['object_ids'] ) ) {
+                                        $selects[] = 'tr.object_id';
+                                }
                                 break;
                         case 'ids':
                         case 'id=>parent':
@@ -602 +639 @@
 
                 $join .= " INNER JOIN {$this->db->term_taxonomy} AS tt ON t.term_id = tt.term_id";
 
+                if ( ! empty( $this->query_vars['object_ids'] ) ) {
+                        $join .= " INNER JOIN {$this->db->term_relationships} AS tr ON tr.term_taxonomy_id = tt.term_taxonomy_id";
+                }
+
                 $where = implode( ' AND ', $this->sql_clauses['where'] );
 
                 /**
@@ -657 +698 @@
                 }
 
                 $terms = $this->db->get_results( $this->request );
-                if ( 'all' == $_fields ) {
+                if ( 'all' == $_fields || 'all_with_object_id' === $_fields ) {
                         update_term_cache( $terms );
                 }
 
@@ -708 +749 @@
                         }
                 }
 
+                /*
+                 * When querying for terms connected to objects, we may get
+                 * duplicate results. The duplicates should be preserved if
+                 * `$fields` is 'all_with_object_id', but should otherwise be
+                 * removed.
+                 */
+                if ( ! empty( $args['object_ids'] ) && 'all_with_object_id' != $_fields ) {
+                        $_tt_ids = $_terms = array();
+                        foreach ( $terms as $term ) {
+                                if ( isset( $_tt_ids[ $term->term_id ] ) ) {
+                                        continue;
+                                }
+
+                                $_tt_ids[ $term->term_id ] = 1;
+                                $_terms[] = $term;
+                        }
+
+                        $terms = $_terms;
+                }
+
                 $_terms = array();
                 if ( 'id=>parent' == $_fields ) {
                         foreach ( $terms as $term ) {
@@ -715 +776 @@
                         }
                 } elseif ( 'ids' == $_fields ) {
                         foreach ( $terms as $term ) {
-                                $_terms[] = $term->term_id;
+                                $_terms[] = (int) $term->term_id;
+                        }
+                } elseif ( 'tt_ids' == $_fields ) {
+                        foreach ( $terms as $term ) {
+                                $_terms[] = (int) $term->term_taxonomy_id;
                         }
                 } elseif ( 'names' == $_fields ) {
                         foreach ( $terms as $term ) {
                                 $_terms[] = $term->name;
                         }
+                } elseif ( 'slugs' == $_fields ) {
+                        foreach ( $terms as $term ) {
+                                $_terms[] = $term->slug;
+                        }
                 } elseif ( 'id=>name' == $_fields ) {
                         foreach ( $terms as $term ) {
                                 $_terms[ $term->term_id ] = $term->name;
@@ -746 +815 @@
 
                 wp_cache_add( $cache_key, $terms, 'terms', DAY_IN_SECONDS );
 
-                if ( 'all' === $_fields ) {
+                if ( 'all' === $_fields || 'all_with_object_id' === $_fields ) {
                         $terms = array_map( 'get_term', $terms );
                 }
 
@@ -766 +835 @@
         protected function parse_orderby( $orderby_raw ) {
                 $_orderby = strtolower( $orderby_raw );
                 $maybe_orderby_meta = false;
-                if ( 'count' == $_orderby ) {
-                        $orderby = 'tt.count';
-                } elseif ( 'name' == $_orderby ) {
-                        $orderby = 't.name';
-                } elseif ( 'slug' == $_orderby ) {
-                        $orderby = 't.slug';
+
+                if ( in_array( $_orderby, array( 'term_id', 'name', 'slug', 'term_group' ), true ) ) {
+                        $orderby = "t.$_orderby";
+                } elseif ( in_array( $_orderby, array( 'count', 'parent', 'taxonomy', 'term_taxonomy_id', 'description' ), true ) ) {
+                        $orderby = "tt.$_orderby";
+                } elseif ( 'term_order' === $_orderby ) {
+                        $orderby = 'tr.term_order';
                 } elseif ( 'include' == $_orderby && ! empty( $this->query_vars['include'] ) ) {
                         $include = implode( ',', wp_parse_id_list( $this->query_vars['include'] ) );
                         $orderby = "FIELD( t.term_id, $include )";
-                } elseif ( 'term_group' == $_orderby ) {
-                        $orderby = 't.term_group';
-                } elseif ( 'description' == $_orderby ) {
-                        $orderby = 'tt.description';
                 } elseif ( 'none' == $_orderby ) {
                         $orderby = '';
                 } elseif ( empty( $_orderby ) || 'id' == $_orderby || 'term_id' === $_orderby ) {

src/wp-includes/taxonomy.php

@@ -1983 +1983 @@
                 $object_ids = array($object_ids);
         $object_ids = array_map('intval', $object_ids);
 
-        $defaults = array(
-                'orderby' => 'name',
-                'order'   => 'ASC',
-                'fields'  => 'all',
-                'parent'  => '',
-                'update_term_meta_cache' => true,
-                'meta_query' => '',
-        );
-        $args = wp_parse_args( $args, $defaults );
-
-        $terms = array();
-        if ( count($taxonomies) > 1 ) {
-                foreach ( $taxonomies as $index => $taxonomy ) {
-                        $t = get_taxonomy($taxonomy);
-                        if ( isset($t->args) && is_array($t->args) && $args != array_merge($args, $t->args) ) {
-                                unset($taxonomies[$index]);
-                                $terms = array_merge($terms, wp_get_object_terms($object_ids, $taxonomy, array_merge($args, $t->args)));
-                        }
-                }
-        } else {
-                $t = get_taxonomy($taxonomies[0]);
-                if ( isset($t->args) && is_array($t->args) )
-                        $args = array_merge($args, $t->args);
-        }
-
-        $orderby = $args['orderby'];
-        $order = $args['order'];
-        $fields = $args['fields'];
-
-        if ( in_array( $orderby, array( 'term_id', 'name', 'slug', 'term_group' ) ) ) {
-                $orderby = "t.$orderby";
-        } elseif ( in_array( $orderby, array( 'count', 'parent', 'taxonomy', 'term_taxonomy_id' ) ) ) {
-                $orderby = "tt.$orderby";
-        } elseif ( 'term_order' === $orderby ) {
-                $orderby = 'tr.term_order';
-        } elseif ( 'none' === $orderby ) {
-                $orderby = '';
-                $order = '';
-        } else {
-                $orderby = 't.term_id';
-        }
-
-        // tt_ids queries can only be none or tr.term_taxonomy_id
-        if ( ('tt_ids' == $fields) && !empty($orderby) )
-                $orderby = 'tr.term_taxonomy_id';
-
-        if ( !empty($orderby) )
-                $orderby = "ORDER BY $orderby";
-
-        $order = strtoupper( $order );
-        if ( '' !== $order && ! in_array( $order, array( 'ASC', 'DESC' ) ) )
-                $order = 'ASC';
-
-        $taxonomy_array = $taxonomies;
-        $object_id_array = $object_ids;
-        $taxonomies = "'" . implode("', '", array_map( 'esc_sql', $taxonomies ) ) . "'";
-        $object_ids = implode(', ', $object_ids);
-
-        $select_this = '';
-        if ( 'all' == $fields ) {
-                $select_this = 't.*, tt.*';
-        } elseif ( 'ids' == $fields ) {
-                $select_this = 't.term_id';
-        } elseif ( 'names' == $fields ) {
-                $select_this = 't.name';
-        } elseif ( 'slugs' == $fields ) {
-                $select_this = 't.slug';
-        } elseif ( 'all_with_object_id' == $fields ) {
-                $select_this = 't.*, tt.*, tr.object_id';
-        }
-
-        $where = array(
-                "tt.taxonomy IN ($taxonomies)",
-                "tr.object_id IN ($object_ids)",
-        );
-
-        if ( '' !== $args['parent'] ) {
-                $where[] = $wpdb->prepare( 'tt.parent = %d', $args['parent'] );
-        }
-
-        // Meta query support.
-        $meta_query_join = '';
-        if ( ! empty( $args['meta_query'] ) ) {
-                $mquery = new WP_Meta_Query( $args['meta_query'] );
-                $mq_sql = $mquery->get_sql( 'term', 't', 'term_id' );
-
-                $meta_query_join .= $mq_sql['join'];
-
-                // Strip leading AND.
-                $where[] = preg_replace( '/^\s*AND/', '', $mq_sql['where'] );
-        }
-
-        $where = implode( ' AND ', $where );
-
-        $query = "SELECT $select_this FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON tt.term_id = t.term_id INNER JOIN $wpdb->term_relationships AS tr ON tr.term_taxonomy_id = tt.term_taxonomy_id $meta_query_join WHERE $where $orderby $order";
+        $args['taxonomy'] = $taxonomies;
+        $args['object_ids'] = $object_ids;
 
-        $objects = false;
-        if ( 'all' == $fields || 'all_with_object_id' == $fields ) {
-                $_terms = $wpdb->get_results( $query );
-                $object_id_index = array();
-                foreach ( $_terms as $key => $term ) {
-                        $term = sanitize_term( $term, $taxonomy, 'raw' );
-                        $_terms[ $key ] = $term;
-
-                        if ( isset( $term->object_id ) ) {
-                                $object_id_index[ $key ] = $term->object_id;
-                        }
-                }
-
-                update_term_cache( $_terms );
-                $_terms = array_map( 'get_term', $_terms );
-
-                // Re-add the object_id data, which is lost when fetching terms from cache.
-                if ( 'all_with_object_id' === $fields ) {
-                        foreach ( $_terms as $key => $_term ) {
-                                if ( isset( $object_id_index[ $key ] ) ) {
-                                        $_term->object_id = $object_id_index[ $key ];
-                                }
-                        }
-                }
-
-                $terms = array_merge( $terms, $_terms );
-                $objects = true;
-
-        } elseif ( 'ids' == $fields || 'names' == $fields || 'slugs' == $fields ) {
-                $_terms = $wpdb->get_col( $query );
-                $_field = ( 'ids' == $fields ) ? 'term_id' : 'name';
-                foreach ( $_terms as $key => $term ) {
-                        $_terms[$key] = sanitize_term_field( $_field, $term, $term, $taxonomy, 'raw' );
-                }
-                $terms = array_merge( $terms, $_terms );
-        } elseif ( 'tt_ids' == $fields ) {
-                $terms = $wpdb->get_col("SELECT tr.term_taxonomy_id FROM $wpdb->term_relationships AS tr INNER JOIN $wpdb->term_taxonomy AS tt ON tr.term_taxonomy_id = tt.term_taxonomy_id WHERE tr.object_id IN ($object_ids) AND tt.taxonomy IN ($taxonomies) $orderby $order");
-                foreach ( $terms as $key => $tt_id ) {
-                        $terms[$key] = sanitize_term_field( 'term_taxonomy_id', $tt_id, 0, $taxonomy, 'raw' ); // 0 should be the term id, however is not needed when using raw context.
-                }
-        }
-
-        // Update termmeta cache, if necessary.
-        if ( $args['update_term_meta_cache'] && ( 'all' === $fields || 'all_with_object_id' === $fields || 'ids' === $fields ) ) {
-                if ( 'ids' === $fields ) {
-                        $term_ids = $terms;
-                } else {
-                        $term_ids = wp_list_pluck( $terms, 'term_id' );
-                }
-
-                update_termmeta_cache( $term_ids );
-        }
-
-        if ( ! $terms ) {
-                $terms = array();
-        } elseif ( $objects && 'all_with_object_id' !== $fields ) {
-                $_tt_ids = array();
-                $_terms = array();
-                foreach ( $terms as $term ) {
-                        if ( in_array( $term->term_taxonomy_id, $_tt_ids ) ) {
-                                continue;
-                        }
-
-                        $_tt_ids[] = $term->term_taxonomy_id;
-                        $_terms[] = $term;
-                }
-                $terms = $_terms;
-        } elseif ( ! $objects ) {
-                $terms = array_values( array_unique( $terms ) );
-        }
+        $terms = get_terms( $args );
 
         /**
          * Filters the terms for a given object or objects.
          *
          * @since 4.2.0
          *
-         * @param array $terms           An array of terms for the given object or objects.
-         * @param array $object_id_array Array of object IDs for which `$terms` were retrieved.
-         * @param array $taxonomy_array  Array of taxonomies from which `$terms` were retrieved.
-         * @param array $args            An array of arguments for retrieving terms for the given
-         *                               object(s). See wp_get_object_terms() for details.
+         * @param array $terms      An array of terms for the given object or objects.
+         * @param array $object_ids Array of object IDs for which `$terms` were retrieved.
+         * @param array $taxonomies Array of taxonomies from which `$terms` were retrieved.
+         * @param array $args       An array of arguments for retrieving terms for the given
+         *                          object(s). See wp_get_object_terms() for details.
          */
-        $terms = apply_filters( 'get_object_terms', $terms, $object_id_array, $taxonomy_array, $args );
+        $terms = apply_filters( 'get_object_terms', $terms, $object_ids, $taxonomies, $args );
+
+        $object_ids = implode( ',', $object_ids );
+        $taxonomies = implode( ',', $taxonomies );
 
         /**
          * Filters the terms for a given object or objects.

tests/phpunit/tests/term/query.php

@@ -185 +185 @@
 
                 $this->assertEquals( array( $t1, $t2 ), $terms );
         }
+
+        /**
+         * @ticket 37198
+         */
+        public function test_object_ids_single() {
+                register_taxonomy( 'wptests_tax_1', 'post' );
+
+                $p = self::factory()->post->create();
+                $t = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax_1' ) );
+
+                wp_set_object_terms( $p, array( $t ), 'wptests_tax_1' );
+
+                $query = new WP_Term_Query( array(
+                        'taxonomy' => 'wptests_tax_1',
+                        'object_ids' => $p,
+                        'fields' => 'ids',
+                ) );
+
+                $this->assertEqualSets( array( $t ), $query->terms );
+        }
+
+        /**
+         * @ticket 37198
+         */
+        public function test_object_ids_array() {
+                register_taxonomy( 'wptests_tax_1', 'post' );
+
+                $p = self::factory()->post->create();
+                $t = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax_1' ) );
+
+                wp_set_object_terms( $p, array( $t ), 'wptests_tax_1' );
+
+                $query = new WP_Term_Query( array(
+                        'taxonomy' => 'wptests_tax_1',
+                        'object_ids' => array( $p ),
+                        'fields' => 'ids',
+                ) );
+
+                $this->assertEqualSets( array( $t ), $query->terms );
+        }
+
+        /**
+         * @ticket 37198
+         */
+        public function test_duplicates_should_be_removed_for_fields_all() {
+                register_taxonomy( 'wptests_tax_1', 'post' );
+                $posts = self::factory()->post->create_many( 2 );
+                $t = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax_1' ) );
+
+                foreach ( $posts as $p ) {
+                        wp_set_object_terms( $p, array( $t ), 'wptests_tax_1' );
+                }
+
+                $query = new WP_Term_Query( array(
+                        'taxonomy' => 'wptests_tax_1',
+                        'object_ids' => $posts,
+                        'fields' => 'all',
+                ) );
+
+                $this->assertSame( 1, count( $query->terms ) );
+                $this->assertSame( $t, reset( $query->terms )->term_id );
+        }
+
+        /**
+         * @ticket 37198
+         */
+        public function test_duplicates_should_not_be_removed_for_fields_all_with_object_id() {
+                register_taxonomy( 'wptests_tax_1', 'post' );
+                $posts = self::factory()->post->create_many( 2 );
+                $t = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax_1' ) );
+
+                foreach ( $posts as $p ) {
+                        wp_set_object_terms( $p, array( $t ), 'wptests_tax_1' );
+                }
+
+                $query = new WP_Term_Query( array(
+                        'taxonomy' => 'wptests_tax_1',
+                        'object_ids' => $posts,
+                        'fields' => 'all_with_object_id',
+                ) );
+
+                $this->assertSame( 2, count( $query->terms ) );
+                foreach ( $query->terms as $term ) {
+                        $this->assertSame( $t, $term->term_id );
+                }
+        }
+
+        /**
+         * @ticket 37198
+         * @group cache
+         */
+        public function test_object_ids_cache_should_be_invalidated_by_term_relationship_change() {
+                register_taxonomy( 'wptests_tax_1', 'post' );
+
+                $p = self::factory()->post->create();
+                $terms = self::factory()->term->create_many( 2, array( 'taxonomy' => 'wptests_tax_1' ) );
+
+                wp_set_object_terms( $p, array( $terms[0] ), 'wptests_tax_1' );
+
+                $query = new WP_Term_Query( array(
+                        'taxonomy' => 'wptests_tax_1',
+                        'object_ids' => $p,
+                        'fields' => 'ids',
+                ) );
+                $found = $query->get_terms();
+
+                $this->assertEqualSets( array( $terms[0] ), $found );
+
+                wp_set_object_terms( $p, array( $terms[1] ), 'wptests_tax_1' );
+
+                $query = new WP_Term_Query( array(
+                        'taxonomy' => 'wptests_tax_1',
+                        'object_ids' => $p,
+                        'fields' => 'ids',
+                ) );
+                $found = $query->get_terms();
+
+                $this->assertEqualSets( array( $terms[1] ), $found );
+        }
 }

tests/phpunit/tests/term/wpGetObjectTerms.php

@@ -23 +23 @@
                 $this->assertEquals( 3, count($tt_1) );
 
                 // make sure they're correct
-                $terms = wp_get_object_terms($post_id, $this->taxonomy, array('fields' => 'slugs', 'orderby' => 't.term_id'));
+                $terms = wp_get_object_terms($post_id, $this->taxonomy, array('fields' => 'slugs', 'orderby' => 'term_id'));
                 $this->assertEquals( $terms_1_slugs, $terms );
         }
 
@@ -360 +360 @@
          * @ticket 15675
          */
         public function test_parent() {
+                register_taxonomy( 'wptests_tax2', 'post', array(
+                        'hierarchical' => true,
+                ) );
+
                 $t1 = self::factory()->term->create( array(
-                        'taxonomy' => $this->taxonomy,
+                        'taxonomy' => 'wptests_tax2',
                 ) );
                 $t2 = self::factory()->term->create( array(
-                        'taxonomy' => $this->taxonomy,
+                        'taxonomy' => 'wptests_tax2',
                 ) );
                 $t3 = self::factory()->term->create( array(
-                        'taxonomy' => $this->taxonomy,
+                        'taxonomy' => 'wptests_tax2',
                         'parent' => $t1,
                 ) );
                 $t4 = self::factory()->term->create( array(
-                        'taxonomy' => $this->taxonomy,
+                        'taxonomy' => 'wptests_tax2',
                         'parent' => $t2,
                 ) );
 
                 $p = self::factory()->post->create();
 
-                wp_set_object_terms( $p, array( $t1, $t2, $t3, $t3 ), $this->taxonomy );
+                wp_set_object_terms( $p, array( $t1, $t2, $t3, $t3 ), 'wptests_tax2' );
 
-                $found = wp_get_object_terms( $p, $this->taxonomy, array(
+                $found = wp_get_object_terms( $p, 'wptests_tax2', array(
                         'parent' => $t1,
                         'fields' => 'ids',
                 ) );

tests/phpunit/tests/term/wpSetObjectTerms.php

@@ -259 +259 @@
                 $this->assertEquals( 3, count($tt_1) );
 
                 // make sure they're correct
-                $terms = wp_get_object_terms($post_id, $this->taxonomy, array('fields' => 'ids', 'orderby' => 't.term_id'));
+                $terms = wp_get_object_terms($post_id, $this->taxonomy, array('fields' => 'ids', 'orderby' => 'term_id'));
                 $this->assertEquals( $terms_1, $terms );
 
                 // change the terms
@@ -267 +267 @@
                 $this->assertEquals( 2, count($tt_2) );
 
                 // make sure they're correct
-                $terms = wp_get_object_terms($post_id, $this->taxonomy, array('fields' => 'ids', 'orderby' => 't.term_id'));
+                $terms = wp_get_object_terms($post_id, $this->taxonomy, array('fields' => 'ids', 'orderby' => 'term_id'));
                 $this->assertEquals( $terms_2, $terms );
 
                 // make sure the tt id for 'bar' matches
@@ -288 +288 @@
                 $this->assertEquals( 3, count($tt_1) );
 
                 // make sure they're correct
-                $terms = wp_get_object_terms($post_id, $this->taxonomy, array('fields' => 'names', 'orderby' => 't.term_id'));
+                $terms = wp_get_object_terms($post_id, $this->taxonomy, array('fields' => 'names', 'orderby' => 'term_id'));
                 $this->assertEquals( $terms_1, $terms );
 
                 // change the terms
@@ -296 +296 @@
                 $this->assertEquals( 2, count($tt_2) );
 
                 // make sure they're correct
-                $terms = wp_get_object_terms($post_id, $this->taxonomy, array('fields' => 'names', 'orderby' => 't.term_id'));
+                $terms = wp_get_object_terms($post_id, $this->taxonomy, array('fields' => 'names', 'orderby' => 'term_id'));
                 $this->assertEquals( $terms_2, $terms );
 
                 // make sure the tt id for 'bar' matches