* - public - If the taxonomy should be publicly queryable; //@TODO not implemented.
* * Defaults to true.
* - hierarchical - Whether the taxonomy is hierarchical (e.g. category). Defaults to false.
- * - show_ui -Whether to generate a default UI for managing this taxonomy in the admin.
+ * - show_ui - Whether to generate a default UI for managing this taxonomy in the admin.
* * If not set, the default is inherited from public.
- * - show_in_menu - Where to show the taxonomy in the admin menu.
+ * - show_in_menu - Whether to show the taxonomy in the admin menu.
* * If true, the taxonomy is shown as a submenu of the object type menu.
* * If false, no menu is shown.
* * show_ui must be true.
);
$args = wp_parse_args( $args, $defaults );
- if ( strlen( $taxonomy ) > 32 )
+ if ( strlen( $taxonomy ) > 32 ) {
+ _doing_it_wrong( __FUNCTION__, __( 'Taxonomies cannot exceed 32 characters in length' ), '4.0' );
return new WP_Error( 'taxonomy_too_long', __( 'Taxonomies cannot exceed 32 characters in length' ) );
+ }
if ( false !== $args['query_var'] && ! empty( $wp ) ) {
if ( true === $args['query_var'] )
*
* @param string $taxonomy Taxonomy slug.
* @param array|string $object_type Object type or array of object types.
- * @param array|string $args Array or string of taxonomy registration arguments.
+ * @param array $args Array of taxonomy registration arguments.
*/
do_action( 'registered_taxonomy', $taxonomy, $object_type, $args );
}
function get_objects_in_term( $term_ids, $taxonomies, $args = array() ) {
global $wpdb;
- if ( ! is_array( $term_ids ) )
+ if ( ! is_array( $term_ids ) ) {
$term_ids = array( $term_ids );
-
- if ( ! is_array( $taxonomies ) )
+ }
+ if ( ! is_array( $taxonomies ) ) {
$taxonomies = array( $taxonomies );
-
+ }
foreach ( (array) $taxonomies as $taxonomy ) {
- if ( ! taxonomy_exists( $taxonomy ) )
+ if ( ! taxonomy_exists( $taxonomy ) ) {
return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy' ) );
+ }
}
$defaults = array( 'order' => 'ASC' );
$args = wp_parse_args( $args, $defaults );
- extract( $args, EXTR_SKIP );
- $order = ( 'desc' == strtolower( $order ) ) ? 'DESC' : 'ASC';
+ $order = ( 'desc' == strtolower( $args['order'] ) ) ? 'DESC' : 'ASC';
$term_ids = array_map('intval', $term_ids );
$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 ($term_ids) ORDER BY tr.object_id $order");
- if ( ! $object_ids )
+ if ( ! $object_ids ){
return array();
-
+ }
return $object_ids;
}
/**
* List of taxonomy queries. A single taxonomy query is an associative array:
- * - 'taxonomy' string The taxonomy being queried
+ * - 'taxonomy' string The taxonomy being queried. Optional when using the term_taxonomy_id field.
* - 'terms' string|array The list of terms
* - 'field' string (optional) Which term field is being used.
- * Possible values: 'term_id', 'slug' or 'name'
+ * Possible values: 'term_id', 'slug', 'name', or 'term_taxonomy_id'
* Default: 'term_id'
* - 'operator' string (optional)
* Possible values: 'AND', 'IN' or 'NOT IN'.
* Default: 'IN'
- * - 'include_children' bool (optional) Whether to include child terms.
+ * - 'include_children' bool (optional) Whether to include child terms. Requires that a taxonomy be specified.
* Default: true
*
* @since 3.1.0
foreach ( $this->queries as $index => $query ) {
$this->clean_query( $query );
- if ( is_wp_error( $query ) )
+ if ( is_wp_error( $query ) ) {
return self::$no_results;
+ }
- extract( $query );
+ $terms = $query['terms'];
+ $operator = strtoupper( $query['operator'] );
if ( 'IN' == $operator ) {
if ( empty( $terms ) ) {
if ( 'OR' == $this->relation ) {
- if ( ( $index + 1 === $count ) && empty( $where ) )
+ if ( ( $index + 1 === $count ) && empty( $where ) ) {
return self::$no_results;
+ }
continue;
} else {
return self::$no_results;
$where[] = "$alias.term_taxonomy_id $operator ($terms)";
} elseif ( 'NOT IN' == $operator ) {
- if ( empty( $terms ) )
+ if ( empty( $terms ) ) {
continue;
+ }
$terms = implode( ',', $terms );
)";
} elseif ( 'AND' == $operator ) {
- if ( empty( $terms ) )
+ if ( empty( $terms ) ) {
continue;
+ }
$num_terms = count( $terms );
$i++;
}
- if ( ! empty( $where ) )
+ if ( ! empty( $where ) ) {
$where = ' AND ( ' . implode( " $this->relation ", $where ) . ' )';
- else
+ } else {
$where = '';
-
+ }
return compact( 'join', 'where' );
}
* @param array &$query The single query
*/
private function clean_query( &$query ) {
- if ( ! taxonomy_exists( $query['taxonomy'] ) ) {
+ if ( empty( $query['taxonomy'] ) ) {
+ if ( 'term_taxonomy_id' !== $query['field'] ) {
+ $query = new WP_Error( 'Invalid taxonomy' );
+ return;
+ }
+
+ // so long as there are shared terms, include_children requires that a taxonomy is set
+ $query['include_children'] = false;
+ } elseif ( ! taxonomy_exists( $query['taxonomy'] ) ) {
$query = new WP_Error( 'Invalid taxonomy' );
return;
}
* The 'get_terms_fields' filter passes the fields for the SELECT query
* along with the $args array.
*
- * The list of arguments that $args can contain, which will overwrite the defaults:
- *
- * orderby - Default is 'name'. Can be name, count, term_group, slug or nothing
- * (will use term_id), Passing a custom value other than these will cause it to
- * order based on the custom value.
- *
- * order - Default is ASC. Can use DESC.
- *
- * hide_empty - Default is true. Will not return empty terms, which means
- * terms whose count is 0 according to the given taxonomy.
- *
- * exclude - Default is an empty array. An array, comma- or space-delimited string
- * of term ids to exclude from the return array. If 'include' is non-empty,
- * 'exclude' is ignored.
- *
- * exclude_tree - Default is an empty array. An array, comma- or space-delimited
- * string of term ids to exclude from the return array, along with all of their
- * descendant terms according to the primary taxonomy. If 'include' is non-empty,
- * 'exclude_tree' is ignored.
- *
- * include - Default is an empty array. An array, comma- or space-delimited string
- * of term ids to include in the return array.
- *
- * number - The maximum number of terms to return. Default is to return them all.
- *
- * offset - The number by which to offset the terms query.
- *
- * fields - Default is 'all', which returns an array of term objects.
- * If 'fields' is 'ids' or 'names', returns an array of
- * integers or strings, respectively.
- *
- * slug - Returns terms whose "slug" matches this value. Default is empty string.
- *
- * hierarchical - Whether to include terms that have non-empty descendants
- * (even if 'hide_empty' is set to true).
- *
- * search - Returned terms' names will contain the value of 'search',
- * case-insensitive. Default is an empty string.
- *
- * name__like - Returned terms' names will contain the value of 'name__like',
- * case-insensitive. Default is empty string.
- *
- * description__like - Returned terms' descriptions will contain the value of
- * 'description__like', case-insensitive. Default is empty string.
- *
- * The argument 'pad_counts', if set to true will include the quantity of a term's
- * children in the quantity of each term's "count" object variable.
- *
- * The 'get' argument, if set to 'all' instead of its default empty string,
- * returns terms regardless of ancestry or whether the terms are empty.
- *
- * The 'child_of' argument, when used, should be set to the integer of a term ID. Its default
- * is 0. If set to a non-zero value, all returned terms will be descendants
- * of that term according to the given taxonomy. Hence 'child_of' is set to 0
- * if more than one taxonomy is passed in $taxonomies, because multiple taxonomies
- * make term ancestry ambiguous.
- *
- * The 'parent' argument, when used, should be set to the integer of a term ID. Its default is
- * the empty string '', which has a different meaning from the integer 0.
- * If set to an integer value, all returned terms will have as an immediate
- * ancestor the term whose ID is specified by that integer according to the given taxonomy.
- * The 'parent' argument is different from 'child_of' in that a term X is considered a 'parent'
- * of term Y only if term X is the father of term Y, not its grandfather or great-grandfather, etc.
- *
- * The 'cache_domain' argument enables a unique cache key to be produced when this query is stored
- * in object cache. For instance, if you are using one of this function's filters to modify the
- * query (such as 'terms_clauses'), setting 'cache_domain' to a unique value will not overwrite
- * the cache for similar queries. Default value is 'core'.
- *
* @since 2.3.0
*
- * @uses $wpdb
- * @uses wp_parse_args() Merges the defaults with those defined by $args and allows for strings.
+ * @global wpdb $wpdb WordPress database access abstraction object.
*
- * @param string|array $taxonomies Taxonomy name or list of Taxonomy names
- * @param string|array $args The values of what to search for when returning terms
- * @return array|WP_Error List of Term Objects and their children. Will return WP_Error, if any of $taxonomies do not exist.
+ * @param string|array $taxonomies Taxonomy name or list of Taxonomy names.
+ * @param array|string $args {
+ * Optional. Array or string of arguments to get terms.
+ *
+ * @type string $orderby Field(s) to order terms by. Accepts term fields, though
+ * empty defaults to 'term_id'. Default 'name'.
+ * @type string $order Whether to order terms in ascending or descending order.
+ * Accepts 'ASC' (ascending) or 'DESC' (descending).
+ * Default 'ASC'.
+ * @type bool|int $hide_empty Whether to hide terms not assigned to any posts. Accepts
+ * 1|true or 0|false. Default 1|true.
+ * @type array|string $include Array or comma/space-separated string of term ids to include.
+ * Default empty array.
+ * @type array|string $exclude Array or comma/space-separated string of term ids to exclude.
+ * If $include is non-empty, $exclude is ignored.
+ * Default empty array.
+ * @type array|string $exclude_tree Array or comma/space-separated string of term ids to exclude
+ * along with all of their descendant terms. If $include is
+ * non-empty, $exclude_tree is ignored. Default empty array.
+ * @type int $number Maximum number of terms to return. Accepts 1+ or -1 (all).
+ * Default -1.
+ * @type int $offset The number by which to offset the terms query. Default empty.
+ * @type string $fields Term fields to query for. Accepts 'all' (returns an array of
+ * term objects), 'ids' or 'names' (returns an array of integers
+ * or strings, respectively. Default 'all'.
+ * @type string $slug Slug to return term(s) for. Default empty.
+ * @type bool $hierarchical Whether to include terms that have non-empty descendants (even
+ * if $hide_empty is set to true). Default true.
+ * @type string $search Search criteria to match terms. Will be SQL-formatted with
+ * wildcards before and after. Default empty.
+ * @type string $name__like Retrieve terms with criteria by which a term is LIKE $name__like.
+ * Default empty.
+ * @type string $description__like Retrieve terms where the description is LIKE $description__like.
+ * Default empty.
+ * @type bool $pad_counts Whether to pad the quantity of a term's children in the quantity
+ * of each term's "count" object variable. Default false.
+ * @type string $get Whether to return terms regardless of ancestry or whether the terms
+ * are empty. Accepts 'all' or empty (disabled). Default empty.
+ * @type int $child_of Term ID to retrieve child terms of. If multiple taxonomies
+ * are passed, $child_of is ignored. Default 0.
+ * @type int|string $parent Parent term ID to retrieve direct-child terms of. Default empty.
+ * @type string $cache_domain Unique cache key to be produced when this query is stored in an
+ * object cache. Default is 'core'.
+ * }
+ * @return array|WP_Error List of Term Objects and their children. Will return WP_Error, if any of $taxonomies
+ * do not exist.
*/
-function get_terms($taxonomies, $args = '') {
+function get_terms( $taxonomies, $args = '' ) {
global $wpdb;
$empty_array = array();
$single_taxonomy = ! is_array( $taxonomies ) || 1 === count( $taxonomies );
- if ( ! is_array( $taxonomies ) )
+ if ( ! is_array( $taxonomies ) ) {
$taxonomies = array( $taxonomies );
+ }
foreach ( $taxonomies as $taxonomy ) {
if ( ! taxonomy_exists($taxonomy) ) {
*/
$args = apply_filters( 'get_terms_args', $args, $taxonomies );
- extract($args, EXTR_SKIP);
-
+ $child_of = $args['child_of'];
if ( $child_of ) {
$hierarchy = _get_term_hierarchy( reset( $taxonomies ) );
- if ( ! isset( $hierarchy[ $child_of ] ) )
+ if ( ! isset( $hierarchy[ $child_of ] ) ) {
return $empty_array;
+ }
}
+ $parent = $args['parent'];
if ( $parent ) {
$hierarchy = _get_term_hierarchy( reset( $taxonomies ) );
- if ( ! isset( $hierarchy[ $parent ] ) )
+ if ( ! isset( $hierarchy[ $parent ] ) ) {
return $empty_array;
+ }
}
// $args can be whatever, only use the args defined in defaults to compute the key
$filter_key = ( has_filter('list_terms_exclusions') ) ? serialize($GLOBALS['wp_filter']['list_terms_exclusions']) : '';
- $key = md5( serialize( compact(array_keys($defaults)) ) . serialize( $taxonomies ) . $filter_key );
+ $key = md5( serialize( wp_array_slice_assoc( $args, array_keys( $defaults ) ) ) . serialize( $taxonomies ) . $filter_key );
$last_changed = wp_cache_get( 'last_changed', 'terms' );
if ( ! $last_changed ) {
$last_changed = microtime();
return $cache;
}
- $_orderby = strtolower($orderby);
- if ( 'count' == $_orderby )
+ $_orderby = strtolower( $args['orderby'] );
+ if ( 'count' == $_orderby ) {
$orderby = 'tt.count';
- else if ( 'name' == $_orderby )
+ } else if ( 'name' == $_orderby ) {
$orderby = 't.name';
- else if ( 'slug' == $_orderby )
+ } else if ( 'slug' == $_orderby ) {
$orderby = 't.slug';
- else if ( 'term_group' == $_orderby )
+ } else if ( 'term_group' == $_orderby ) {
$orderby = 't.term_group';
- else if ( 'none' == $_orderby )
+ } else if ( 'none' == $_orderby ) {
$orderby = '';
- elseif ( empty($_orderby) || 'id' == $_orderby )
+ } elseif ( empty($_orderby) || 'id' == $_orderby ) {
$orderby = 't.term_id';
- else
+ } else {
$orderby = 't.name';
-
+ }
/**
* Filter the ORDERBY clause of the terms query.
*
*/
$orderby = apply_filters( 'get_terms_orderby', $orderby, $args, $taxonomies );
- if ( !empty($orderby) )
+ $order = strtoupper( $args['order'] );
+ if ( ! empty( $orderby ) ) {
$orderby = "ORDER BY $orderby";
- else
+ } else {
$order = '';
+ }
- $order = strtoupper( $order );
- if ( '' !== $order && !in_array( $order, array( 'ASC', 'DESC' ) ) )
+ if ( '' !== $order && ! in_array( $order, array( 'ASC', 'DESC' ) ) ) {
$order = 'ASC';
+ }
$where = "tt.taxonomy IN ('" . implode("', '", $taxonomies) . "')";
+
+ $exclude = $args['exclude'];
+ $exclude_tree = $args['exclude_tree'];
+ $include = $args['include'];
+
$inclusions = '';
if ( ! empty( $include ) ) {
$exclude = '';
$where .= $inclusions;
}
- $exclusions = '';
if ( ! empty( $exclude_tree ) ) {
$exclude_tree = wp_parse_id_list( $exclude_tree );
$excluded_children = $exclude_tree;
);
}
$exclusions = implode( ',', array_map( 'intval', $excluded_children ) );
+ } else {
+ $exclusions = '';
}
if ( ! empty( $exclude ) ) {
$exterms = wp_parse_id_list( $exclude );
- if ( empty( $exclusions ) )
+ if ( empty( $exclusions ) ) {
$exclusions = implode( ',', $exterms );
- else
+ } else {
$exclusions .= ', ' . implode( ',', $exterms );
+ }
}
- if ( ! empty( $exclusions ) )
+ if ( ! empty( $exclusions ) ) {
$exclusions = ' AND t.term_id NOT IN (' . $exclusions . ')';
+ }
/**
* Filter the terms to exclude from the terms query.
*/
$exclusions = apply_filters( 'list_terms_exclusions', $exclusions, $args, $taxonomies );
- if ( ! empty( $exclusions ) )
+ if ( ! empty( $exclusions ) ) {
$where .= $exclusions;
+ }
- if ( !empty($slug) ) {
- $slug = sanitize_title($slug);
+ if ( ! empty( $args['slug'] ) ) {
+ $slug = sanitize_title( $args['slug'] );
$where .= " AND t.slug = '$slug'";
}
- if ( !empty($name__like) ) {
- $name__like = like_escape( $name__like );
- $where .= $wpdb->prepare( " AND t.name LIKE %s", '%' . $name__like . '%' );
+ if ( ! empty( $args['name__like'] ) ) {
+ $where .= $wpdb->prepare( " AND t.name LIKE %s", '%' . $wpdb->esc_like( $args['name__like'] ) . '%' );
}
- if ( ! empty( $description__like ) ) {
- $description__like = like_escape( $description__like );
- $where .= $wpdb->prepare( " AND tt.description LIKE %s", '%' . $description__like . '%' );
+ if ( ! empty( $args['description__like'] ) ) {
+ $where .= $wpdb->prepare( " AND tt.description LIKE %s", '%' . $wpdb->esc_like( $args['description__like'] ) . '%' );
}
if ( '' !== $parent ) {
$where .= " AND tt.parent = '$parent'";
}
- if ( 'count' == $fields )
+ $hierarchical = $args['hierarchical'];
+ if ( 'count' == $args['fields'] ) {
$hierarchical = false;
-
- if ( $hide_empty && !$hierarchical )
+ }
+ if ( $args['hide_empty'] && !$hierarchical ) {
$where .= ' AND tt.count > 0';
+ }
+
+ $number = $args['number'];
+ $offset = $args['offset'];
// don't limit the query results when we have to descend the family tree
if ( $number && ! $hierarchical && ! $child_of && '' === $parent ) {
- if ( $offset )
+ if ( $offset ) {
$limits = 'LIMIT ' . $offset . ',' . $number;
- else
+ } else {
$limits = 'LIMIT ' . $number;
+ }
} else {
$limits = '';
}
- if ( ! empty( $search ) ) {
- $search = like_escape( $search );
- $where .= $wpdb->prepare( ' AND ((t.name LIKE %s) OR (t.slug LIKE %s))', '%' . $search . '%', '%' . $search . '%' );
+ if ( ! empty( $args['search'] ) ) {
+ $like = '%' . $wpdb->esc_like( $args['search'] ) . '%';
+ $where .= $wpdb->prepare( ' AND ((t.name LIKE %s) OR (t.slug LIKE %s))', $like, $like );
}
$selects = array();
- switch ( $fields ) {
+ switch ( $args['fields'] ) {
case 'all':
$selects = array( 't.*', 'tt.*' );
break;
break;
}
- $_fields = $fields;
+ $_fields = $args['fields'];
/**
* Filter the fields to select in the terms query.
* @param array $args An array of terms query arguments.
*/
$clauses = apply_filters( 'terms_clauses', compact( $pieces ), $taxonomies, $args );
- foreach ( $pieces as $piece )
- $$piece = isset( $clauses[ $piece ] ) ? $clauses[ $piece ] : '';
+ $fields = isset( $clauses[ 'fields' ] ) ? $clauses[ 'fields' ] : '';
+ $join = isset( $clauses[ 'join' ] ) ? $clauses[ 'join' ] : '';
+ $where = isset( $clauses[ 'where' ] ) ? $clauses[ 'where' ] : '';
+ $orderby = isset( $clauses[ 'orderby' ] ) ? $clauses[ 'orderby' ] : '';
+ $order = isset( $clauses[ 'order' ] ) ? $clauses[ 'order' ] : '';
+ $limits = isset( $clauses[ 'limits' ] ) ? $clauses[ 'limits' ] : '';
$query = "SELECT $fields FROM $wpdb->terms AS t $join WHERE $where $orderby $order $limits";
- $fields = $_fields;
-
- if ( 'count' == $fields ) {
+ if ( 'count' == $_fields ) {
$term_count = $wpdb->get_var($query);
return $term_count;
}
$terms = $wpdb->get_results($query);
- if ( 'all' == $fields ) {
+ if ( 'all' == $_fields ) {
update_term_cache($terms);
}
if ( $child_of ) {
$children = _get_term_hierarchy( reset( $taxonomies ) );
- if ( ! empty( $children ) )
+ if ( ! empty( $children ) ) {
$terms = _get_term_children( $child_of, $terms, reset( $taxonomies ) );
+ }
}
// Update term counts to include children.
- if ( $pad_counts && 'all' == $fields )
+ if ( $args['pad_counts'] && 'all' == $_fields ) {
_pad_term_counts( $terms, reset( $taxonomies ) );
-
+ }
// Make sure we show empty categories that have children.
- if ( $hierarchical && $hide_empty && is_array( $terms ) ) {
+ if ( $hierarchical && $args['hide_empty'] && is_array( $terms ) ) {
foreach ( $terms as $k => $term ) {
if ( ! $term->count ) {
$children = get_term_children( $term->term_id, reset( $taxonomies ) );
reset( $terms );
$_terms = array();
- if ( 'id=>parent' == $fields ) {
- while ( $term = array_shift( $terms ) )
+ if ( 'id=>parent' == $_fields ) {
+ while ( $term = array_shift( $terms ) ) {
$_terms[$term->term_id] = $term->parent;
- } elseif ( 'ids' == $fields ) {
- while ( $term = array_shift( $terms ) )
+ }
+ } elseif ( 'ids' == $_fields ) {
+ while ( $term = array_shift( $terms ) ) {
$_terms[] = $term->term_id;
- } elseif ( 'names' == $fields ) {
- while ( $term = array_shift( $terms ) )
+ }
+ } elseif ( 'names' == $_fields ) {
+ while ( $term = array_shift( $terms ) ) {
$_terms[] = $term->name;
- } elseif ( 'id=>name' == $fields ) {
- while ( $term = array_shift( $terms ) )
+ }
+ } elseif ( 'id=>name' == $_fields ) {
+ while ( $term = array_shift( $terms ) ) {
$_terms[$term->term_id] = $term->name;
- } elseif ( 'id=>slug' == $fields ) {
- while ( $term = array_shift( $terms ) )
+ }
+ } elseif ( 'id=>slug' == $_fields ) {
+ while ( $term = array_shift( $terms ) ) {
$_terms[$term->term_id] = $term->slug;
+ }
}
- if ( ! empty( $_terms ) )
+ if ( ! empty( $_terms ) ) {
$terms = $_terms;
+ }
- if ( $number && is_array( $terms ) && count( $terms ) > $number )
+ if ( $number && is_array( $terms ) && count( $terms ) > $number ) {
$terms = array_slice( $terms, $offset, $number );
+ }
wp_cache_add( $cache_key, $terms, 'terms', DAY_IN_SECONDS );
* @param string $taxonomy The taxonomy name to use
* @param int $parent ID of parent term under which to confine the exists search.
* @return mixed Returns 0 if the term does not exist. Returns the term ID if no taxonomy is specified
- * and the term ID exists. Returns an array of the term ID and the taxonomy if the pairing exists.
+ * and the term ID exists. Returns an array of the term ID and the term taxonomy ID
+ * if the taxonomy is specified and the pairing exists.
*/
function term_exists($term, $taxonomy = '', $parent = 0) {
global $wpdb;
}
$args = wp_parse_args($args, $defaults);
- extract($args, EXTR_SKIP);
- if ( isset( $default ) ) {
- $default = (int) $default;
- if ( ! term_exists($default, $taxonomy) )
- unset($default);
+ if ( isset( $args['default'] ) ) {
+ $default = (int) $args['default'];
+ if ( ! term_exists( $default, $taxonomy ) ) {
+ unset( $default );
+ }
+ }
+
+ if ( isset( $args['force_default'] ) ) {
+ $force_default = $args['force_default'];
}
// Update children to point to new parent
$args = array_merge($args, $t->args);
}
- extract($args, EXTR_SKIP);
+ $orderby = $args['orderby'];
+ $order = $args['order'];
+ $fields = $args['fields'];
if ( 'count' == $orderby )
$orderby = 'tt.count';
$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) $orderby $order";
+ $objects = false;
if ( 'all' == $fields || 'all_with_object_id' == $fields ) {
$_terms = $wpdb->get_results( $query );
foreach ( $_terms as $key => $term ) {
}
$terms = array_merge( $terms, $_terms );
update_term_cache( $terms );
+ $objects = true;
} else if ( 'ids' == $fields || 'names' == $fields || 'slugs' == $fields ) {
$_terms = $wpdb->get_col( $query );
$_field = ( 'ids' == $fields ) ? 'term_id' : 'name';
}
}
- if ( ! $terms )
+ if ( ! $terms ) {
$terms = array();
+ } elseif ( $objects && 'all_with_object_id' !== $fields ) {
+ $_tt_ids = array();
+ $_terms = array();
+ foreach ( $terms as $term ) {
+ if ( in_array( $term->term_taxonomy_id, $_tt_ids ) ) {
+ continue;
+ }
+ $_tt_ids[] = $term->term_taxonomy_id;
+ $_terms[] = $term;
+ }
+ $terms = $_terms;
+ } elseif ( ! $objects ) {
+ $terms = array_values( array_unique( $terms ) );
+ }
/**
* Filter the terms for a given object or objects.
*
function wp_insert_term( $term, $taxonomy, $args = array() ) {
global $wpdb;
- if ( ! taxonomy_exists($taxonomy) )
+ if ( ! taxonomy_exists($taxonomy) ) {
return new WP_Error('invalid_taxonomy', __('Invalid taxonomy'));
-
+ }
/**
* Filter a term before it is sanitized and inserted into the database.
*
* @param string $taxonomy Taxonomy slug.
*/
$term = apply_filters( 'pre_insert_term', $term, $taxonomy );
- if ( is_wp_error( $term ) )
- return $term;
-
- if ( is_int($term) && 0 == $term )
+ if ( is_wp_error( $term ) ) {
+ return $term;
+ }
+ if ( is_int($term) && 0 == $term ) {
return new WP_Error('invalid_term_id', __('Invalid term ID'));
-
- if ( '' == trim($term) )
+ }
+ if ( '' == trim($term) ) {
return new WP_Error('empty_term_name', __('A name is required for this term'));
-
+ }
$defaults = array( 'alias_of' => '', 'description' => '', 'parent' => 0, 'slug' => '');
- $args = wp_parse_args($args, $defaults);
+ $args = wp_parse_args( $args, $defaults );
+
+ if ( $args['parent'] > 0 && ! term_exists( (int) $args['parent'] ) ) {
+ return new WP_Error( 'missing_parent', __( 'Parent term does not exist.' ) );
+ }
$args['name'] = $term;
$args['taxonomy'] = $taxonomy;
$args = sanitize_term($args, $taxonomy, 'db');
- extract($args, EXTR_SKIP);
// expected_slashed ($name)
- $name = wp_unslash($name);
- $description = wp_unslash($description);
+ $name = wp_unslash( $args['name'] );
+ $description = wp_unslash( $args['description'] );
+ $parent = (int) $args['parent'];
- $slug_provided = ! empty( $slug );
+ $slug_provided = ! empty( $args['slug'] );
if ( ! $slug_provided ) {
- $slug = sanitize_title($name);
+ $_name = trim( $name );
+ $existing_term = get_term_by( 'name', $_name, $taxonomy );
+ if ( $existing_term ) {
+ $slug = $existing_term->slug;
+ } else {
+ $slug = sanitize_title( $name );
+ }
+ } else {
+ $slug = $args['slug'];
}
$term_group = 0;
- if ( $alias_of ) {
- $alias = $wpdb->get_row( $wpdb->prepare( "SELECT term_id, term_group FROM $wpdb->terms WHERE slug = %s", $alias_of) );
+ if ( $args['alias_of'] ) {
+ $alias = $wpdb->get_row( $wpdb->prepare( "SELECT term_id, term_group FROM $wpdb->terms WHERE slug = %s", $args['alias_of'] ) );
if ( $alias->term_group ) {
// The alias we want is already in a group, so let's use that one.
$term_group = $alias->term_group;
// We've got an existing term in the same taxonomy, which matches the name of the new term:
if ( is_taxonomy_hierarchical($taxonomy) && $existing_term['name'] == $name && $exists = term_exists( (int) $term_id, $taxonomy ) ) {
// Hierarchical, and it matches an existing term, Do not allow same "name" in the same level.
- $siblings = get_terms($taxonomy, array('fields' => 'names', 'get' => 'all', 'parent' => (int)$parent) );
+ $siblings = get_terms($taxonomy, array('fields' => 'names', 'get' => 'all', 'parent' => $parent ) );
if ( in_array($name, $siblings) ) {
if ( $slug_provided ) {
return new WP_Error( 'term_exists', __( 'A term with the name and slug provided already exists with this parent.' ), $exists['term_id'] );
}
} else {
$slug = wp_unique_term_slug($slug, (object) $args);
- if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) )
+ if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) ) {
return new WP_Error('db_insert_error', __('Could not insert term into the database'), $wpdb->last_error);
+ }
$term_id = (int) $wpdb->insert_id;
}
} elseif ( $existing_term['name'] != $name ) {
// We've got an existing term, with a different name, Create the new term.
$slug = wp_unique_term_slug($slug, (object) $args);
- if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) )
+ if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) ) {
return new WP_Error('db_insert_error', __('Could not insert term into the database'), $wpdb->last_error);
+ }
$term_id = (int) $wpdb->insert_id;
} elseif ( $exists = term_exists( (int) $term_id, $taxonomy ) ) {
// Same name, same slug.
} else {
// This term does not exist at all in the database, Create it.
$slug = wp_unique_term_slug($slug, (object) $args);
- if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) )
+ if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) ) {
return new WP_Error('db_insert_error', __('Could not insert term into the database'), $wpdb->last_error);
+ }
$term_id = (int) $wpdb->insert_id;
}
$tt_id = $wpdb->get_var( $wpdb->prepare( "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 = %s AND t.term_id = %d", $taxonomy, $term_id ) );
- if ( !empty($tt_id) )
+ if ( !empty($tt_id) ) {
return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id);
-
+ }
$wpdb->insert( $wpdb->term_taxonomy, compact( 'term_id', 'taxonomy', 'description', 'parent') + array( 'count' => 0 ) );
$tt_id = (int) $wpdb->insert_id;
* @since 2.3.0
* @uses wp_remove_object_terms()
*
- * @param int $object_id The object to relate to.
- * @param array|int|string $terms The slug or id of the term, will replace all existing
- * related terms in this taxonomy.
- * @param array|string $taxonomy The context in which to relate the term to the object.
- * @param bool $append If false will delete difference of terms.
- * @return array|WP_Error Affected Term IDs
+ * @param int $object_id The object to relate to.
+ * @param array|int|string $terms A single term slug, single term id, or array of either term slugs or ids.
+ * Will replace all existing related terms in this taxonomy.
+ * @param array|string $taxonomy The context in which to relate the term to the object.
+ * @param bool $append Optional. If false will delete difference of terms. Default false.
+ * @return array|WP_Error Affected Term IDs.
*/
-function wp_set_object_terms($object_id, $terms, $taxonomy, $append = false) {
+function wp_set_object_terms( $object_id, $terms, $taxonomy, $append = false ) {
global $wpdb;
$object_id = (int) $object_id;
$defaults = array( 'alias_of' => '', 'description' => '', 'parent' => 0, 'slug' => '');
$args = wp_parse_args($args, $defaults);
$args = sanitize_term($args, $taxonomy, 'db');
- extract($args, EXTR_SKIP);
+ $parsed_args = $args;
// expected_slashed ($name)
- $name = wp_unslash($name);
- $description = wp_unslash($description);
+ $name = wp_unslash( $args['name'] );
+ $description = wp_unslash( $args['description'] );
+
+ $parsed_args['name'] = $name;
+ $parsed_args['description'] = $description;
if ( '' == trim($name) )
return new WP_Error('empty_term_name', __('A name is required for this term'));
$empty_slug = false;
- if ( empty($slug) ) {
+ if ( empty( $args['slug'] ) ) {
$empty_slug = true;
$slug = sanitize_title($name);
+ } else {
+ $slug = $args['slug'];
}
- if ( $alias_of ) {
- $alias = $wpdb->get_row( $wpdb->prepare( "SELECT term_id, term_group FROM $wpdb->terms WHERE slug = %s", $alias_of) );
+ $parsed_args['slug'] = $slug;
+
+ $term_group = isset( $parsed_args['term_group'] ) ? $parsed_args['term_group'] : 0;
+ if ( $args['alias_of'] ) {
+ $alias = $wpdb->get_row( $wpdb->prepare( "SELECT term_id, term_group FROM $wpdb->terms WHERE slug = %s", $args['alias_of'] ) );
if ( $alias->term_group ) {
// The alias we want is already in a group, so let's use that one.
$term_group = $alias->term_group;
/** This action is documented in wp-includes/taxonomy.php */
do_action( 'edited_terms', $alias->term_id, $taxonomy );
}
+
+ $parsed_args['term_group'] = $term_group;
}
/**
*
* @since 3.1.0
*
- * @param int $parent ID of the parent term.
- * @param int $term_id Term ID.
- * @param string $taxonomy Taxonomy slug.
- * @param array $args Compacted array of update arguments for the given term.
- * @param array $args An array of update arguments for the given term.
+ * @param int $parent ID of the parent term.
+ * @param int $term_id Term ID.
+ * @param string $taxonomy Taxonomy slug.
+ * @param array $parsed_args An array of potentially altered update arguments for the given term.
+ * @param array $args An array of update arguments for the given term.
*/
- $parent = apply_filters( 'wp_update_term_parent', $parent, $term_id, $taxonomy, compact( array_keys( $args ) ), $args );
+ $parent = apply_filters( 'wp_update_term_parent', $args['parent'], $term_id, $taxonomy, $parsed_args, $args );
// Check for duplicate slug
$id = $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->terms WHERE slug = %s", $slug ) );
* @return bool Always true when complete.
*/
function wp_update_term_count_now( $terms, $taxonomy ) {
- global $wpdb;
-
$terms = array_map('intval', $terms);
$taxonomy = get_taxonomy($taxonomy);
*
* @param array $args Override the defaults.
*/
-function the_taxonomies($args = array()) {
+function the_taxonomies( $args = array() ) {
$defaults = array(
'post' => 0,
'before' => '',
'sep' => ' ',
'after' => '',
- 'template' => '%s: %l.'
+ /* translators: %s: taxonomy label, %l: list of term links */
+ 'template' => __( '%s: %l.' )
);
$r = wp_parse_args( $args, $defaults );
- extract( $r, EXTR_SKIP );
- echo $before . join($sep, get_the_taxonomies($post, $r)) . $after;
+ echo $r['before'] . join( $r['sep'], get_the_taxonomies( $r['post'], $r ) ) . $r['after'];
}
/**
*
* @since 2.5.0
*
- * @param int|WP_Post $post Optional. Post ID or post object.
+ * @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post.
* @param array $args Override the defaults.
- * @return array
+ * @return array List of taxonomies.
*/
-function get_the_taxonomies($post = 0, $args = array() ) {
+function get_the_taxonomies( $post = 0, $args = array() ) {
$post = get_post( $post );
$args = wp_parse_args( $args, array(
- 'template' => '%s: %l.',
+ /* translators: %s: taxonomy label, %l: list of term links */
+ 'template' => __( '%s: %l.' ),
) );
- extract( $args, EXTR_SKIP );
$taxonomies = array();
- if ( !$post )
+ if ( ! $post ) {
return $taxonomies;
+ }
- foreach ( get_object_taxonomies($post) as $taxonomy ) {
- $t = (array) get_taxonomy($taxonomy);
- if ( empty($t['label']) )
+ foreach ( get_object_taxonomies( $post ) as $taxonomy ) {
+ $t = (array) get_taxonomy( $taxonomy );
+ if ( empty( $t['label'] ) ) {
$t['label'] = $taxonomy;
- if ( empty($t['args']) )
+ }
+ if ( empty( $t['args'] ) ) {
$t['args'] = array();
- if ( empty($t['template']) )
- $t['template'] = $template;
-
- $terms = get_object_term_cache($post->ID, $taxonomy);
- if ( false === $terms )
- $terms = wp_get_object_terms($post->ID, $taxonomy, $t['args']);
+ }
+ if ( empty( $t['template'] ) ) {
+ $t['template'] = $args['template'];
+ }
+ $terms = get_object_term_cache( $post->ID, $taxonomy );
+ if ( false === $terms ) {
+ $terms = wp_get_object_terms( $post->ID, $taxonomy, $t['args'] );
+ }
$links = array();
- foreach ( $terms as $term )
- $links[] = "<a href='" . esc_attr( get_term_link($term) ) . "'>$term->name</a>";
-
- if ( $links )
- $taxonomies[$taxonomy] = wp_sprintf($t['template'], $t['label'], $links, $terms);
+ foreach ( $terms as $term ) {
+ $links[] = "<a href='" . esc_attr( get_term_link( $term ) ) . "'>$term->name</a>";
+ }
+ if ( $links ) {
+ $taxonomies[$taxonomy] = wp_sprintf( $t['template'], $t['label'], $links, $terms );
+ }
}
return $taxonomies;
}
* Retrieve all taxonomies of a post with just the names.
*
* @since 2.5.0
+ *
* @uses get_object_taxonomies()
*
- * @param int|WP_Post $post Optional. Post ID or post object.
+ * @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post.
* @return array
*/
-function get_post_taxonomies($post = 0) {
+function get_post_taxonomies( $post = 0 ) {
$post = get_post( $post );
return get_object_taxonomies($post);
wp_update_term( $loop_member, $taxonomy, array( 'parent' => 0 ) );
return $parent;
-}
\ No newline at end of file
+}
scripts.mit.edu / autoinstalls / wordpress.git / blobdiff