WordPress.org
Get WordPress

Make WordPress Core

Changeset 5726


Ignore:
Timestamp:
06/19/2007 12:33:44 AM (17 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.