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

equal deleted inserted replaced

-:7b1b88e27a20
+:48c4eec2b7e6
 * their results by object metadata, by generating `JOIN` and `WHERE` subclauses to be
 * attached to the primary SQL query string.
 *
 * @since 3.1.0
 */
+#[AllowDynamicProperties]
 class WP_Tax_Query {
 	/**
 	 * Array of taxonomy queries.
 	 *
 		$this->queries = $this->sanitize_query( $tax_query );
 	}
 	/**
-	 * Ensure the 'tax_query' argument passed to the class constructor is well-formed.
+	 * Ensures the 'tax_query' argument passed to the class constructor is well-formed.
 	 *
 	 * Ensures that each query-level clause has a 'relation' key, and that
 	 * each first-order clause contains all the necessary keys from `$defaults`.
 	 *
 	 * @since 4.1.0
 		return $cleaned_query;
 	}
 	/**
-	 * Sanitize a 'relation' operator.
+	 * Sanitizes a 'relation' operator.
 	 *
 	 * @since 4.1.0
 	 *
 	 * @param string $relation Raw relation key from the query argument.
-	 * @return string Sanitized relation ('AND' or 'OR').
+	 * @return string Sanitized relation. Either 'AND' or 'OR'.
 	 */
 	public function sanitize_relation( $relation ) {
 		if ( 'OR' === strtoupper( $relation ) ) {
 			return 'OR';
 		} else {
 			return 'AND';
 		}
 	}
 	/**
-	 * Determine whether a clause is first-order.
+	 * Determines whether a clause is first-order.
 	 *
 	 * A "first-order" clause is one that contains any of the first-order
 	 * clause keys ('terms', 'taxonomy', 'include_children', 'field',
 	 * 'operator'). An empty clause also counts as a first-order clause,
 	 * for backward compatibility. Any clause that doesn't meet this is
 		return $this->get_sql_clauses();
 	}
 	/**
-	 * Generate SQL clauses to be appended to a main query.
+	 * Generates SQL clauses to be appended to a main query.
 	 *
 	 * Called by the public WP_Tax_Query::get_sql(), this method
 	 * is abstracted out to maintain parity with the other Query classes.
 	 *
 	 * @since 4.1.0
 		return $sql;
 	}
 	/**
-	 * Generate SQL clauses for a single query array.
+	 * Generates SQL clauses for a single query array.
 	 *
 	 * If nested subqueries are found, this method recurses the tree to
 	 * produce the properly nested SQL.
 	 *
 	 * @since 4.1.0
 		return $sql;
 	}
 	/**
-	 * Generate SQL JOIN and WHERE clauses for a "first-order" query clause.
+	 * Generates SQL JOIN and WHERE clauses for a "first-order" query clause.
 	 *
 	 * @since 4.1.0
 	 *
 	 * @global wpdb $wpdb The WordPress database abstraction object.
 	 *
 	 * @param array $clause       Query clause (passed by reference).
 	 * @param array $parent_query Parent query array.
-	 * @return string[] {
+	 * @return array {
 	 *     Array containing JOIN and WHERE SQL clauses to append to a first-order query.
 	 *
-	 *     @type string $join  SQL fragment to append to the main JOIN clause.
+	 *     @type string[] $join  Array of SQL fragments to append to the main JOIN clause.
-	 *     @type string $where SQL fragment to append to the main WHERE clause.
+	 *     @type string[] $where Array of SQL fragments to append to the main WHERE clause.
 	 * }
 	 */
 	public function get_sql_for_clause( &$clause, $parent_query ) {
 		global $wpdb;
 		} elseif ( 'NOT EXISTS' === $operator || 'EXISTS' === $operator ) {
 			$where = $wpdb->prepare(
 				"$operator (
-				SELECT 1
+					SELECT 1
-				FROM $wpdb->term_relationships
+					FROM $wpdb->term_relationships
-				INNER JOIN $wpdb->term_taxonomy
+					INNER JOIN $wpdb->term_taxonomy
-				ON $wpdb->term_taxonomy.term_taxonomy_id = $wpdb->term_relationships.term_taxonomy_id
+					ON $wpdb->term_taxonomy.term_taxonomy_id = $wpdb->term_relationships.term_taxonomy_id
-				WHERE $wpdb->term_taxonomy.taxonomy = %s
+					WHERE $wpdb->term_taxonomy.taxonomy = %s
-				AND $wpdb->term_relationships.object_id = $this->primary_table.$this->primary_id_column
+					AND $wpdb->term_relationships.object_id = $this->primary_table.$this->primary_id_column
-			)",
+				)",
 				$clause['taxonomy']
 			);
 		}
 		$sql['where'][] = $where;
 		return $sql;
 	}
 	/**
-	 * Identify an existing table alias that is compatible with the current query clause.
+	 * Identifies an existing table alias that is compatible with the current query clause.
 	 *
 	 * We avoid unnecessary table joins by allowing each clause to look for
 	 * an existing table alias that is compatible with the query that it
 	 * needs to perform.
 	 *
 	 * @return string|false Table alias if found, otherwise false.
 	 */
 	protected function find_compatible_table_alias( $clause, $parent_query ) {
 		$alias = false;
-		// Sanity check. Only IN queries use the JOIN syntax.
+		// Confidence check. Only IN queries use the JOIN syntax.
 		if ( ! isset( $clause['operator'] ) || 'IN' !== $clause['operator'] ) {
 			return $alias;
 		}
 		// Since we're only checking IN queries, we're only concerned with OR relations.
 	 * Operates on the `$query` object by reference. In the case of error,
 	 * `$query` is converted to a WP_Error object.
 	 *
 	 * @since 3.2.0
 	 *
-	 * @global wpdb $wpdb The WordPress database abstraction object.
-	 *
 	 * @param array  $query           The single query. Passed by reference.
 	 * @param string $resulting_field The resulting field. Accepts 'slug', 'name', 'term_taxonomy_id',
 	 *                                or 'term_id'. Default 'term_id'.
 	 */
 	public function transform_query( &$query, $resulting_field ) {
 		if ( empty( $query['terms'] ) ) {
 			return;
 		}
-		if ( $query['field'] == $resulting_field ) {
+		if ( $query['field'] === $resulting_field ) {
 			return;
 		}
 		$resulting_field = sanitize_key( $resulting_field );

changeset 21	48c4eec2b7e6
parent 19	3d72ae0968f4