WordPress.org
Get WordPress

Make WordPress Core

Changeset 5726


Ignore:
Timestamp:
06/19/2007 12:33:44 AM (19 years ago)
Author:
ryan
Message:

Add some taxonomy validation. Rearrange funcs.

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/wp-admin/includes/bookmark.php

    r5712 r5726  
    5555function wp_get_link_cats($link_id = 0) {
    5656
    57         $cats = get_object_terms($link_id, 'link_category', 'fields=ids');
     57        $cats = wp_get_object_terms($link_id, 'link_category', 'fields=ids');
    5858
    5959        return array_unique($cats);

  • trunk/wp-includes/category-template.php

    r5715 r5726  
    6969        $categories = get_object_term_cache($id, 'category');
    7070        if ( false === $categories )
    71                 $categories = get_object_terms($id, 'category');
     71                $categories = wp_get_object_terms($id, 'category');
    7272
    7373        if ( !empty($categories) )
    … …  
    421421        $tags = get_object_term_cache($id, 'post_tag');
    422422        if ( false === $tags )
    423                 $tags = get_object_terms($id, 'post_tag');
     423                $tags = wp_get_object_terms($id, 'post_tag');
    424424
    425425        $tags = apply_filters( 'get_the_tags', $tags );

  • trunk/wp-includes/link-template.php

    r5716 r5726  
    361361        if ( $in_same_cat ) {
    362362                $join = " INNER JOIN $wpdb->term_relationships AS tr ON $wpdb->posts.ID = tr.object_id ";
    363                 $cat_array = get_object_terms($post->ID, 'category', 'fields=tt_ids');
     363                $cat_array = wp_get_object_terms($post->ID, 'category', 'fields=tt_ids');
    364364                $join .= ' AND (tr.term_taxonomy_id = ' . intval($cat_array[0]);
    365365                for ( $i = 1; $i < (count($cat_array)); $i++ ) {
    … …  
    394394        if ( $in_same_cat ) {
    395395                $join = " INNER JOIN $wpdb->term_relationships AS tr ON $wpdb->posts.ID = tr.object_id ";
    396                 $cat_array = get_object_terms($post->ID, 'category', 'fields=tt_ids');
     396                $cat_array = wp_get_object_terms($post->ID, 'category', 'fields=tt_ids');
    397397                $join .= ' AND (tr.term_taxonomy_id = ' . intval($cat_array[0]);
    398398                for ( $i = 1; $i < (count($cat_array)); $i++ ) {

  • trunk/wp-includes/post.php

    r5708 r5726  
    441441        $args = wp_parse_args( $args, $defaults );
    442442
    443         $cats = get_object_terms($post_id, 'category', $args);
     443        $cats = wp_get_object_terms($post_id, 'category', $args);
    444444        return $cats;
    445445}
    … …  
    451451        $args = wp_parse_args( $args, $defaults );
    452452
    453         $tags = get_object_terms($post_id, 'post_tag', $args);
     453        $tags = wp_get_object_terms($post_id, 'post_tag', $args);
    454454
    455455        return $tags;

  • trunk/wp-includes/taxonomy.php

    r5708 r5726  
    11<?php
     2
     3//
     4// Taxonomy Registration
     5//
    26
    37$wp_taxonomies = array();
    … …  
    610$wp_taxonomies['link_category'] = (object) array('name' => 'link_category', 'object_type' => 'link', 'hierarchical' => false);
    711
    8 function is_taxonomy( $taxonomy ) {
    9         global $wp_taxonomies;
    10 
    11         return isset($wp_taxonomies[$taxonomy]);       
    12 }
    13 
    14 function get_taxonomy( $taxonomy ) {
    15         global $wp_taxonomies;
    16 
    17         if ( ! is_taxonomy($taxonomy) )
    18                 return false;
    19 
    20         return $wp_taxonomies[$taxonomy];
    21 }
    22 
    23 function is_taxonomy_hierarchical($taxonomy) {
    24         if ( ! is_taxonomy($taxonomy) )
    25                 return false;
    26 
    27         $taxonomy = get_taxonomy($taxonomy);
    28         return $taxonomy->hierarchical;
    29 }
    30 
    31 function register_taxonomy( $taxonomy, $object_type, $args = array() ) {
    32         global $wp_taxonomies;
    33 
    34         $defaults = array('hierarchical' => false, 'update_count_callback' => '');
    35         $args = wp_parse_args($args, $defaults);
    36 
    37         $args['name'] = $taxonomy;
    38         $args['object_type'] = $object_type;
    39         $wp_taxonomies[$taxonomy] = (object) $args;
    40 }
    41 
    42 function wp_count_terms( $taxonomy, $args = array() ) {
    43         global $wpdb;
    44 
    45         $defaults = array('ignore_empty' => false);
    46         $args = wp_parse_args($args, $defaults);
    47         extract($args, EXTR_SKIP);
    48 
    49         $where = '';
    50         if ( $ignore_empty )
    51                 $where = 'AND count > 0';
    52 
    53         return $wpdb->get_var("SELECT COUNT(*) FROM $wpdb->term_taxonomy WHERE taxonomy = '$taxonomy' $where");
    54 }
    55 
    56 /**
    57  * Adds a new term to the database.  Optionally marks it as an alias of an existing term.
    58  * @param int|string $term The term to add or update.
    59  * @param string $taxonomy The taxonomy to which to add the term
    60  * @param int|string $alias_of The id or slug of the new term's alias.
    61  */
    62 function wp_insert_term( $term, $taxonomy, $args = array() ) {
    63         global $wpdb;
    64 
    65         if ( ! is_taxonomy($taxonomy) )
    66                 return new WP_Error('invalid_taxonomy', __('Invalid taxonomy'));
    67 
    68         $defaults = array( 'alias_of' => '', 'description' => '', 'parent' => 0, 'slug' => '');
    69         $args = wp_parse_args($args, $defaults);
    70         $args['name'] = $term;
    71         $args = sanitize_term($args, $taxonomy, 'db');
    72         extract($args, EXTR_SKIP);
    73 
    74         if ( empty($slug) )
    75                 $slug = sanitize_title($name);
    76         else
    77                 $slug = sanitize_title($slug);
    78 
    79         $term_group = 0;       
    80         if ( $alias_of ) {
    81                 $alias = $wpdb->fetch_row("SELECT term_id, term_group FROM $wpdb->terms WHERE slug = '$alias_of'");
    82                 if ( $alias->term_group ) {
    83                         // The alias we want is already in a group, so let's use that one.
    84                         $term_group = $alias->term_group;
    85                 } else {
    86                         // The alias isn't in a group, so let's create a new one and firstly add the alias term to it.
    87                         $term_group = $wpdb->get_var("SELECT MAX(term_group) FROM $wpdb->terms GROUP BY term_group") + 1;
    88                         $wpdb->query("UPDATE $wpdb->terms SET term_group = $term_group WHERE term_id = $alias->term_id");
    89                 }
    90         }
    91 
    92         if ( ! $term_id = is_term($slug) ) {
    93                 $wpdb->query("INSERT INTO $wpdb->terms (name, slug, term_group) VALUES ('$name', '$slug', '$term_group')");
    94                 $term_id = (int) $wpdb->insert_id;
    95         }
    96 
    97         if ( empty($slug) ) {
    98                 $slug = sanitize_title($slug, $term_id);
    99                 $wpdb->query("UPDATE $wpdb->terms SET slug = '$slug' WHERE term_id = '$term_id'");
    100         }
    101 
    102         $tt_id = $wpdb->get_var("SELECT tt.term_taxonomy_id FROM $wpdb->term_taxonomy AS tt INNER JOIN $wpdb->terms AS t ON tt.term_id = t.term_id WHERE tt.taxonomy = '$taxonomy' AND t.term_id = $term_id");
    103 
    104         if ( !empty($tt_id) )
    105                 return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id);
    106 
    107         $wpdb->query("INSERT INTO $wpdb->term_taxonomy (term_id, taxonomy, description, parent, count) VALUES ('$term_id', '$taxonomy', '$description', '$parent', '0')");
    108         $tt_id = (int) $wpdb->insert_id;
    109 
    110         do_action("create_term", $term_id, $tt_id);
    111         do_action("create_$taxonomy", $term_id, $tt_id);
    112 
    113         $term_id = apply_filters('term_id_filter', $term_id, $tt_id);
    114 
    115         clean_term_cache($term_id, $taxonomy);
    116 
    117         do_action("created_term", $term_id, $tt_id);
    118         do_action("created_$taxonomy", $term_id, $tt_id);
    119 
    120         return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id);
    121 }
    122 
    123 function wp_delete_object_term_relationships( $object_id, $taxonomies ) {
    124         global $wpdb;
    125 
    126         $object_id = (int) $object_id;
    127 
    128         if ( !is_array($taxonomies) )
    129                 $taxonomies = array($taxonomies);
    130 
    131         foreach ( $taxonomies as $taxonomy ) {
    132                 $terms = get_object_terms($object_id, $taxonomy, 'fields=tt_ids');
    133                 $in_terms = "'" . implode("', '", $terms) . "'";
    134                 $wpdb->query("DELETE FROM $wpdb->term_relationships WHERE object_id = '$object_id' AND term_taxonomy_id IN ($in_terms)");
    135 
    136                 wp_update_term_count($terms, $taxonomy);
    137         }
    138 
    139         // TODO clear the cache
    140 }
    141 
    142 /**
    143  * Removes a term from the database.
    144  */
    145 function wp_delete_term( $term, $taxonomy, $args = array() ) {
    146         global $wpdb;
    147 
    148         $term = (int) $term;
    149 
    150         if ( ! $ids = is_term($term, $taxonomy) )
    151                 return false;
    152         $tt_id = $ids['term_taxonomy_id'];
    153 
    154         $defaults = array();
    155         $args = wp_parse_args($args, $defaults);
    156         extract($args, EXTR_SKIP);
    157 
    158         if ( isset($default) ) {
    159                 $default = (int) $default;
    160                 if ( ! is_term($default, $taxonomy) )
    161                         unset($default);
    162         }
    163 
    164         // Update children to point to new parent
    165         if ( is_taxonomy_hierarchical($taxonomy) ) {
    166                 $term_obj = get_term($term, $taxonomy);
    167                 $parent = $term_obj->parent;
    168 
    169                 $wpdb->query("UPDATE $wpdb->term_taxonomy SET parent = '$parent' WHERE parent = '$term_obj->term_id' AND taxonomy = '$taxonomy'");
    170         }
    171 
    172         $objects = $wpdb->get_col("SELECT object_id FROM $wpdb->term_relationships WHERE term_taxonomy_id = '$tt_id'");
    173 
    174         foreach ( (array) $objects as $object ) {
    175                 $terms = get_object_terms($object, $taxonomy, 'fields=ids');
    176                 if ( 1 == count($terms) && isset($default) )
    177                         $terms = array($default);
    178                 else
    179                         $terms = array_diff($terms, array($term));
    180                 wp_set_object_terms($object, $terms, $taxonomy);
    181         }
    182 
    183         $wpdb->query("DELETE FROM $wpdb->term_taxonomy WHERE term_taxonomy_id = '$tt_id'");
    184 
    185         // Delete the term if no taxonomies use it.
    186         if ( !$wpdb->get_var("SELECT COUNT(*) FROM $wpdb->term_taxonomy WHERE term_id = '$term'") )
    187                 $wpdb->query("DELETE FROM $wpdb->terms WHERE term_id = '$term'");
    188 
    189         clean_term_cache($term, $taxonomy);
    190 
    191         do_action("delete_$taxonomy", $term, $tt_id);
    192 
    193         return true;
    194 }
    195 
    196 function wp_update_term( $term, $taxonomy, $args = array() ) {
    197         global $wpdb;
    198 
    199         if ( ! is_taxonomy($taxonomy) )
    200                 return new WP_Error('invalid_taxonomy', __('Invalid taxonomy'));
    201 
    202         $term_id = (int) $term;
    203 
    204         // First, get all of the original args
    205         $term = get_term ($term_id, $taxonomy, ARRAY_A);
    206 
    207         $term = sanitize_term($term, $taxonomy, 'db');
    208 
    209         // Escape data pulled from DB.
    210         $term = add_magic_quotes($term);
    211 
    212         // Merge old and new args with new args overwriting old ones.
    213         $args = array_merge($term, $args);
    214 
    215         $defaults = array( 'alias_of' => '', 'description' => '', 'parent' => 0, 'slug' => '');
    216         $args = wp_parse_args($args, $defaults);
    217         extract($args, EXTR_SKIP);
    218 
    219         if ( empty($slug) )
    220                 $slug = sanitize_title($name);
    221         else
    222                 $slug = sanitize_title($slug);
    223 
    224         if ( $alias_of ) {
    225                 $alias = $wpdb->fetch_row("SELECT term_id, term_group FROM $wpdb->terms WHERE slug = '$alias_of'");
    226                 if ( $alias->term_group ) {
    227                         // The alias we want is already in a group, so let's use that one.
    228                         $term_group = $alias->term_group;
    229                 } else {
    230                         // The alias isn't in a group, so let's create a new one and firstly add the alias term to it.
    231                         $term_group = $wpdb->get_var("SELECT MAX(term_group) FROM $wpdb->terms GROUP BY term_group") + 1;
    232                         $wpdb->query("UPDATE $wpdb->terms SET term_group = $term_group WHERE term_id = $alias->term_id");
    233                 }
    234         }
    235 
    236         $wpdb->query("UPDATE $wpdb->terms SET name = '$name', slug = '$slug', term_group = '$term_group' WHERE term_id = '$term_id'");
    237 
    238         if ( empty($slug) ) {
    239                 $slug = sanitize_title($name, $term_id);
    240                 $wpdb->query("UPDATE $wpdb->terms SET slug = '$slug' WHERE term_id = '$term_id'");
    241         }
    242 
    243         $tt_id = $wpdb->get_var("SELECT tt.term_taxonomy_id FROM $wpdb->term_taxonomy AS tt INNER JOIN $wpdb->terms AS t ON tt.term_id = t.term_id WHERE tt.taxonomy = '$taxonomy' AND t.term_id = $term_id");
    244 
    245         $wpdb->query("UPDATE $wpdb->term_taxonomy SET term_id = '$term_id', taxonomy = '$taxonomy', description = '$description', parent = '$parent' WHERE term_taxonomy_id = '$tt_id'");
    246 
    247         do_action("edit_term", $term_id, $tt_id);
    248         do_action("edit_$taxonomy", $term_id, $tt_id);
    249 
    250         $term_id = apply_filters('term_id_filter', $term_id, $tt_id);
    251 
    252         clean_term_cache($term_id, $taxonomy);
    253 
    254         do_action("edited_term", $term_id, $tt_id);
    255         do_action("edited_$taxonomy", $term_id, $tt_id);
    256 
    257         return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id);
    258 }
    259 
    260 function wp_update_term_count( $terms, $taxonomy ) {
    261         global $wpdb;
    262 
    263         if ( empty($terms) )
    264                 return false;
    265 
    266         if ( !is_array($terms) )
    267                 $terms = array($terms);
    268 
    269         $terms = array_map('intval', $terms);
    270 
    271         $taxonomy = get_taxonomy($taxonomy);
    272         if ( isset($taxonomy->update_count_callback) )
    273                 return call_user_func($taxonomy->update_count_callback, $terms);
    274 
    275         // Default count updater
    276         $count = $wpdb->get_var("SELECT COUNT(*) FROM $wpdb->term_relationships WHERE term_taxonomy_id = '$term'");
    277         $wpdb->query("UPDATE $wpdb->term_taxonomy SET count = '$count' WHERE term_taxonomy_id = '$term'");
    278 
    279         return true;
    280 }
    281 
    282 /**
    283  * Returns the index of a defined term, or 0 (false) if the term doesn't exist.
    284  */
    285 function is_term($term, $taxonomy = '') {
    286         global $wpdb;
    287 
    288         if ( is_int($term) ) {
    289                 $where = "t.term_id = '$term'";
    290         } else {
    291                 if ( ! $term = sanitize_title($term) )
    292                         return 0;
    293                 $where = "t.slug = '$term'";
    294         }
    295 
    296         $term_id = $wpdb->get_var("SELECT term_id FROM $wpdb->terms as t WHERE $where");
    297 
    298         if ( empty($taxonomy) || empty($term_id) )
    299                 return $term_id;
    300 
    301         return $wpdb->get_row("SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $where AND tt.taxonomy = '$taxonomy'", ARRAY_A);
    302 }
    303 
    304 /**
    305  * Given an array of terms, returns those that are defined term slugs.  Ignores integers.
    306  * @param array $terms The term slugs to check for a definition.
    307  */
    308 function get_defined_terms($terms) {
    309         global $wpdb;
    310 
    311         foreach ( $terms as $term ) {
    312                 if ( !is_int($term) )
    313                         $searches[] = $term;
    314         }
    315 
    316         $terms = "'" . implode("', '", $searches) . "'";
    317         return $wpdb->get_col("SELECT slug FROM $wpdb->terms WHERE slug IN ($terms)");
    318 }
    319 
    320 /**
    321  * Relates an object (post, link etc) to a term and taxonomy type.  Creates the term and taxonomy
    322  * relationship if it doesn't already exist.  Creates a term if it doesn't exist (using the slug).
    323  * @param int $object_id The object to relate to.
    324  * @param array|int|string $term The slug or id of the term.
    325  * @param array|string $taxonomy The context in which to relate the term to the object.
    326  */
    327 function wp_set_object_terms($object_id, $terms, $taxonomy, $append = false) {
    328         global $wpdb;
    329 
    330         $object_id = (int) $object_id;
    331 
    332         if ( ! is_taxonomy($taxonomy) )
    333                 return false;
    334 
    335         if ( !is_array($terms) )
    336                 $terms = array($terms);
    337 
    338         if ( ! $append )
    339                 $old_terms =  get_object_terms($object_id, $taxonomy, 'fields=tt_ids');
    340 
    341         $tt_ids = array();
    342         $term_ids = array();
    343 
    344         foreach ($terms as $term) {
    345                 if ( !$id = is_term($term, $taxonomy) )
    346                         $id = wp_insert_term($term, $taxonomy);
    347                 $term_ids[] = $id['term_id'];
    348                 $id = $id['term_taxonomy_id'];
    349                 $tt_ids[] = $id;
    350 
    351                 if ( $wpdb->get_var("SELECT term_taxonomy_id FROM $wpdb->term_relationships WHERE object_id = '$object_id' AND term_taxonomy_id = '$id'") )
    352                         continue;
    353                 $wpdb->query("INSERT INTO $wpdb->term_relationships (object_id, term_taxonomy_id) VALUES ('$object_id', '$id')");
    354         }
    355 
    356         wp_update_term_count($tt_ids, $taxonomy);
    357 
    358         if ( ! $append ) {
    359                 $delete_terms = array_diff($old_terms, $tt_ids);
    360                 if ( $delete_terms ) {
    361                         $delete_terms = "'" . implode("', '", $delete_terms) . "'";
    362                         $wpdb->query("DELETE FROM $wpdb->term_relationships WHERE term_taxonomy_id IN ($delete_terms)");
    363                         $wpdb->query("UPDATE $wpdb->term_taxonomy SET count = count - 1 WHERE term_taxonomy_id IN ($delete_terms)");
    364                         wp_update_term_count($delete_terms, $taxonomy);
    365                 }
    366         }
    367 
    368         // TODO clean old_terms. Need term_id instead of tt_id
    369         clean_term_cache($term_ids, $taxonomy);
    370 
    371         return $tt_ids;
    372 }
    373 
    374 function get_objects_in_term( $terms, $taxonomies, $args = array() ) {
    375         global $wpdb;
    376 
    377         if ( !is_array( $terms) )
    378                 $terms = array($terms);
    379 
    380         if ( !is_array($taxonomies) )
    381                 $taxonomies = array($taxonomies);
    382 
    383         $defaults = array('order' => 'ASC');
    384         $args = wp_parse_args( $args, $defaults );
    385         extract($args, EXTR_SKIP);
    386 
    387         $terms = array_map('intval', $terms);
    388 
    389         $taxonomies = "'" . implode("', '", $taxonomies) . "'";
    390         $terms = "'" . implode("', '", $terms) . "'";
    391 
    392         $object_ids = $wpdb->get_col("SELECT tr.object_id FROM $wpdb->term_relationships AS tr INNER JOIN $wpdb->term_taxonomy AS tt ON tr.term_taxonomy_id = tt.term_taxonomy_id WHERE tt.taxonomy IN ($taxonomies) AND tt.term_id IN ($terms) ORDER BY tr.object_id $order");
    393 
    394         if ( ! $object_ids )
    395                 return array();
    396 
    397         return $object_ids;
    398 }
    399 
    40012function get_object_taxonomies($object_type) {
    40113        global $wp_taxonomies;
    … …  
    41022}
    41123
    412 /**
    413  * Returns the terms associated with the given object(s), in the supplied taxonomies.
    414  * @param int|array $object_id The id of the object(s)) to retrieve for.
    415  * @param string|array $taxonomies The taxonomies to retrieve terms from.
    416  * @return array The requested term data.                       
    417  */
    418 function get_object_terms($object_ids, $taxonomies, $args = array()) {
    419         global $wpdb;
     24function get_taxonomy( $taxonomy ) {
     25        global $wp_taxonomies;
     26
     27        if ( ! is_taxonomy($taxonomy) )
     28                return false;
     29
     30        return $wp_taxonomies[$taxonomy];
     31}
     32
     33function is_taxonomy( $taxonomy ) {
     34        global $wp_taxonomies;
     35
     36        return isset($wp_taxonomies[$taxonomy]);       
     37}
     38
     39function is_taxonomy_hierarchical($taxonomy) {
     40        if ( ! is_taxonomy($taxonomy) )
     41                return false;
     42
     43        $taxonomy = get_taxonomy($taxonomy);
     44        return $taxonomy->hierarchical;
     45}
     46
     47function register_taxonomy( $taxonomy, $object_type, $args = array() ) {
     48        global $wp_taxonomies;
     49
     50        $defaults = array('hierarchical' => false, 'update_count_callback' => '');
     51        $args = wp_parse_args($args, $defaults);
     52
     53        $args['name'] = $taxonomy;
     54        $args['object_type'] = $object_type;
     55        $wp_taxonomies[$taxonomy] = (object) $args;
     56}
     57
     58//
     59// Term API
     60//
     61
     62function get_objects_in_term( $terms, $taxonomies, $args = array() ) {
     63        global $wpdb;
     64
     65        if ( !is_array( $terms) )
     66                $terms = array($terms);
    42067
    42168        if ( !is_array($taxonomies) )
    42269                $taxonomies = array($taxonomies);
    42370
    424         if ( !is_array($object_ids) )
    425                 $object_ids = array($object_ids);
    426         $object_ids = array_map('intval', $object_ids);
    427 
    428         $defaults = array('orderby' => 'name', 'order' => 'ASC', 'fields' => 'all');
     71        foreach ( $taxonomies as $taxonomy ) {
     72                if ( ! is_taxonomy($taxonomy) )
     73                        return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));
     74        }
     75
     76        $defaults = array('order' => 'ASC');
    42977        $args = wp_parse_args( $args, $defaults );
    43078        extract($args, EXTR_SKIP);
    43179
    432         if ( 'count' == $orderby )
    433                 $orderby = 'tt.count';
    434         else if ( 'name' == $orderby )
    435                 $orderby = 't.name';
     80        $terms = array_map('intval', $terms);
    43681
    43782        $taxonomies = "'" . implode("', '", $taxonomies) . "'";
    438         $object_ids = implode(', ', $object_ids);
    439 
    440         if ( 'all' == $fields )
    441                 $select_this = 't.*, tt.*';
    442         else if ( 'ids' == $fields )
    443                 $select_this = 't.term_id';
    444         else if ( 'all_with_object_id' == $fields )
    445                 $select_this = 't.*, tt.*, tr.object_id';
    446 
    447         $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 WHERE tt.taxonomy IN ($taxonomies) AND tr.object_id IN ($object_ids) ORDER BY $orderby $order";
    448 
    449         if ( 'all' == $fields || 'all_with_object_id' == $fields ) {
    450                 $terms = $wpdb->get_results($query);
    451                 update_term_cache($terms);
    452         } else if ( 'ids' == $fields ) {
    453                 $terms = $wpdb->get_col($query);
    454         } else if ( 'tt_ids' == $fields ) {
    455                 $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) ORDER BY tr.term_taxonomy_id $order");
    456         }
    457 
    458         if ( ! $terms )
     83        $terms = "'" . implode("', '", $terms) . "'";
     84
     85        $object_ids = $wpdb->get_col("SELECT tr.object_id FROM $wpdb->term_relationships AS tr INNER JOIN $wpdb->term_taxonomy AS tt ON tr.term_taxonomy_id = tt.term_taxonomy_id WHERE tt.taxonomy IN ($taxonomies) AND tt.term_id IN ($terms) ORDER BY tr.object_id $order");
     86
     87        if ( ! $object_ids )
    45988                return array();
    46089
    461         return $terms;
     90        return $object_ids;
     91}
     92
     93function &get_term(&$term, $taxonomy, $output = OBJECT) {
     94        global $wpdb;
     95
     96        if ( empty($term) )
     97                return null;
     98
     99        if ( ! is_taxonomy($taxonomy) )
     100                return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));
     101
     102        if ( is_object($term) ) {
     103                wp_cache_add($term->term_id, $term, $taxonomy);
     104                $_term = $term;
     105        } else {
     106                $term = (int) $term;
     107                if ( ! $_term = wp_cache_get($term, $taxonomy) ) {
     108                        $_term = $wpdb->get_row("SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy = '$taxonomy' AND t.term_id = '$term' LIMIT 1");
     109                        wp_cache_add($term, $_term, $taxonomy);
     110                }
     111        }
     112
     113        $_term = apply_filters('get_term', $_term, $taxonomy);
     114        $_term = apply_filters("get_$taxonomy", $_term, $taxonomy);
     115
     116        if ( $output == OBJECT ) {
     117                return $_term;
     118        } elseif ( $output == ARRAY_A ) {
     119                return get_object_vars($_term);
     120        } elseif ( $output == ARRAY_N ) {
     121                return array_values(get_object_vars($_term));
     122        } else {
     123                return $_term;
     124        }
     125}
     126
     127function get_term_by($field, $value, $taxonomy, $output = OBJECT) {
     128        global $wpdb;
     129
     130        if ( ! is_taxonomy($taxonomy) )
     131                return false;
     132
     133        if ( 'slug' == $field ) {
     134                $field = 't.slug';
     135                $value = sanitize_title($field);
     136                if ( empty($value) )
     137                        return false;
     138        } else if ( 'name' == $field ) {
     139                // Assume already escaped
     140                $field = 't.name';
     141        } else {
     142                $field = 't.term_id';
     143                $value = (int) $value;
     144        }
     145
     146        $term = $wpdb->get_row("SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy = '$taxonomy' AND $field = '$value' LIMIT 1");
     147        if ( !$term )
     148                return false;
     149
     150        wp_cache_add($term->term_id, $term, $taxonomy);
     151
     152        if ( $output == OBJECT ) {
     153                return $term;
     154        } elseif ( $output == ARRAY_A ) {
     155                return get_object_vars($term);
     156        } elseif ( $output == ARRAY_N ) {
     157                return array_values(get_object_vars($term));
     158        } else {
     159                return $term;
     160        }
     161}
     162
     163function get_term_children( $term, $taxonomy ) {
     164        if ( ! is_taxonomy($taxonomy) )
     165                return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));
     166
     167        $terms = _get_term_hierarchy($taxonomy);
     168
     169        if ( ! isset($terms[$term]) )
     170                return array();
     171
     172        $children = $terms[$term];
     173
     174        foreach ( $terms[$term] as $child ) {
     175                if ( isset($terms[$child]) )
     176                        $children = array_merge($children, get_term_children($child, $taxonomy));
     177        }
     178
     179        return $children;
     180}
     181
     182function get_term_field( $field, $term, $taxonomy, $context = 'display' ) {
     183        $term = (int) $term;
     184        $term = get_term( $term, $taxonomy );
     185
     186        if ( is_wp_error($term) )
     187                return $term;
     188
     189        if ( !is_object($term) )
     190                return '';
     191
     192        if ( !isset($term->$field) )
     193                return '';
     194
     195        return sanitize_term_field($field, $term->$field, $term->term_id, $taxonomy, $context);
     196}
     197
     198function get_term_to_edit( $id, $taxonomy ) {
     199        $term = get_term( $id, $taxonomy );
     200
     201        if ( is_wp_error($term) )
     202                return $term;
     203
     204        if ( !is_object($term) )
     205                return '';
     206
     207        return sanitize_term($term, $taxonomy, 'edit');
    462208}
    463209
    … …  
    469215                $single_taxonomy = true;
    470216                $taxonomies = array($taxonomies);
     217        }
     218
     219        foreach ( $taxonomies as $taxonomy ) {
     220                if ( ! is_taxonomy($taxonomy) )
     221                        return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));
    471222        }
    472223
    … …  
    624375}
    625376
    626 function &get_term(&$term, $taxonomy, $output = OBJECT) {
    627         global $wpdb;
    628 
    629         if ( empty($term) )
    630                 return null;
    631 
    632         if ( is_object($term) ) {
    633                 wp_cache_add($term->term_id, $term, $taxonomy);
    634                 $_term = $term;
     377/**
     378 * Returns the index of a defined term, or 0 (false) if the term doesn't exist.
     379 */
     380function is_term($term, $taxonomy = '') {
     381        global $wpdb;
     382
     383        if ( is_int($term) ) {
     384                $where = "t.term_id = '$term'";
    635385        } else {
    636                 $term = (int) $term;
    637                 if ( ! $_term = wp_cache_get($term, $taxonomy) ) {
    638                         $_term = $wpdb->get_row("SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy = '$taxonomy' AND t.term_id = '$term' LIMIT 1");
    639                         wp_cache_add($term, $_term, $taxonomy);
    640                 }
    641         }
    642 
    643         $_term = apply_filters('get_term', $_term, $taxonomy);
    644         $_term = apply_filters("get_$taxonomy", $_term, $taxonomy);
    645 
    646         if ( $output == OBJECT ) {
    647                 return $_term;
    648         } elseif ( $output == ARRAY_A ) {
    649                 return get_object_vars($_term);
    650         } elseif ( $output == ARRAY_N ) {
    651                 return array_values(get_object_vars($_term));
    652         } else {
    653                 return $_term;
    654         }
    655 }
    656 
    657 function get_term_by($field, $value, $taxonomy, $output = OBJECT) {
    658         global $wpdb;
    659 
    660         if ( ! is_taxonomy($taxonomy) )
    661                 return false;
    662 
    663         if ( 'slug' == $field ) {
    664                 $field = 't.slug';
    665                 $value = sanitize_title($field);
    666                 if ( empty($value) )
    667                         return false;
    668         } else if ( 'name' == $field ) {
    669                 // Assume already escaped
    670                 $field = 't.name';
    671         } else {
    672                 $field = 't.term_id';
    673                 $value = (int) $value;
    674         }
    675 
    676         $term = $wpdb->get_row("SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy = '$taxonomy' AND $field = '$value' LIMIT 1");
    677         if ( !$term )
    678                 return false;
    679 
    680         wp_cache_add($term->term_id, $term, $taxonomy);
    681 
    682         if ( $output == OBJECT ) {
    683                 return $term;
    684         } elseif ( $output == ARRAY_A ) {
    685                 return get_object_vars($term);
    686         } elseif ( $output == ARRAY_N ) {
    687                 return array_values(get_object_vars($term));
    688         } else {
    689                 return $term;
    690         }
    691 }
    692 
    693 function get_term_children( $term, $taxonomy ) {
    694         $terms = _get_term_hierarchy($taxonomy);
    695 
    696         if ( ! isset($terms[$term]) )
    697                 return array();
    698 
    699         $children = $terms[$term];
    700 
    701         foreach ( $terms[$term] as $child ) {
    702                 if ( isset($terms[$child]) )
    703                         $children = array_merge($children, get_term_children($child, $taxonomy));
    704         }
    705 
    706         return $children;
    707 }
    708 
    709 function get_term_field( $field, $term, $taxonomy, $context = 'display' ) {
    710         $term = (int) $term;
    711         $term = get_term( $term, $taxonomy );
    712 
    713         if ( !is_object($term) )
    714                 return '';
    715 
    716         if ( !isset($term->$field) )
    717                 return '';
    718 
    719         return sanitize_term_field($field, $term->$field, $term->term_id, $taxonomy, $context);
    720 }
    721 
    722 function get_term_to_edit( $id, $taxonomy ) {
    723         $term = get_term( $id, $taxonomy );
    724 
    725         if ( !is_object($term) )
    726                 return '';
    727 
    728         return sanitize_term($term, $taxonomy, 'edit');
     386                if ( ! $term = sanitize_title($term) )
     387                        return 0;
     388                $where = "t.slug = '$term'";
     389        }
     390
     391        $term_id = $wpdb->get_var("SELECT term_id FROM $wpdb->terms as t WHERE $where");
     392
     393        if ( empty($taxonomy) || empty($term_id) )
     394                return $term_id;
     395
     396        return $wpdb->get_row("SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $where AND tt.taxonomy = '$taxonomy'", ARRAY_A);
    729397}
    730398
    … …  
    777445}
    778446
     447function wp_count_terms( $taxonomy, $args = array() ) {
     448        global $wpdb;
     449
     450        $defaults = array('ignore_empty' => false);
     451        $args = wp_parse_args($args, $defaults);
     452        extract($args, EXTR_SKIP);
     453
     454        $where = '';
     455        if ( $ignore_empty )
     456                $where = 'AND count > 0';
     457
     458        return $wpdb->get_var("SELECT COUNT(*) FROM $wpdb->term_taxonomy WHERE taxonomy = '$taxonomy' $where");
     459}
     460
     461function wp_delete_object_term_relationships( $object_id, $taxonomies ) {
     462        global $wpdb;
     463
     464        $object_id = (int) $object_id;
     465
     466        if ( !is_array($taxonomies) )
     467                $taxonomies = array($taxonomies);
     468
     469        foreach ( $taxonomies as $taxonomy ) {
     470                $terms = get_object_terms($object_id, $taxonomy, 'fields=tt_ids');
     471                $in_terms = "'" . implode("', '", $terms) . "'";
     472                $wpdb->query("DELETE FROM $wpdb->term_relationships WHERE object_id = '$object_id' AND term_taxonomy_id IN ($in_terms)");
     473
     474                wp_update_term_count($terms, $taxonomy);
     475        }
     476
     477        // TODO clear the cache
     478}
     479
     480/**
     481 * Removes a term from the database.
     482 */
     483function wp_delete_term( $term, $taxonomy, $args = array() ) {
     484        global $wpdb;
     485
     486        $term = (int) $term;
     487
     488        if ( ! $ids = is_term($term, $taxonomy) )
     489                return false;
     490        $tt_id = $ids['term_taxonomy_id'];
     491
     492        $defaults = array();
     493        $args = wp_parse_args($args, $defaults);
     494        extract($args, EXTR_SKIP);
     495
     496        if ( isset($default) ) {
     497                $default = (int) $default;
     498                if ( ! is_term($default, $taxonomy) )
     499                        unset($default);
     500        }
     501
     502        // Update children to point to new parent
     503        if ( is_taxonomy_hierarchical($taxonomy) ) {
     504                $term_obj = get_term($term, $taxonomy);
     505                $parent = $term_obj->parent;
     506
     507                $wpdb->query("UPDATE $wpdb->term_taxonomy SET parent = '$parent' WHERE parent = '$term_obj->term_id' AND taxonomy = '$taxonomy'");
     508        }
     509
     510        $objects = $wpdb->get_col("SELECT object_id FROM $wpdb->term_relationships WHERE term_taxonomy_id = '$tt_id'");
     511
     512        foreach ( (array) $objects as $object ) {
     513                $terms = get_object_terms($object, $taxonomy, 'fields=ids');
     514                if ( 1 == count($terms) && isset($default) )
     515                        $terms = array($default);
     516                else
     517                        $terms = array_diff($terms, array($term));
     518                wp_set_object_terms($object, $terms, $taxonomy);
     519        }
     520
     521        $wpdb->query("DELETE FROM $wpdb->term_taxonomy WHERE term_taxonomy_id = '$tt_id'");
     522
     523        // Delete the term if no taxonomies use it.
     524        if ( !$wpdb->get_var("SELECT COUNT(*) FROM $wpdb->term_taxonomy WHERE term_id = '$term'") )
     525                $wpdb->query("DELETE FROM $wpdb->terms WHERE term_id = '$term'");
     526
     527        clean_term_cache($term, $taxonomy);
     528
     529        do_action("delete_$taxonomy", $term, $tt_id);
     530
     531        return true;
     532}
     533
     534/**
     535 * Returns the terms associated with the given object(s), in the supplied taxonomies.
     536 * @param int|array $object_id The id of the object(s)) to retrieve for.
     537 * @param string|array $taxonomies The taxonomies to retrieve terms from.
     538 * @return array The requested term data.                       
     539 */
     540function wp_get_object_terms($object_ids, $taxonomies, $args = array()) {
     541        global $wpdb;
     542
     543        if ( !is_array($taxonomies) )
     544                $taxonomies = array($taxonomies);
     545
     546        foreach ( $taxonomies as $taxonomy ) {
     547                if ( ! is_taxonomy($taxonomy) )
     548                        return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));
     549        }
     550
     551        if ( !is_array($object_ids) )
     552                $object_ids = array($object_ids);
     553        $object_ids = array_map('intval', $object_ids);
     554
     555        $defaults = array('orderby' => 'name', 'order' => 'ASC', 'fields' => 'all');
     556        $args = wp_parse_args( $args, $defaults );
     557        extract($args, EXTR_SKIP);
     558
     559        if ( 'count' == $orderby )
     560                $orderby = 'tt.count';
     561        else if ( 'name' == $orderby )
     562                $orderby = 't.name';
     563
     564        $taxonomies = "'" . implode("', '", $taxonomies) . "'";
     565        $object_ids = implode(', ', $object_ids);
     566
     567        if ( 'all' == $fields )
     568                $select_this = 't.*, tt.*';
     569        else if ( 'ids' == $fields )
     570                $select_this = 't.term_id';
     571        else if ( 'all_with_object_id' == $fields )
     572                $select_this = 't.*, tt.*, tr.object_id';
     573
     574        $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 WHERE tt.taxonomy IN ($taxonomies) AND tr.object_id IN ($object_ids) ORDER BY $orderby $order";
     575
     576        if ( 'all' == $fields || 'all_with_object_id' == $fields ) {
     577                $terms = $wpdb->get_results($query);
     578                update_term_cache($terms);
     579        } else if ( 'ids' == $fields ) {
     580                $terms = $wpdb->get_col($query);
     581        } else if ( 'tt_ids' == $fields ) {
     582                $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) ORDER BY tr.term_taxonomy_id $order");
     583        }
     584
     585        if ( ! $terms )
     586                return array();
     587
     588        return $terms;
     589}
     590
     591/**
     592 * Adds a new term to the database.  Optionally marks it as an alias of an existing term.
     593 * @param int|string $term The term to add or update.
     594 * @param string $taxonomy The taxonomy to which to add the term
     595 * @param int|string $alias_of The id or slug of the new term's alias.
     596 */
     597function wp_insert_term( $term, $taxonomy, $args = array() ) {
     598        global $wpdb;
     599
     600        if ( ! is_taxonomy($taxonomy) )
     601                return new WP_Error('invalid_taxonomy', __('Invalid taxonomy'));
     602
     603        $defaults = array( 'alias_of' => '', 'description' => '', 'parent' => 0, 'slug' => '');
     604        $args = wp_parse_args($args, $defaults);
     605        $args['name'] = $term;
     606        $args = sanitize_term($args, $taxonomy, 'db');
     607        extract($args, EXTR_SKIP);
     608
     609        if ( empty($slug) )
     610                $slug = sanitize_title($name);
     611        else
     612                $slug = sanitize_title($slug);
     613
     614        $term_group = 0;       
     615        if ( $alias_of ) {
     616                $alias = $wpdb->fetch_row("SELECT term_id, term_group FROM $wpdb->terms WHERE slug = '$alias_of'");
     617                if ( $alias->term_group ) {
     618                        // The alias we want is already in a group, so let's use that one.
     619                        $term_group = $alias->term_group;
     620                } else {
     621                        // The alias isn't in a group, so let's create a new one and firstly add the alias term to it.
     622                        $term_group = $wpdb->get_var("SELECT MAX(term_group) FROM $wpdb->terms GROUP BY term_group") + 1;
     623                        $wpdb->query("UPDATE $wpdb->terms SET term_group = $term_group WHERE term_id = $alias->term_id");
     624                }
     625        }
     626
     627        if ( ! $term_id = is_term($slug) ) {
     628                $wpdb->query("INSERT INTO $wpdb->terms (name, slug, term_group) VALUES ('$name', '$slug', '$term_group')");
     629                $term_id = (int) $wpdb->insert_id;
     630        }
     631
     632        if ( empty($slug) ) {
     633                $slug = sanitize_title($slug, $term_id);
     634                $wpdb->query("UPDATE $wpdb->terms SET slug = '$slug' WHERE term_id = '$term_id'");
     635        }
     636
     637        $tt_id = $wpdb->get_var("SELECT tt.term_taxonomy_id FROM $wpdb->term_taxonomy AS tt INNER JOIN $wpdb->terms AS t ON tt.term_id = t.term_id WHERE tt.taxonomy = '$taxonomy' AND t.term_id = $term_id");
     638
     639        if ( !empty($tt_id) )
     640                return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id);
     641
     642        $wpdb->query("INSERT INTO $wpdb->term_taxonomy (term_id, taxonomy, description, parent, count) VALUES ('$term_id', '$taxonomy', '$description', '$parent', '0')");
     643        $tt_id = (int) $wpdb->insert_id;
     644
     645        do_action("create_term", $term_id, $tt_id);
     646        do_action("create_$taxonomy", $term_id, $tt_id);
     647
     648        $term_id = apply_filters('term_id_filter', $term_id, $tt_id);
     649
     650        clean_term_cache($term_id, $taxonomy);
     651
     652        do_action("created_term", $term_id, $tt_id);
     653        do_action("created_$taxonomy", $term_id, $tt_id);
     654
     655        return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id);
     656}
     657
     658/**
     659 * Relates an object (post, link etc) to a term and taxonomy type.  Creates the term and taxonomy
     660 * relationship if it doesn't already exist.  Creates a term if it doesn't exist (using the slug).
     661 * @param int $object_id The object to relate to.
     662 * @param array|int|string $term The slug or id of the term.
     663 * @param array|string $taxonomy The context in which to relate the term to the object.
     664 */
     665function wp_set_object_terms($object_id, $terms, $taxonomy, $append = false) {
     666        global $wpdb;
     667
     668        $object_id = (int) $object_id;
     669
     670        if ( ! is_taxonomy($taxonomy) )
     671                return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));
     672
     673        if ( !is_array($terms) )
     674                $terms = array($terms);
     675
     676        if ( ! $append )
     677                $old_terms =  wp_get_object_terms($object_id, $taxonomy, 'fields=tt_ids');
     678
     679        $tt_ids = array();
     680        $term_ids = array();
     681
     682        foreach ($terms as $term) {
     683                if ( !$id = is_term($term, $taxonomy) )
     684                        $id = wp_insert_term($term, $taxonomy);
     685                $term_ids[] = $id['term_id'];
     686                $id = $id['term_taxonomy_id'];
     687                $tt_ids[] = $id;
     688
     689                if ( $wpdb->get_var("SELECT term_taxonomy_id FROM $wpdb->term_relationships WHERE object_id = '$object_id' AND term_taxonomy_id = '$id'") )
     690                        continue;
     691                $wpdb->query("INSERT INTO $wpdb->term_relationships (object_id, term_taxonomy_id) VALUES ('$object_id', '$id')");
     692        }
     693
     694        wp_update_term_count($tt_ids, $taxonomy);
     695
     696        if ( ! $append ) {
     697                $delete_terms = array_diff($old_terms, $tt_ids);
     698                if ( $delete_terms ) {
     699                        $delete_terms = "'" . implode("', '", $delete_terms) . "'";
     700                        $wpdb->query("DELETE FROM $wpdb->term_relationships WHERE term_taxonomy_id IN ($delete_terms)");
     701                        $wpdb->query("UPDATE $wpdb->term_taxonomy SET count = count - 1 WHERE term_taxonomy_id IN ($delete_terms)");
     702                        wp_update_term_count($delete_terms, $taxonomy);
     703                }
     704        }
     705
     706        // TODO clean old_terms. Need term_id instead of tt_id
     707        clean_term_cache($term_ids, $taxonomy);
     708
     709        return $tt_ids;
     710}
     711
     712function wp_update_term( $term, $taxonomy, $args = array() ) {
     713        global $wpdb;
     714
     715        if ( ! is_taxonomy($taxonomy) )
     716                return new WP_Error('invalid_taxonomy', __('Invalid taxonomy'));
     717
     718        $term_id = (int) $term;
     719
     720        // First, get all of the original args
     721        $term = get_term ($term_id, $taxonomy, ARRAY_A);
     722
     723        $term = sanitize_term($term, $taxonomy, 'db');
     724
     725        // Escape data pulled from DB.
     726        $term = add_magic_quotes($term);
     727
     728        // Merge old and new args with new args overwriting old ones.
     729        $args = array_merge($term, $args);
     730
     731        $defaults = array( 'alias_of' => '', 'description' => '', 'parent' => 0, 'slug' => '');
     732        $args = wp_parse_args($args, $defaults);
     733        extract($args, EXTR_SKIP);
     734
     735        if ( empty($slug) )
     736                $slug = sanitize_title($name);
     737        else
     738                $slug = sanitize_title($slug);
     739
     740        if ( $alias_of ) {
     741                $alias = $wpdb->fetch_row("SELECT term_id, term_group FROM $wpdb->terms WHERE slug = '$alias_of'");
     742                if ( $alias->term_group ) {
     743                        // The alias we want is already in a group, so let's use that one.
     744                        $term_group = $alias->term_group;
     745                } else {
     746                        // The alias isn't in a group, so let's create a new one and firstly add the alias term to it.
     747                        $term_group = $wpdb->get_var("SELECT MAX(term_group) FROM $wpdb->terms GROUP BY term_group") + 1;
     748                        $wpdb->query("UPDATE $wpdb->terms SET term_group = $term_group WHERE term_id = $alias->term_id");
     749                }
     750        }
     751
     752        $wpdb->query("UPDATE $wpdb->terms SET name = '$name', slug = '$slug', term_group = '$term_group' WHERE term_id = '$term_id'");
     753
     754        if ( empty($slug) ) {
     755                $slug = sanitize_title($name, $term_id);
     756                $wpdb->query("UPDATE $wpdb->terms SET slug = '$slug' WHERE term_id = '$term_id'");
     757        }
     758
     759        $tt_id = $wpdb->get_var("SELECT tt.term_taxonomy_id FROM $wpdb->term_taxonomy AS tt INNER JOIN $wpdb->terms AS t ON tt.term_id = t.term_id WHERE tt.taxonomy = '$taxonomy' AND t.term_id = $term_id");
     760
     761        $wpdb->query("UPDATE $wpdb->term_taxonomy SET term_id = '$term_id', taxonomy = '$taxonomy', description = '$description', parent = '$parent' WHERE term_taxonomy_id = '$tt_id'");
     762
     763        do_action("edit_term", $term_id, $tt_id);
     764        do_action("edit_$taxonomy", $term_id, $tt_id);
     765
     766        $term_id = apply_filters('term_id_filter', $term_id, $tt_id);
     767
     768        clean_term_cache($term_id, $taxonomy);
     769
     770        do_action("edited_term", $term_id, $tt_id);
     771        do_action("edited_$taxonomy", $term_id, $tt_id);
     772
     773        return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id);
     774}
     775
     776function wp_update_term_count( $terms, $taxonomy ) {
     777        global $wpdb;
     778
     779        if ( empty($terms) )
     780                return false;
     781
     782        if ( !is_array($terms) )
     783                $terms = array($terms);
     784
     785        $terms = array_map('intval', $terms);
     786
     787        $taxonomy = get_taxonomy($taxonomy);
     788        if ( isset($taxonomy->update_count_callback) )
     789                return call_user_func($taxonomy->update_count_callback, $terms);
     790
     791        // Default count updater
     792        $count = $wpdb->get_var("SELECT COUNT(*) FROM $wpdb->term_relationships WHERE term_taxonomy_id = '$term'");
     793        $wpdb->query("UPDATE $wpdb->term_taxonomy SET count = '$count' WHERE term_taxonomy_id = '$term'");
     794
     795        return true;
     796}
     797
    779798//
    780799// Cache
    781800//
     801
     802function clean_object_term_cache($object_ids, $object_type) {
     803        global $object_term_cache, $blog_id;
     804
     805        if ( !is_array($ids) )
     806                $ids = array($ids);
     807
     808        $taxonomies = get_object_taxonomies($object_type);
     809
     810        foreach ( $ids as $id ) {
     811                foreach ( $taxonomies as $taxonomy ) {
     812                        if ( isset($object_term_cache[$blog_id][$id][$taxonomy]) )
     813                                unset($object_term_cache[$blog_id][$id][$taxonomy]);
     814                }
     815        }
     816}
    782817
    783818function clean_term_cache($ids, $taxonomy) {
    … …  
    793828        delete_option("{$taxonomy}_children");
    794829        wp_cache_delete('get_terms', 'terms');
    795 }
    796 
    797 function update_term_cache($terms, $taxonomy = '') {
    798         foreach ( $terms as $term ) {
    799                 $term_taxonomy = $taxonomy;
    800                 if ( empty($term_taxonomy) )
    801                         $term_taxonomy = $term->taxonomy;
    802 
    803                 wp_cache_add($term->term_id, $term, $term_taxonomy);
    804         }
    805 }
    806 
    807 function clean_object_term_cache($object_ids, $object_type) {
    808         global $object_term_cache, $blog_id;
    809 
    810         if ( !is_array($ids) )
    811                 $ids = array($ids);
    812 
    813         $taxonomies = get_object_taxonomies($object_type);
    814 
    815         foreach ( $ids as $id ) {
    816                 foreach ( $taxonomies as $taxonomy ) {
    817                         if ( isset($object_term_cache[$blog_id][$id][$taxonomy]) )
    818                                 unset($object_term_cache[$blog_id][$id][$taxonomy]);
    819                 }
    820         }
    821830}
    822831
    … …  
    854863                return;
    855864
    856         $terms = get_object_terms($object_ids, get_object_taxonomies($object_type), 'fields=all_with_object_id');
     865        $terms = wp_get_object_terms($object_ids, get_object_taxonomies($object_type), 'fields=all_with_object_id');
    857866
    858867        if ( empty($terms) )
    … …  
    865874                if ( ! isset($object_term_cache[$blog_id][$id]) )
    866875                                $object_term_cache[$blog_id][$id] = array();
     876        }
     877}
     878
     879function update_term_cache($terms, $taxonomy = '') {
     880        foreach ( $terms as $term ) {
     881                $term_taxonomy = $taxonomy;
     882                if ( empty($term_taxonomy) )
     883                        $term_taxonomy = $term->taxonomy;
     884
     885                wp_cache_add($term->term_id, $term, $term_taxonomy);
    867886        }
    868887}
Note: See TracChangeset for help on using the changeset viewer.