enmi-conf.org: comparison wp/wp-includes/class-wp-term-query.php

equal deleted inserted replaced

-:c7c34916027a
+:177826044cd9
 	 *                                                not return accurate results when coupled with $object_ids.
 	 *                                                See #41796 for details.
 	 *     @type int          $offset                 The number by which to offset the terms query. Default empty.
 	 *     @type string       $fields                 Term fields to query for. Accepts 'all' (returns an array of
 	 *                                                complete term objects), 'all_with_object_id' (returns an
-	 *                                                array of term objects with the 'object_id' param; only works
+	 *                                                array of term objects with the 'object_id' param; works only
-	 *                                                when the `$fields` parameter is 'object_ids' ), 'ids'
+	 *                                                when the `$object_ids` parameter is populated), 'ids'
 	 *                                                (returns an array of ids), 'tt_ids' (returns an array of
 	 *                                                term taxonomy ids), 'id=>parent' (returns an associative
 	 *                                                array with ids as keys, parent term IDs as values), 'names'
 	 *                                                (returns an array of term names), 'count' (returns the number
 	 *                                                of matching terms), 'id=>name' (returns an associative array
 	 *                                                See `WP_Meta_Query`. Default empty.
 	 *     @type string       $meta_key               Limit terms to those matching a specific metadata key.
 	 *                                                Can be used in conjunction with `$meta_value`. Default empty.
 	 *     @type string       $meta_value             Limit terms to those matching a specific metadata value.
 	 *                                                Usually used in conjunction with `$meta_key`. Default empty.
-	 *     @type string       $meta_type              Type of object metadata is for (e.g., comment, post, or user).
+	 *     @type string       $meta_type              MySQL data type that the `$meta_value` will be CAST to for
-	 *                                                Default empty.
+	 *                                                comparisons. Default empty.
 	 *     @type string       $meta_compare           Comparison operator to test the 'meta_value'. Default empty.
 	 * }
 	 */
 	public function __construct( $query = '' ) {
 		$this->query_var_defaults = array(
 		 *
 		 * Use {@see 'get_terms_args'} to filter the passed arguments.
 		 *
 		 * @since 4.4.0
 		 *
-		 * @param array $defaults   An array of default get_terms() arguments.
+		 * @param array    $defaults   An array of default get_terms() arguments.
-		 * @param array $taxonomies An array of taxonomies.
+		 * @param string[] $taxonomies An array of taxonomy names.
 		 */
 		$this->query_var_defaults = apply_filters( 'get_terms_defaults', $this->query_var_defaults, $taxonomies );
 		$query = wp_parse_args( $query, $this->query_var_defaults );
 		if ( 0 < intval( $query['parent'] ) ) {
 			$query['child_of'] = false;
 		}
 		if ( 'all' == $query['get'] ) {
-			$query['childless'] = false;
+			$query['childless']    = false;
-			$query['child_of'] = 0;
+			$query['child_of']     = 0;
-			$query['hide_empty'] = 0;
+			$query['hide_empty']   = 0;
 			$query['hierarchical'] = false;
-			$query['pad_counts'] = false;
+			$query['pad_counts']   = false;
 		}
 		$query['taxonomy'] = $taxonomies;
 		$this->query_vars = $query;
 			}
 		}
 		if ( ! $has_hierarchical_tax ) {
 			$args['hierarchical'] = false;
-			$args['pad_counts'] = false;
+			$args['pad_counts']   = false;
 		}
 		// 'parent' overrides 'child_of'.
 		if ( 0 < intval( $args['parent'] ) ) {
 			$args['child_of'] = false;
 		}
 		if ( 'all' == $args['get'] ) {
-			$args['childless'] = false;
+			$args['childless']    = false;
-			$args['child_of'] = 0;
+			$args['child_of']     = 0;
-			$args['hide_empty'] = 0;
+			$args['hide_empty']   = 0;
 			$args['hierarchical'] = false;
-			$args['pad_counts'] = false;
+			$args['pad_counts']   = false;
 		}
 		/**
 		 * Filters the terms query arguments.
 		 *
 		 * @since 3.1.0
 		 *
-		 * @param array $args       An array of get_terms() arguments.
+		 * @param array    $args       An array of get_terms() arguments.
-		 * @param array $taxonomies An array of taxonomies.
+		 * @param string[] $taxonomies An array of taxonomy names.
 		 */
 		$args = apply_filters( 'get_terms_args', $args, $taxonomies );
 		// Avoid the query if the queried parent/child_of term has no descendants.
 		$child_of = $args['child_of'];
 					$in_hierarchy = true;
 				}
 			}
 			if ( ! $in_hierarchy ) {
-				return array();
+				if ( 'count' == $args['fields'] ) {
+					return 0;
+				} else {
+					$this->terms = array();
+					return $this->terms;
+				}
 			}
 		}
 		// 'term_order' is a legal sort order only when joining the relationship table.
 		$_orderby = $this->query_vars['orderby'];
 		$exclude_tree = $args['exclude_tree'];
 		$include      = $args['include'];
 		$inclusions = '';
 		if ( ! empty( $include ) ) {
-			$exclude = '';
+			$exclude      = '';
 			$exclude_tree = '';
-			$inclusions = implode( ',', wp_parse_id_list( $include ) );
+			$inclusions   = implode( ',', wp_parse_id_list( $include ) );
 		}
 		if ( ! empty( $inclusions ) ) {
 			$this->sql_clauses['where']['inclusions'] = 't.term_id IN ( ' . $inclusions . ' )';
 		}
 		$exclusions = array();
 		if ( ! empty( $exclude_tree ) ) {
-			$exclude_tree = wp_parse_id_list( $exclude_tree );
+			$exclude_tree      = wp_parse_id_list( $exclude_tree );
 			$excluded_children = $exclude_tree;
 			foreach ( $exclude_tree as $extrunk ) {
 				$excluded_children = array_merge(
 					$excluded_children,
-					(array) get_terms( reset( $taxonomies ), array(
+					(array) get_terms(
-						'child_of' => intval( $extrunk ),
+						reset( $taxonomies ),
-						'fields' => 'ids',
+						array(
-						'hide_empty' => 0
+							'child_of'   => intval( $extrunk ),
-					) )
+							'fields'     => 'ids',
+							'hide_empty' => 0,
+						)
+					)
 				);
 			}
 			$exclusions = array_merge( $excluded_children, $exclusions );
 		}
 		// 'childless' terms are those without an entry in the flattened term hierarchy.
 		$childless = (bool) $args['childless'];
 		if ( $childless ) {
 			foreach ( $taxonomies as $_tax ) {
 				$term_hierarchy = _get_term_hierarchy( $_tax );
-				$exclusions = array_merge( array_keys( $term_hierarchy ), $exclusions );
+				$exclusions     = array_merge( array_keys( $term_hierarchy ), $exclusions );
 			}
 		}
 		if ( ! empty( $exclusions ) ) {
 			$exclusions = 't.term_id NOT IN (' . implode( ',', array_map( 'intval', $exclusions ) ) . ')';
 		/**
 		 * Filters the terms to exclude from the terms query.
 		 *
 		 * @since 2.3.0
 		 *
-		 * @param string $exclusions `NOT IN` clause of the terms query.
+		 * @param string   $exclusions `NOT IN` clause of the terms query.
-		 * @param array  $args       An array of terms query arguments.
+		 * @param array    $args       An array of terms query arguments.
-		 * @param array  $taxonomies An array of taxonomies.
+		 * @param string[] $taxonomies An array of taxonomy names.
 		 */
 		$exclusions = apply_filters( 'list_terms_exclusions', $exclusions, $args, $taxonomies );
 		if ( ! empty( $exclusions ) ) {
 			// Must do string manipulation here for backward compatibility with filter.
 		if (
 			( ! empty( $args['slug'] ) ) ||
 			( is_string( $args['slug'] ) && 0 !== strlen( $args['slug'] ) )
 		) {
 			if ( is_array( $args['slug'] ) ) {
-				$slug = array_map( 'sanitize_title', $args['slug'] );
+				$slug                               = array_map( 'sanitize_title', $args['slug'] );
 				$this->sql_clauses['where']['slug'] = "t.slug IN ('" . implode( "', '", $slug ) . "')";
 			} else {
-				$slug = sanitize_title( $args['slug'] );
+				$slug                               = sanitize_title( $args['slug'] );
 				$this->sql_clauses['where']['slug'] = "t.slug = '$slug'";
 			}
 		}
 		if ( ! empty( $args['term_taxonomy_id'] ) ) {
 			if ( is_array( $args['term_taxonomy_id'] ) ) {
 				$tt_ids = implode( ',', array_map( 'intval', $args['term_taxonomy_id'] ) );
 				$this->sql_clauses['where']['term_taxonomy_id'] = "tt.term_taxonomy_id IN ({$tt_ids})";
 			} else {
-				$this->sql_clauses['where']['term_taxonomy_id'] = $wpdb->prepare( "tt.term_taxonomy_id = %d", $args['term_taxonomy_id'] );
+				$this->sql_clauses['where']['term_taxonomy_id'] = $wpdb->prepare( 'tt.term_taxonomy_id = %d', $args['term_taxonomy_id'] );
 			}
 		}
 		if ( ! empty( $args['name__like'] ) ) {
-			$this->sql_clauses['where']['name__like'] = $wpdb->prepare( "t.name LIKE %s", '%' . $wpdb->esc_like( $args['name__like'] ) . '%' );
+			$this->sql_clauses['where']['name__like'] = $wpdb->prepare( 't.name LIKE %s', '%' . $wpdb->esc_like( $args['name__like'] ) . '%' );
 		}
 		if ( ! empty( $args['description__like'] ) ) {
-			$this->sql_clauses['where']['description__like'] = $wpdb->prepare( "tt.description LIKE %s", '%' . $wpdb->esc_like( $args['description__like'] ) . '%' );
+			$this->sql_clauses['where']['description__like'] = $wpdb->prepare( 'tt.description LIKE %s', '%' . $wpdb->esc_like( $args['description__like'] ) . '%' );
 		}
 		if ( ! empty( $args['object_ids'] ) ) {
 			$object_ids = $args['object_ids'];
 			if ( ! is_array( $object_ids ) ) {
 				$object_ids = array( $object_ids );
 			}
-			$object_ids = implode( ', ', array_map( 'intval', $object_ids ) );
+			$object_ids                               = implode( ', ', array_map( 'intval', $object_ids ) );
 			$this->sql_clauses['where']['object_ids'] = "tr.object_id IN ($object_ids)";
 		}
 		/*
 		 * When querying for object relationships, the 'count > 0' check
 		if ( ! empty( $args['object_ids'] ) ) {
 			$args['hide_empty'] = false;
 		}
 		if ( '' !== $parent ) {
-			$parent = (int) $parent;
+			$parent                               = (int) $parent;
 			$this->sql_clauses['where']['parent'] = "tt.parent = '$parent'";
 		}
 		$hierarchical = $args['hierarchical'];
 		if ( 'count' == $args['fields'] ) {
 			$hierarchical = false;
 		}
-		if ( $args['hide_empty'] && !$hierarchical ) {
+		if ( $args['hide_empty'] && ! $hierarchical ) {
 			$this->sql_clauses['where']['count'] = 'tt.count > 0';
 		}
 		$number = $args['number'];
 		$offset = $args['offset'];
 			}
 		} else {
 			$limits = '';
 		}
 		if ( ! empty( $args['search'] ) ) {
 			$this->sql_clauses['where']['search'] = $this->get_search_sql( $args['search'] );
 		}
 		// Meta query support.
-		$join = '';
+		$join     = '';
 		$distinct = '';
 		// Reparse meta_query query_vars, in case they were modified in a 'pre_get_terms' callback.
 		$this->meta_query->parse_query_vars( $this->query_vars );
-		$mq_sql = $this->meta_query->get_sql( 'term', 't', 'term_id' );
+		$mq_sql       = $this->meta_query->get_sql( 'term', 't', 'term_id' );
 		$meta_clauses = $this->meta_query->get_clauses();
 		if ( ! empty( $meta_clauses ) ) {
-			$join .= $mq_sql['join'];
+			$join                                    .= $mq_sql['join'];
 			$this->sql_clauses['where']['meta_query'] = preg_replace( '/^\s*AND\s*/', '', $mq_sql['where'] );
-			$distinct .= "DISTINCT";
+			$distinct                                .= 'DISTINCT';
 		}
 		$selects = array();
 		switch ( $args['fields'] ) {
 			case 'all':
-			case 'all_with_object_id' :
+			case 'all_with_object_id':
-			case 'tt_ids' :
+			case 'tt_ids':
-			case 'slugs' :
+			case 'slugs':
 				$selects = array( 't.*', 'tt.*' );
 				if ( 'all_with_object_id' === $args['fields'] && ! empty( $args['object_ids'] ) ) {
 					$selects[] = 'tr.object_id';
 				}
 				break;
 			case 'names':
 				$selects = array( 't.term_id', 'tt.parent', 'tt.count', 't.name', 'tt.taxonomy' );
 				break;
 			case 'count':
 				$orderby = '';
-				$order = '';
+				$order   = '';
 				$selects = array( 'COUNT(*)' );
 				break;
 			case 'id=>name':
 				$selects = array( 't.term_id', 't.name', 'tt.count', 'tt.taxonomy' );
 				break;
 		 *
 		 * Use of this filter can result in unpredictable behavior, and is not recommended.
 		 *
 		 * @since 2.8.0
 		 *
-		 * @param array $selects    An array of fields to select for the terms query.
+		 * @param string[] $selects    An array of fields to select for the terms query.
-		 * @param array $args       An array of term query arguments.
+		 * @param array    $args       An array of term query arguments.
-		 * @param array $taxonomies An array of taxonomies.
+		 * @param string[] $taxonomies An array of taxonomy names.
 		 */
 		$fields = implode( ', ', apply_filters( 'get_terms_fields', $selects, $args, $taxonomies ) );
 		$join .= " INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id";
 		/**
 		 * Filters the terms query SQL clauses.
 		 *
 		 * @since 3.1.0
 		 *
-		 * @param array $pieces     Terms query SQL clauses.
+		 * @param string[] $pieces     Array of query SQL clauses.
-		 * @param array $taxonomies An array of taxonomies.
+		 * @param string[] $taxonomies An array of taxonomy names.
-		 * @param array $args       An array of terms query arguments.
+		 * @param array    $args       An array of term query arguments.
 		 */
 		$clauses = apply_filters( 'terms_clauses', compact( 'fields', 'join', 'where', 'distinct', 'orderby', 'order', 'limits' ), $taxonomies, $args );
-		$fields = isset( $clauses[ 'fields' ] ) ? $clauses[ 'fields' ] : '';
+		$fields   = isset( $clauses['fields'] ) ? $clauses['fields'] : '';
-		$join = isset( $clauses[ 'join' ] ) ? $clauses[ 'join' ] : '';
+		$join     = isset( $clauses['join'] ) ? $clauses['join'] : '';
-		$where = isset( $clauses[ 'where' ] ) ? $clauses[ 'where' ] : '';
+		$where    = isset( $clauses['where'] ) ? $clauses['where'] : '';
-		$distinct = isset( $clauses[ 'distinct' ] ) ? $clauses[ 'distinct' ] : '';
+		$distinct = isset( $clauses['distinct'] ) ? $clauses['distinct'] : '';
-		$orderby = isset( $clauses[ 'orderby' ] ) ? $clauses[ 'orderby' ] : '';
+		$orderby  = isset( $clauses['orderby'] ) ? $clauses['orderby'] : '';
-		$order = isset( $clauses[ 'order' ] ) ? $clauses[ 'order' ] : '';
+		$order    = isset( $clauses['order'] ) ? $clauses['order'] : '';
-		$limits = isset( $clauses[ 'limits' ] ) ? $clauses[ 'limits' ] : '';
+		$limits   = isset( $clauses['limits'] ) ? $clauses['limits'] : '';
 		if ( $where ) {
 			$where = "WHERE $where";
 		}
 		$this->sql_clauses['limits']  = $limits;
 		$this->request = "{$this->sql_clauses['select']} {$this->sql_clauses['from']} {$where} {$this->sql_clauses['orderby']} {$this->sql_clauses['limits']}";
 		// $args can be anything. Only use the args defined in defaults to compute the key.
-		$key = md5( serialize( wp_array_slice_assoc( $args, array_keys( $this->query_var_defaults ) ) ) . serialize( $taxonomies ) . $this->request );
+		$key          = md5( serialize( wp_array_slice_assoc( $args, array_keys( $this->query_var_defaults ) ) ) . serialize( $taxonomies ) . $this->request );
 		$last_changed = wp_cache_get_last_changed( 'terms' );
-		$cache_key = "get_terms:$key:$last_changed";
+		$cache_key    = "get_terms:$key:$last_changed";
-		$cache = wp_cache_get( $cache_key, 'terms' );
+		$cache        = wp_cache_get( $cache_key, 'terms' );
 		if ( false !== $cache ) {
 			if ( 'all' === $_fields || 'all_with_object_id' === $_fields ) {
 				$cache = $this->populate_terms( $cache );
 			}
 				if ( isset( $_tt_ids[ $term->term_id ] ) ) {
 					continue;
 				}
 				$_tt_ids[ $term->term_id ] = 1;
-				$_terms[] = $term;
+				$_terms[]                  = $term;
 			}
 			$terms = $_terms;
 		}
 	 *
 	 * @param string $orderby_raw Alias for the field to order by.
 	 * @return string|false Value to used in the ORDER clause. False otherwise.
 	 */
 	protected function parse_orderby( $orderby_raw ) {
-		$_orderby = strtolower( $orderby_raw );
+		$_orderby           = strtolower( $orderby_raw );
 		$maybe_orderby_meta = false;
 		if ( in_array( $_orderby, array( 'term_id', 'name', 'slug', 'term_group' ), true ) ) {
 			$orderby = "t.$_orderby";
 		} elseif ( in_array( $_orderby, array( 'count', 'parent', 'taxonomy', 'term_taxonomy_id', 'description' ), true ) ) {
 			$orderby = 'tr.term_order';
 		} elseif ( 'include' == $_orderby && ! empty( $this->query_vars['include'] ) ) {
 			$include = implode( ',', wp_parse_id_list( $this->query_vars['include'] ) );
 			$orderby = "FIELD( t.term_id, $include )";
 		} elseif ( 'slug__in' == $_orderby && ! empty( $this->query_vars['slug'] ) && is_array( $this->query_vars['slug'] ) ) {
-			$slugs = implode( "', '", array_map( 'sanitize_title_for_query', $this->query_vars['slug'] ) );
+			$slugs   = implode( "', '", array_map( 'sanitize_title_for_query', $this->query_vars['slug'] ) );
 			$orderby = "FIELD( t.slug, '" . $slugs . "')";
 		} elseif ( 'none' == $_orderby ) {
 			$orderby = '';
 		} elseif ( empty( $_orderby ) || 'id' == $_orderby || 'term_id' === $_orderby ) {
 			$orderby = 't.term_id';
 		/**
 		 * Filters the ORDERBY clause of the terms query.
 		 *
 		 * @since 2.8.0
 		 *
-		 * @param string $orderby    `ORDERBY` clause of the terms query.
+		 * @param string   $orderby    `ORDERBY` clause of the terms query.
-		 * @param array  $args       An array of terms query arguments.
+		 * @param array    $args       An array of term query arguments.
-		 * @param array  $taxonomies An array of taxonomies.
+		 * @param string[] $taxonomies An array of taxonomy names.
 		 */
 		$orderby = apply_filters( 'get_terms_orderby', $orderby, $this->query_vars, $this->query_vars['taxonomy'] );
 		// Run after the 'get_terms_orderby' filter for backward compatibility.
 		if ( $maybe_orderby_meta ) {
 		$meta_clauses = $this->meta_query->get_clauses();
 		if ( ! $meta_clauses || ! $orderby_raw ) {
 			return $orderby;
 		}
-		$allowed_keys = array();
+		$allowed_keys       = array();
-		$primary_meta_key = null;
+		$primary_meta_key   = null;
 		$primary_meta_query = reset( $meta_clauses );
 		if ( ! empty( $primary_meta_query['key'] ) ) {
 			$primary_meta_key = $primary_meta_query['key'];
-			$allowed_keys[] = $primary_meta_key;
+			$allowed_keys[]   = $primary_meta_key;
 		}
 		$allowed_keys[] = 'meta_value';
 		$allowed_keys[] = 'meta_value_num';
 		$allowed_keys   = array_merge( $allowed_keys, array_keys( $meta_clauses ) );
 		if ( ! in_array( $orderby_raw, $allowed_keys, true ) ) {
 			return $orderby;
 		}
-		switch( $orderby_raw ) {
+		switch ( $orderby_raw ) {
 			case $primary_meta_key:
 			case 'meta_value':
 				if ( ! empty( $primary_meta_query['type'] ) ) {
 					$orderby = "CAST({$primary_meta_query['alias']}.meta_value AS {$primary_meta_query['cast']})";
 				} else {
 			default:
 				if ( array_key_exists( $orderby_raw, $meta_clauses ) ) {
 					// $orderby corresponds to a meta_query clause.
 					$meta_clause = $meta_clauses[ $orderby_raw ];
-					$orderby = "CAST({$meta_clause['alias']}.meta_value AS {$meta_clause['cast']})";
+					$orderby     = "CAST({$meta_clause['alias']}.meta_value AS {$meta_clause['cast']})";
 				}
 				break;
 		}
 		return $orderby;

changeset 9	177826044cd9
parent 7	cf61fcea0001
child 16	a86126ab1dd4