[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/ -> taxonomy.php (source)

   1  <?php
   2  /**
   3   * Core Taxonomy API
   4   *
   5   * @package WordPress
   6   * @subpackage Taxonomy
   7   */
   8  
   9  //
  10  // Taxonomy registration.
  11  //
  12  
  13  /**
  14   * Creates the initial taxonomies.
  15   *
  16   * This function fires twice: in wp-settings.php before plugins are loaded (for
  17   * backward compatibility reasons), and again on the {@see 'init'} action. We must
  18   * avoid registering rewrite rules before the {@see 'init'} action.
  19   *
  20   * @since 2.8.0
  21   *
  22   * @global WP_Rewrite $wp_rewrite WordPress rewrite component.
  23   */
  24  function create_initial_taxonomies() {
  25      global $wp_rewrite;
  26  
  27      if ( ! did_action( 'init' ) ) {
  28          $rewrite = array(
  29              'category'    => false,
  30              'post_tag'    => false,
  31              'post_format' => false,
  32          );
  33      } else {
  34  
  35          /**
  36           * Filters the post formats rewrite base.
  37           *
  38           * @since 3.1.0
  39           *
  40           * @param string $context Context of the rewrite base. Default 'type'.
  41           */
  42          $post_format_base = apply_filters( 'post_format_rewrite_base', 'type' );
  43          $rewrite          = array(
  44              'category'    => array(
  45                  'hierarchical' => true,
  46                  'slug'         => get_option( 'category_base' ) ? get_option( 'category_base' ) : 'category',
  47                  'with_front'   => ! get_option( 'category_base' ) || $wp_rewrite->using_index_permalinks(),
  48                  'ep_mask'      => EP_CATEGORIES,
  49              ),
  50              'post_tag'    => array(
  51                  'hierarchical' => false,
  52                  'slug'         => get_option( 'tag_base' ) ? get_option( 'tag_base' ) : 'tag',
  53                  'with_front'   => ! get_option( 'tag_base' ) || $wp_rewrite->using_index_permalinks(),
  54                  'ep_mask'      => EP_TAGS,
  55              ),
  56              'post_format' => $post_format_base ? array( 'slug' => $post_format_base ) : false,
  57          );
  58      }
  59  
  60      register_taxonomy(
  61          'category',
  62          'post',
  63          array(
  64              'hierarchical'          => true,
  65              'query_var'             => 'category_name',
  66              'rewrite'               => $rewrite['category'],
  67              'public'                => true,
  68              'show_ui'               => true,
  69              'show_admin_column'     => true,
  70              '_builtin'              => true,
  71              'capabilities'          => array(
  72                  'manage_terms' => 'manage_categories',
  73                  'edit_terms'   => 'edit_categories',
  74                  'delete_terms' => 'delete_categories',
  75                  'assign_terms' => 'assign_categories',
  76              ),
  77              'show_in_rest'          => true,
  78              'rest_base'             => 'categories',
  79              'rest_controller_class' => 'WP_REST_Terms_Controller',
  80          )
  81      );
  82  
  83      register_taxonomy(
  84          'post_tag',
  85          'post',
  86          array(
  87              'hierarchical'          => false,
  88              'query_var'             => 'tag',
  89              'rewrite'               => $rewrite['post_tag'],
  90              'public'                => true,
  91              'show_ui'               => true,
  92              'show_admin_column'     => true,
  93              '_builtin'              => true,
  94              'capabilities'          => array(
  95                  'manage_terms' => 'manage_post_tags',
  96                  'edit_terms'   => 'edit_post_tags',
  97                  'delete_terms' => 'delete_post_tags',
  98                  'assign_terms' => 'assign_post_tags',
  99              ),
 100              'show_in_rest'          => true,
 101              'rest_base'             => 'tags',
 102              'rest_controller_class' => 'WP_REST_Terms_Controller',
 103          )
 104      );
 105  
 106      register_taxonomy(
 107          'nav_menu',
 108          'nav_menu_item',
 109          array(
 110              'public'            => false,
 111              'hierarchical'      => false,
 112              'labels'            => array(
 113                  'name'          => __( 'Navigation Menus' ),
 114                  'singular_name' => __( 'Navigation Menu' ),
 115              ),
 116              'query_var'         => false,
 117              'rewrite'           => false,
 118              'show_ui'           => false,
 119              '_builtin'          => true,
 120              'show_in_nav_menus' => false,
 121          )
 122      );
 123  
 124      register_taxonomy(
 125          'link_category',
 126          'link',
 127          array(
 128              'hierarchical' => false,
 129              'labels'       => array(
 130                  'name'                       => __( 'Link Categories' ),
 131                  'singular_name'              => __( 'Link Category' ),
 132                  'search_items'               => __( 'Search Link Categories' ),
 133                  'popular_items'              => null,
 134                  'all_items'                  => __( 'All Link Categories' ),
 135                  'edit_item'                  => __( 'Edit Link Category' ),
 136                  'update_item'                => __( 'Update Link Category' ),
 137                  'add_new_item'               => __( 'Add New Link Category' ),
 138                  'new_item_name'              => __( 'New Link Category Name' ),
 139                  'separate_items_with_commas' => null,
 140                  'add_or_remove_items'        => null,
 141                  'choose_from_most_used'      => null,
 142                  'back_to_items'              => __( '&larr; Go to Link Categories' ),
 143              ),
 144              'capabilities' => array(
 145                  'manage_terms' => 'manage_links',
 146                  'edit_terms'   => 'manage_links',
 147                  'delete_terms' => 'manage_links',
 148                  'assign_terms' => 'manage_links',
 149              ),
 150              'query_var'    => false,
 151              'rewrite'      => false,
 152              'public'       => false,
 153              'show_ui'      => true,
 154              '_builtin'     => true,
 155          )
 156      );
 157  
 158      register_taxonomy(
 159          'post_format',
 160          'post',
 161          array(
 162              'public'            => true,
 163              'hierarchical'      => false,
 164              'labels'            => array(
 165                  'name'          => _x( 'Formats', 'post format' ),
 166                  'singular_name' => _x( 'Format', 'post format' ),
 167              ),
 168              'query_var'         => true,
 169              'rewrite'           => $rewrite['post_format'],
 170              'show_ui'           => false,
 171              '_builtin'          => true,
 172              'show_in_nav_menus' => current_theme_supports( 'post-formats' ),
 173          )
 174      );
 175  
 176      register_taxonomy(
 177          'wp_theme',
 178          array( 'wp_template' ),
 179          array(
 180              'public'            => false,
 181              'hierarchical'      => false,
 182              'labels'            => array(
 183                  'name'          => __( 'Themes' ),
 184                  'singular_name' => __( 'Theme' ),
 185              ),
 186              'query_var'         => false,
 187              'rewrite'           => false,
 188              'show_ui'           => false,
 189              '_builtin'          => true,
 190              'show_in_nav_menus' => false,
 191              'show_in_rest'      => false,
 192          )
 193      );
 194  }
 195  
 196  /**
 197   * Retrieves a list of registered taxonomy names or objects.
 198   *
 199   * @since 3.0.0
 200   *
 201   * @global array $wp_taxonomies The registered taxonomies.
 202   *
 203   * @param array  $args     Optional. An array of `key => value` arguments to match against the taxonomy objects.
 204   *                         Default empty array.
 205   * @param string $output   Optional. The type of output to return in the array. Accepts either taxonomy 'names'
 206   *                         or 'objects'. Default 'names'.
 207   * @param string $operator Optional. The logical operation to perform. Accepts 'and' or 'or'. 'or' means only
 208   *                         one element from the array needs to match; 'and' means all elements must match.
 209   *                         Default 'and'.
 210   * @return string[]|WP_Taxonomy[] An array of taxonomy names or objects.
 211   */
 212  function get_taxonomies( $args = array(), $output = 'names', $operator = 'and' ) {
 213      global $wp_taxonomies;
 214  
 215      $field = ( 'names' === $output ) ? 'name' : false;
 216  
 217      return wp_filter_object_list( $wp_taxonomies, $args, $operator, $field );
 218  }
 219  
 220  /**
 221   * Return the names or objects of the taxonomies which are registered for the requested object or object type, such as
 222   * a post object or post type name.
 223   *
 224   * Example:
 225   *
 226   *     $taxonomies = get_object_taxonomies( 'post' );
 227   *
 228   * This results in:
 229   *
 230   *     Array( 'category', 'post_tag' )
 231   *
 232   * @since 2.3.0
 233   *
 234   * @global array $wp_taxonomies The registered taxonomies.
 235   *
 236   * @param string|string[]|WP_Post $object Name of the type of taxonomy object, or an object (row from posts)
 237   * @param string                  $output Optional. The type of output to return in the array. Accepts either
 238   *                                        'names' or 'objects'. Default 'names'.
 239   * @return string[]|WP_Taxonomy[] The names or objects of all taxonomies of `$object_type`.
 240   */
 241  function get_object_taxonomies( $object, $output = 'names' ) {
 242      global $wp_taxonomies;
 243  
 244      if ( is_object( $object ) ) {
 245          if ( 'attachment' === $object->post_type ) {
 246              return get_attachment_taxonomies( $object, $output );
 247          }
 248          $object = $object->post_type;
 249      }
 250  
 251      $object = (array) $object;
 252  
 253      $taxonomies = array();
 254      foreach ( (array) $wp_taxonomies as $tax_name => $tax_obj ) {
 255          if ( array_intersect( $object, (array) $tax_obj->object_type ) ) {
 256              if ( 'names' === $output ) {
 257                  $taxonomies[] = $tax_name;
 258              } else {
 259                  $taxonomies[ $tax_name ] = $tax_obj;
 260              }
 261          }
 262      }
 263  
 264      return $taxonomies;
 265  }
 266  
 267  /**
 268   * Retrieves the taxonomy object of $taxonomy.
 269   *
 270   * The get_taxonomy function will first check that the parameter string given
 271   * is a taxonomy object and if it is, it will return it.
 272   *
 273   * @since 2.3.0
 274   *
 275   * @global array $wp_taxonomies The registered taxonomies.
 276   *
 277   * @param string $taxonomy Name of taxonomy object to return.
 278   * @return WP_Taxonomy|false The Taxonomy Object or false if $taxonomy doesn't exist.
 279   */
 280  function get_taxonomy( $taxonomy ) {
 281      global $wp_taxonomies;
 282  
 283      if ( ! taxonomy_exists( $taxonomy ) ) {
 284          return false;
 285      }
 286  
 287      return $wp_taxonomies[ $taxonomy ];
 288  }
 289  
 290  /**
 291   * Determines whether the taxonomy name exists.
 292   *
 293   * Formerly is_taxonomy(), introduced in 2.3.0.
 294   *
 295   * For more information on this and similar theme functions, check out
 296   * the {@link https://developer.wordpress.org/themes/basics/conditional-tags/
 297   * Conditional Tags} article in the Theme Developer Handbook.
 298   *
 299   * @since 3.0.0
 300   *
 301   * @global array $wp_taxonomies The registered taxonomies.
 302   *
 303   * @param string $taxonomy Name of taxonomy object.
 304   * @return bool Whether the taxonomy exists.
 305   */
 306  function taxonomy_exists( $taxonomy ) {
 307      global $wp_taxonomies;
 308  
 309      return isset( $wp_taxonomies[ $taxonomy ] );
 310  }
 311  
 312  /**
 313   * Determines whether the taxonomy object is hierarchical.
 314   *
 315   * Checks to make sure that the taxonomy is an object first. Then Gets the
 316   * object, and finally returns the hierarchical value in the object.
 317   *
 318   * A false return value might also mean that the taxonomy does not exist.
 319   *
 320   * For more information on this and similar theme functions, check out
 321   * the {@link https://developer.wordpress.org/themes/basics/conditional-tags/
 322   * Conditional Tags} article in the Theme Developer Handbook.
 323   *
 324   * @since 2.3.0
 325   *
 326   * @param string $taxonomy Name of taxonomy object.
 327   * @return bool Whether the taxonomy is hierarchical.
 328   */
 329  function is_taxonomy_hierarchical( $taxonomy ) {
 330      if ( ! taxonomy_exists( $taxonomy ) ) {
 331          return false;
 332      }
 333  
 334      $taxonomy = get_taxonomy( $taxonomy );
 335      return $taxonomy->hierarchical;
 336  }
 337  
 338  /**
 339   * Creates or modifies a taxonomy object.
 340   *
 341   * Note: Do not use before the {@see 'init'} hook.
 342   *
 343   * A simple function for creating or modifying a taxonomy object based on
 344   * the parameters given. If modifying an existing taxonomy object, note
 345   * that the `$object_type` value from the original registration will be
 346   * overwritten.
 347   *
 348   * @since 2.3.0
 349   * @since 4.2.0 Introduced `show_in_quick_edit` argument.
 350   * @since 4.4.0 The `show_ui` argument is now enforced on the term editing screen.
 351   * @since 4.4.0 The `public` argument now controls whether the taxonomy can be queried on the front end.
 352   * @since 4.5.0 Introduced `publicly_queryable` argument.
 353   * @since 4.7.0 Introduced `show_in_rest`, 'rest_base' and 'rest_controller_class'
 354   *              arguments to register the Taxonomy in REST API.
 355   * @since 5.1.0 Introduced `meta_box_sanitize_cb` argument.
 356   * @since 5.4.0 Added the registered taxonomy object as a return value.
 357   * @since 5.5.0 Introduced `default_term` argument.
 358   *
 359   * @global array $wp_taxonomies Registered taxonomies.
 360   *
 361   * @param string       $taxonomy    Taxonomy key, must not exceed 32 characters.
 362   * @param array|string $object_type Object type or array of object types with which the taxonomy should be associated.
 363   * @param array|string $args        {
 364   *     Optional. Array or query string of arguments for registering a taxonomy.
 365   *
 366   *     @type string[]      $labels                An array of labels for this taxonomy. By default, Tag labels are
 367   *                                                used for non-hierarchical taxonomies, and Category labels are used
 368   *                                                for hierarchical taxonomies. See accepted values in
 369   *                                                get_taxonomy_labels(). Default empty array.
 370   *     @type string        $description           A short descriptive summary of what the taxonomy is for. Default empty.
 371   *     @type bool          $public                Whether a taxonomy is intended for use publicly either via
 372   *                                                the admin interface or by front-end users. The default settings
 373   *                                                of `$publicly_queryable`, `$show_ui`, and `$show_in_nav_menus`
 374   *                                                are inherited from `$public`.
 375   *     @type bool          $publicly_queryable    Whether the taxonomy is publicly queryable.
 376   *                                                If not set, the default is inherited from `$public`
 377   *     @type bool          $hierarchical          Whether the taxonomy is hierarchical. Default false.
 378   *     @type bool          $show_ui               Whether to generate and allow a UI for managing terms in this taxonomy in
 379   *                                                the admin. If not set, the default is inherited from `$public`
 380   *                                                (default true).
 381   *     @type bool          $show_in_menu          Whether to show the taxonomy in the admin menu. If true, the taxonomy is
 382   *                                                shown as a submenu of the object type menu. If false, no menu is shown.
 383   *                                                `$show_ui` must be true. If not set, default is inherited from `$show_ui`
 384   *                                                (default true).
 385   *     @type bool          $show_in_nav_menus     Makes this taxonomy available for selection in navigation menus. If not
 386   *                                                set, the default is inherited from `$public` (default true).
 387   *     @type bool          $show_in_rest          Whether to include the taxonomy in the REST API. Set this to true
 388   *                                                for the taxonomy to be available in the block editor.
 389   *     @type string        $rest_base             To change the base url of REST API route. Default is $taxonomy.
 390   *     @type string        $rest_controller_class REST API Controller class name. Default is 'WP_REST_Terms_Controller'.
 391   *     @type bool          $show_tagcloud         Whether to list the taxonomy in the Tag Cloud Widget controls. If not set,
 392   *                                                the default is inherited from `$show_ui` (default true).
 393   *     @type bool          $show_in_quick_edit    Whether to show the taxonomy in the quick/bulk edit panel. It not set,
 394   *                                                the default is inherited from `$show_ui` (default true).
 395   *     @type bool          $show_admin_column     Whether to display a column for the taxonomy on its post type listing
 396   *                                                screens. Default false.
 397   *     @type bool|callable $meta_box_cb           Provide a callback function for the meta box display. If not set,
 398   *                                                post_categories_meta_box() is used for hierarchical taxonomies, and
 399   *                                                post_tags_meta_box() is used for non-hierarchical. If false, no meta
 400   *                                                box is shown.
 401   *     @type callable      $meta_box_sanitize_cb  Callback function for sanitizing taxonomy data saved from a meta
 402   *                                                box. If no callback is defined, an appropriate one is determined
 403   *                                                based on the value of `$meta_box_cb`.
 404   *     @type string[]      $capabilities {
 405   *         Array of capabilities for this taxonomy.
 406   *
 407   *         @type string $manage_terms Default 'manage_categories'.
 408   *         @type string $edit_terms   Default 'manage_categories'.
 409   *         @type string $delete_terms Default 'manage_categories'.
 410   *         @type string $assign_terms Default 'edit_posts'.
 411   *     }
 412   *     @type bool|array    $rewrite {
 413   *         Triggers the handling of rewrites for this taxonomy. Default true, using $taxonomy as slug. To prevent
 414   *         rewrite, set to false. To specify rewrite rules, an array can be passed with any of these keys:
 415   *
 416   *         @type string $slug         Customize the permastruct slug. Default `$taxonomy` key.
 417   *         @type bool   $with_front   Should the permastruct be prepended with WP_Rewrite::$front. Default true.
 418   *         @type bool   $hierarchical Either hierarchical rewrite tag or not. Default false.
 419   *         @type int    $ep_mask      Assign an endpoint mask. Default `EP_NONE`.
 420   *     }
 421   *     @type string|bool   $query_var             Sets the query var key for this taxonomy. Default `$taxonomy` key. If
 422   *                                                false, a taxonomy cannot be loaded at `?{query_var}={term_slug}`. If a
 423   *                                                string, the query `?{query_var}={term_slug}` will be valid.
 424   *     @type callable      $update_count_callback Works much like a hook, in that it will be called when the count is
 425   *                                                updated. Default _update_post_term_count() for taxonomies attached
 426   *                                                to post types, which confirms that the objects are published before
 427   *                                                counting them. Default _update_generic_term_count() for taxonomies
 428   *                                                attached to other object types, such as users.
 429   *     @type string|array  $default_term {
 430   *         Default term to be used for the taxonomy.
 431   *
 432   *         @type string $name         Name of default term.
 433   *         @type string $slug         Slug for default term. Default empty.
 434   *         @type string $description  Description for default term. Default empty.
 435   *     }
 436   *     @type bool          $sort                  Whether terms in this taxonomy should be sorted in the order they are
 437   *                                                provided to `wp_set_object_terms()`. Default null which equates to false.
 438   *     @type array         $args                  Array of arguments to automatically use inside `wp_get_object_terms()`
 439   *                                                for this taxonomy.
 440   *     @type bool          $_builtin              This taxonomy is a "built-in" taxonomy. INTERNAL USE ONLY!
 441   *                                                Default false.
 442   * }
 443   * @return WP_Taxonomy|WP_Error The registered taxonomy object on success, WP_Error object on failure.
 444   */
 445  function register_taxonomy( $taxonomy, $object_type, $args = array() ) {
 446      global $wp_taxonomies;
 447  
 448      if ( ! is_array( $wp_taxonomies ) ) {
 449          $wp_taxonomies = array();
 450      }
 451  
 452      $args = wp_parse_args( $args );
 453  
 454      if ( empty( $taxonomy ) || strlen( $taxonomy ) > 32 ) {
 455          _doing_it_wrong( __FUNCTION__, __( 'Taxonomy names must be between 1 and 32 characters in length.' ), '4.2.0' );
 456          return new WP_Error( 'taxonomy_length_invalid', __( 'Taxonomy names must be between 1 and 32 characters in length.' ) );
 457      }
 458  
 459      $taxonomy_object = new WP_Taxonomy( $taxonomy, $object_type, $args );
 460      $taxonomy_object->add_rewrite_rules();
 461  
 462      $wp_taxonomies[ $taxonomy ] = $taxonomy_object;
 463  
 464      $taxonomy_object->add_hooks();
 465  
 466      // Add default term.
 467      if ( ! empty( $taxonomy_object->default_term ) ) {
 468          $term = term_exists( $taxonomy_object->default_term['name'], $taxonomy );
 469          if ( $term ) {
 470              update_option( 'default_term_' . $taxonomy_object->name, $term['term_id'] );
 471          } else {
 472              $term = wp_insert_term(
 473                  $taxonomy_object->default_term['name'],
 474                  $taxonomy,
 475                  array(
 476                      'slug'        => sanitize_title( $taxonomy_object->default_term['slug'] ),
 477                      'description' => $taxonomy_object->default_term['description'],
 478                  )
 479              );
 480  
 481              // Update `term_id` in options.
 482              if ( ! is_wp_error( $term ) ) {
 483                  update_option( 'default_term_' . $taxonomy_object->name, $term['term_id'] );
 484              }
 485          }
 486      }
 487  
 488      /**
 489       * Fires after a taxonomy is registered.
 490       *
 491       * @since 3.3.0
 492       *
 493       * @param string       $taxonomy    Taxonomy slug.
 494       * @param array|string $object_type Object type or array of object types.
 495       * @param array        $args        Array of taxonomy registration arguments.
 496       */
 497      do_action( 'registered_taxonomy', $taxonomy, $object_type, (array) $taxonomy_object );
 498  
 499      return $taxonomy_object;
 500  }
 501  
 502  /**
 503   * Unregisters a taxonomy.
 504   *
 505   * Can not be used to unregister built-in taxonomies.
 506   *
 507   * @since 4.5.0
 508   *
 509   * @global WP    $wp            Current WordPress environment instance.
 510   * @global array $wp_taxonomies List of taxonomies.
 511   *
 512   * @param string $taxonomy Taxonomy name.
 513   * @return true|WP_Error True on success, WP_Error on failure or if the taxonomy doesn't exist.
 514   */
 515  function unregister_taxonomy( $taxonomy ) {
 516      if ( ! taxonomy_exists( $taxonomy ) ) {
 517          return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
 518      }
 519  
 520      $taxonomy_object = get_taxonomy( $taxonomy );
 521  
 522      // Do not allow unregistering internal taxonomies.
 523      if ( $taxonomy_object->_builtin ) {
 524          return new WP_Error( 'invalid_taxonomy', __( 'Unregistering a built-in taxonomy is not allowed.' ) );
 525      }
 526  
 527      global $wp_taxonomies;
 528  
 529      $taxonomy_object->remove_rewrite_rules();
 530      $taxonomy_object->remove_hooks();
 531  
 532      // Remove custom taxonomy default term option.
 533      if ( ! empty( $taxonomy_object->default_term ) ) {
 534          delete_option( 'default_term_' . $taxonomy_object->name );
 535      }
 536  
 537      // Remove the taxonomy.
 538      unset( $wp_taxonomies[ $taxonomy ] );
 539  
 540      /**
 541       * Fires after a taxonomy is unregistered.
 542       *
 543       * @since 4.5.0
 544       *
 545       * @param string $taxonomy Taxonomy name.
 546       */
 547      do_action( 'unregistered_taxonomy', $taxonomy );
 548  
 549      return true;
 550  }
 551  
 552  /**
 553   * Builds an object with all taxonomy labels out of a taxonomy object.
 554   *
 555   * @since 3.0.0
 556   * @since 4.3.0 Added the `no_terms` label.
 557   * @since 4.4.0 Added the `items_list_navigation` and `items_list` labels.
 558   * @since 4.9.0 Added the `most_used` and `back_to_items` labels.
 559   * @since 5.7.0 Added the `filter_by_item` label.
 560   * @since 5.8.0 Added the `item_link` and `item_link_description` labels.
 561   *
 562   * @param WP_Taxonomy $tax Taxonomy object.
 563   * @return object {
 564   *     Taxonomy labels object. The first default value is for non-hierarchical taxonomies
 565   *     (like tags) and the second one is for hierarchical taxonomies (like categories).
 566   *
 567   *     @type string $name                       General name for the taxonomy, usually plural. The same
 568   *                                              as and overridden by `$tax->label`. Default 'Tags'/'Categories'.
 569   *     @type string $singular_name              Name for one object of this taxonomy. Default 'Tag'/'Category'.
 570   *     @type string $search_items               Default 'Search Tags'/'Search Categories'.
 571   *     @type string $popular_items              This label is only used for non-hierarchical taxonomies.
 572   *                                              Default 'Popular Tags'.
 573   *     @type string $all_items                  Default 'All Tags'/'All Categories'.
 574   *     @type string $parent_item                This label is only used for hierarchical taxonomies. Default
 575   *                                              'Parent Category'.
 576   *     @type string $parent_item_colon          The same as `parent_item`, but with colon `:` in the end.
 577   *     @type string $edit_item                  Default 'Edit Tag'/'Edit Category'.
 578   *     @type string $view_item                  Default 'View Tag'/'View Category'.
 579   *     @type string $update_item                Default 'Update Tag'/'Update Category'.
 580   *     @type string $add_new_item               Default 'Add New Tag'/'Add New Category'.
 581   *     @type string $new_item_name              Default 'New Tag Name'/'New Category Name'.
 582   *     @type string $separate_items_with_commas This label is only used for non-hierarchical taxonomies. Default
 583   *                                              'Separate tags with commas', used in the meta box.
 584   *     @type string $add_or_remove_items        This label is only used for non-hierarchical taxonomies. Default
 585   *                                              'Add or remove tags', used in the meta box when JavaScript
 586   *                                              is disabled.
 587   *     @type string $choose_from_most_used      This label is only used on non-hierarchical taxonomies. Default
 588   *                                              'Choose from the most used tags', used in the meta box.
 589   *     @type string $not_found                  Default 'No tags found'/'No categories found', used in
 590   *                                              the meta box and taxonomy list table.
 591   *     @type string $no_terms                   Default 'No tags'/'No categories', used in the posts and media
 592   *                                              list tables.
 593   *     @type string $filter_by_item             This label is only used for hierarchical taxonomies. Default
 594   *                                              'Filter by category', used in the posts list table.
 595   *     @type string $items_list_navigation      Label for the table pagination hidden heading.
 596   *     @type string $items_list                 Label for the table hidden heading.
 597   *     @type string $most_used                  Title for the Most Used tab. Default 'Most Used'.
 598   *     @type string $back_to_items              Label displayed after a term has been updated.
 599   *     @type string $item_link                  Used in the block editor. Title for a navigation link block variation.
 600   *                                              Default 'Tag Link'/'Category Link'.
 601   *     @type string $item_link_description      Used in the block editor. Description for a navigation link block
 602   *                                              variation. Default 'A link to a tag'/'A link to a category'.
 603   * }
 604   */
 605  function get_taxonomy_labels( $tax ) {
 606      $tax->labels = (array) $tax->labels;
 607  
 608      if ( isset( $tax->helps ) && empty( $tax->labels['separate_items_with_commas'] ) ) {
 609          $tax->labels['separate_items_with_commas'] = $tax->helps;
 610      }
 611  
 612      if ( isset( $tax->no_tagcloud ) && empty( $tax->labels['not_found'] ) ) {
 613          $tax->labels['not_found'] = $tax->no_tagcloud;
 614      }
 615  
 616      $nohier_vs_hier_defaults = array(
 617          'name'                       => array( _x( 'Tags', 'taxonomy general name' ), _x( 'Categories', 'taxonomy general name' ) ),
 618          'singular_name'              => array( _x( 'Tag', 'taxonomy singular name' ), _x( 'Category', 'taxonomy singular name' ) ),
 619          'search_items'               => array( __( 'Search Tags' ), __( 'Search Categories' ) ),
 620          'popular_items'              => array( __( 'Popular Tags' ), null ),
 621          'all_items'                  => array( __( 'All Tags' ), __( 'All Categories' ) ),
 622          'parent_item'                => array( null, __( 'Parent Category' ) ),
 623          'parent_item_colon'          => array( null, __( 'Parent Category:' ) ),
 624          'edit_item'                  => array( __( 'Edit Tag' ), __( 'Edit Category' ) ),
 625          'view_item'                  => array( __( 'View Tag' ), __( 'View Category' ) ),
 626          'update_item'                => array( __( 'Update Tag' ), __( 'Update Category' ) ),
 627          'add_new_item'               => array( __( 'Add New Tag' ), __( 'Add New Category' ) ),
 628          'new_item_name'              => array( __( 'New Tag Name' ), __( 'New Category Name' ) ),
 629          'separate_items_with_commas' => array( __( 'Separate tags with commas' ), null ),
 630          'add_or_remove_items'        => array( __( 'Add or remove tags' ), null ),
 631          'choose_from_most_used'      => array( __( 'Choose from the most used tags' ), null ),
 632          'not_found'                  => array( __( 'No tags found.' ), __( 'No categories found.' ) ),
 633          'no_terms'                   => array( __( 'No tags' ), __( 'No categories' ) ),
 634          'filter_by_item'             => array( null, __( 'Filter by category' ) ),
 635          'items_list_navigation'      => array( __( 'Tags list navigation' ), __( 'Categories list navigation' ) ),
 636          'items_list'                 => array( __( 'Tags list' ), __( 'Categories list' ) ),
 637          /* translators: Tab heading when selecting from the most used terms. */
 638          'most_used'                  => array( _x( 'Most Used', 'tags' ), _x( 'Most Used', 'categories' ) ),
 639          'back_to_items'              => array( __( '&larr; Go to Tags' ), __( '&larr; Go to Categories' ) ),
 640          'item_link'                  => array(
 641              _x( 'Tag Link', 'navigation link block title' ),
 642              _x( 'Category Link', 'navigation link block description' ),
 643          ),
 644          'item_link_description'      => array(
 645              _x( 'A link to a tag.', 'navigation link block description' ),
 646              _x( 'A link to a category.', 'navigation link block description' ),
 647          ),
 648      );
 649  
 650      $nohier_vs_hier_defaults['menu_name'] = $nohier_vs_hier_defaults['name'];
 651  
 652      $labels = _get_custom_object_labels( $tax, $nohier_vs_hier_defaults );
 653  
 654      $taxonomy = $tax->name;
 655  
 656      $default_labels = clone $labels;
 657  
 658      /**
 659       * Filters the labels of a specific taxonomy.
 660       *
 661       * The dynamic portion of the hook name, `$taxonomy`, refers to the taxonomy slug.
 662       *
 663       * Possible hook names include:
 664       *
 665       *  - `taxonomy_labels_category`
 666       *  - `taxonomy_labels_post_tag`
 667       *
 668       * @since 4.4.0
 669       *
 670       * @see get_taxonomy_labels() for the full list of taxonomy labels.
 671       *
 672       * @param object $labels Object with labels for the taxonomy as member variables.
 673       */
 674      $labels = apply_filters( "taxonomy_labels_{$taxonomy}", $labels );
 675  
 676      // Ensure that the filtered labels contain all required default values.
 677      $labels = (object) array_merge( (array) $default_labels, (array) $labels );
 678  
 679      return $labels;
 680  }
 681  
 682  /**
 683   * Add an already registered taxonomy to an object type.
 684   *
 685   * @since 3.0.0
 686   *
 687   * @global array $wp_taxonomies The registered taxonomies.
 688   *
 689   * @param string $taxonomy    Name of taxonomy object.
 690   * @param string $object_type Name of the object type.
 691   * @return bool True if successful, false if not.
 692   */
 693  function register_taxonomy_for_object_type( $taxonomy, $object_type ) {
 694      global $wp_taxonomies;
 695  
 696      if ( ! isset( $wp_taxonomies[ $taxonomy ] ) ) {
 697          return false;
 698      }
 699  
 700      if ( ! get_post_type_object( $object_type ) ) {
 701          return false;
 702      }
 703  
 704      if ( ! in_array( $object_type, $wp_taxonomies[ $taxonomy ]->object_type, true ) ) {
 705          $wp_taxonomies[ $taxonomy ]->object_type[] = $object_type;
 706      }
 707  
 708      // Filter out empties.
 709      $wp_taxonomies[ $taxonomy ]->object_type = array_filter( $wp_taxonomies[ $taxonomy ]->object_type );
 710  
 711      /**
 712       * Fires after a taxonomy is registered for an object type.
 713       *
 714       * @since 5.1.0
 715       *
 716       * @param string $taxonomy    Taxonomy name.
 717       * @param string $object_type Name of the object type.
 718       */
 719      do_action( 'registered_taxonomy_for_object_type', $taxonomy, $object_type );
 720  
 721      return true;
 722  }
 723  
 724  /**
 725   * Remove an already registered taxonomy from an object type.
 726   *
 727   * @since 3.7.0
 728   *
 729   * @global array $wp_taxonomies The registered taxonomies.
 730   *
 731   * @param string $taxonomy    Name of taxonomy object.
 732   * @param string $object_type Name of the object type.
 733   * @return bool True if successful, false if not.
 734   */
 735  function unregister_taxonomy_for_object_type( $taxonomy, $object_type ) {
 736      global $wp_taxonomies;
 737  
 738      if ( ! isset( $wp_taxonomies[ $taxonomy ] ) ) {
 739          return false;
 740      }
 741  
 742      if ( ! get_post_type_object( $object_type ) ) {
 743          return false;
 744      }
 745  
 746      $key = array_search( $object_type, $wp_taxonomies[ $taxonomy ]->object_type, true );
 747      if ( false === $key ) {
 748          return false;
 749      }
 750  
 751      unset( $wp_taxonomies[ $taxonomy ]->object_type[ $key ] );
 752  
 753      /**
 754       * Fires after a taxonomy is unregistered for an object type.
 755       *
 756       * @since 5.1.0
 757       *
 758       * @param string $taxonomy    Taxonomy name.
 759       * @param string $object_type Name of the object type.
 760       */
 761      do_action( 'unregistered_taxonomy_for_object_type', $taxonomy, $object_type );
 762  
 763      return true;
 764  }
 765  
 766  //
 767  // Term API.
 768  //
 769  
 770  /**
 771   * Retrieve object_ids of valid taxonomy and term.
 772   *
 773   * The strings of $taxonomies must exist before this function will continue.
 774   * On failure of finding a valid taxonomy, it will return a WP_Error class,
 775   * kind of like Exceptions in PHP 5, except you can't catch them. Even so,
 776   * you can still test for the WP_Error class and get the error message.
 777   *
 778   * The $terms aren't checked the same as $taxonomies, but still need to exist
 779   * for $object_ids to be returned.
 780   *
 781   * It is possible to change the order that object_ids is returned by either
 782   * using PHP sort family functions or using the database by using $args with
 783   * either ASC or DESC array. The value should be in the key named 'order'.
 784   *
 785   * @since 2.3.0
 786   *
 787   * @global wpdb $wpdb WordPress database abstraction object.
 788   *
 789   * @param int|array    $term_ids   Term ID or array of term IDs of terms that will be used.
 790   * @param string|array $taxonomies String of taxonomy name or Array of string values of taxonomy names.
 791   * @param array|string $args       Change the order of the object_ids, either ASC or DESC.
 792   * @return array|WP_Error An array of $object_ids on success, WP_Error if the taxonomy does not exist.
 793   */
 794  function get_objects_in_term( $term_ids, $taxonomies, $args = array() ) {
 795      global $wpdb;
 796  
 797      if ( ! is_array( $term_ids ) ) {
 798          $term_ids = array( $term_ids );
 799      }
 800      if ( ! is_array( $taxonomies ) ) {
 801          $taxonomies = array( $taxonomies );
 802      }
 803      foreach ( (array) $taxonomies as $taxonomy ) {
 804          if ( ! taxonomy_exists( $taxonomy ) ) {
 805              return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
 806          }
 807      }
 808  
 809      $defaults = array( 'order' => 'ASC' );
 810      $args     = wp_parse_args( $args, $defaults );
 811  
 812      $order = ( 'desc' === strtolower( $args['order'] ) ) ? 'DESC' : 'ASC';
 813  
 814      $term_ids = array_map( 'intval', $term_ids );
 815  
 816      $taxonomies = "'" . implode( "', '", array_map( 'esc_sql', $taxonomies ) ) . "'";
 817      $term_ids   = "'" . implode( "', '", $term_ids ) . "'";
 818  
 819      $sql = "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";
 820  
 821      $last_changed = wp_cache_get_last_changed( 'terms' );
 822      $cache_key    = 'get_objects_in_term:' . md5( $sql ) . ":$last_changed";
 823      $cache        = wp_cache_get( $cache_key, 'terms' );
 824      if ( false === $cache ) {
 825          $object_ids = $wpdb->get_col( $sql );
 826          wp_cache_set( $cache_key, $object_ids, 'terms' );
 827      } else {
 828          $object_ids = (array) $cache;
 829      }
 830  
 831      if ( ! $object_ids ) {
 832          return array();
 833      }
 834      return $object_ids;
 835  }
 836  
 837  /**
 838   * Given a taxonomy query, generates SQL to be appended to a main query.
 839   *
 840   * @since 3.1.0
 841   *
 842   * @see WP_Tax_Query
 843   *
 844   * @param array  $tax_query         A compact tax query
 845   * @param string $primary_table
 846   * @param string $primary_id_column
 847   * @return array
 848   */
 849  function get_tax_sql( $tax_query, $primary_table, $primary_id_column ) {
 850      $tax_query_obj = new WP_Tax_Query( $tax_query );
 851      return $tax_query_obj->get_sql( $primary_table, $primary_id_column );
 852  }
 853  
 854  /**
 855   * Get all Term data from database by Term ID.
 856   *
 857   * The usage of the get_term function is to apply filters to a term object. It
 858   * is possible to get a term object from the database before applying the
 859   * filters.
 860   *
 861   * $term ID must be part of $taxonomy, to get from the database. Failure, might
 862   * be able to be captured by the hooks. Failure would be the same value as $wpdb
 863   * returns for the get_row method.
 864   *
 865   * There are two hooks, one is specifically for each term, named 'get_term', and
 866   * the second is for the taxonomy name, 'term_$taxonomy'. Both hooks gets the
 867   * term object, and the taxonomy name as parameters. Both hooks are expected to
 868   * return a Term object.
 869   *
 870   * {@see 'get_term'} hook - Takes two parameters the term Object and the taxonomy name.
 871   * Must return term object. Used in get_term() as a catch-all filter for every
 872   * $term.
 873   *
 874   * {@see 'get_$taxonomy'} hook - Takes two parameters the term Object and the taxonomy
 875   * name. Must return term object. $taxonomy will be the taxonomy name, so for
 876   * example, if 'category', it would be 'get_category' as the filter name. Useful
 877   * for custom taxonomies or plugging into default taxonomies.
 878   *
 879   * @todo Better formatting for DocBlock
 880   *
 881   * @since 2.3.0
 882   * @since 4.4.0 Converted to return a WP_Term object if `$output` is `OBJECT`.
 883   *              The `$taxonomy` parameter was made optional.
 884   *
 885   * @see sanitize_term_field() The $context param lists the available values for get_term_by() $filter param.
 886   *
 887   * @param int|WP_Term|object $term     If integer, term data will be fetched from the database,
 888   *                                     or from the cache if available.
 889   *                                     If stdClass object (as in the results of a database query),
 890   *                                     will apply filters and return a `WP_Term` object with the `$term` data.
 891   *                                     If `WP_Term`, will return `$term`.
 892   * @param string             $taxonomy Optional. Taxonomy name that `$term` is part of.
 893   * @param string             $output   Optional. The required return type. One of OBJECT, ARRAY_A, or ARRAY_N, which
 894   *                                     correspond to a WP_Term object, an associative array, or a numeric array,
 895   *                                     respectively. Default OBJECT.
 896   * @param string             $filter   Optional. How to sanitize term fields. Default 'raw'.
 897   * @return WP_Term|array|WP_Error|null WP_Term instance (or array) on success, depending on the `$output` value.
 898   *                                     WP_Error if `$taxonomy` does not exist. Null for miscellaneous failure.
 899   */
 900  function get_term( $term, $taxonomy = '', $output = OBJECT, $filter = 'raw' ) {
 901      if ( empty( $term ) ) {
 902          return new WP_Error( 'invalid_term', __( 'Empty Term.' ) );
 903      }
 904  
 905      if ( $taxonomy && ! taxonomy_exists( $taxonomy ) ) {
 906          return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
 907      }
 908  
 909      if ( $term instanceof WP_Term ) {
 910          $_term = $term;
 911      } elseif ( is_object( $term ) ) {
 912          if ( empty( $term->filter ) || 'raw' === $term->filter ) {
 913              $_term = sanitize_term( $term, $taxonomy, 'raw' );
 914              $_term = new WP_Term( $_term );
 915          } else {
 916              $_term = WP_Term::get_instance( $term->term_id );
 917          }
 918      } else {
 919          $_term = WP_Term::get_instance( $term, $taxonomy );
 920      }
 921  
 922      if ( is_wp_error( $_term ) ) {
 923          return $_term;
 924      } elseif ( ! $_term ) {
 925          return null;
 926      }
 927  
 928      // Ensure for filters that this is not empty.
 929      $taxonomy = $_term->taxonomy;
 930  
 931      /**
 932       * Filters a taxonomy term object.
 933       *
 934       * The {@see 'get_$taxonomy'} hook is also available for targeting a specific
 935       * taxonomy.
 936       *
 937       * @since 2.3.0
 938       * @since 4.4.0 `$_term` is now a `WP_Term` object.
 939       *
 940       * @param WP_Term $_term    Term object.
 941       * @param string  $taxonomy The taxonomy slug.
 942       */
 943      $_term = apply_filters( 'get_term', $_term, $taxonomy );
 944  
 945      /**
 946       * Filters a taxonomy term object.
 947       *
 948       * The dynamic portion of the filter name, `$taxonomy`, refers
 949       * to the slug of the term's taxonomy.
 950       *
 951       * Possible hook names include:
 952       *
 953       *  - `get_category`
 954       *  - `get_post_tag`
 955       *
 956       * @since 2.3.0
 957       * @since 4.4.0 `$_term` is now a `WP_Term` object.
 958       *
 959       * @param WP_Term $_term    Term object.
 960       * @param string  $taxonomy The taxonomy slug.
 961       */
 962      $_term = apply_filters( "get_{$taxonomy}", $_term, $taxonomy );
 963  
 964      // Bail if a filter callback has changed the type of the `$_term` object.
 965      if ( ! ( $_term instanceof WP_Term ) ) {
 966          return $_term;
 967      }
 968  
 969      // Sanitize term, according to the specified filter.
 970      $_term->filter( $filter );
 971  
 972      if ( ARRAY_A === $output ) {
 973          return $_term->to_array();
 974      } elseif ( ARRAY_N === $output ) {
 975          return array_values( $_term->to_array() );
 976      }
 977  
 978      return $_term;
 979  }
 980  
 981  /**
 982   * Get all Term data from database by Term field and data.
 983   *
 984   * Warning: $value is not escaped for 'name' $field. You must do it yourself, if
 985   * required.
 986   *
 987   * The default $field is 'id', therefore it is possible to also use null for
 988   * field, but not recommended that you do so.
 989   *
 990   * If $value does not exist, the return value will be false. If $taxonomy exists
 991   * and $field and $value combinations exist, the Term will be returned.
 992   *
 993   * This function will always return the first term that matches the `$field`-
 994   * `$value`-`$taxonomy` combination specified in the parameters. If your query
 995   * is likely to match more than one term (as is likely to be the case when
 996   * `$field` is 'name', for example), consider using get_terms() instead; that
 997   * way, you will get all matching terms, and can provide your own logic for
 998   * deciding which one was intended.
 999   *
1000   * @todo Better formatting for DocBlock.
1001   *
1002   * @since 2.3.0
1003   * @since 4.4.0 `$taxonomy` is optional if `$field` is 'term_taxonomy_id'. Converted to return
1004   *              a WP_Term object if `$output` is `OBJECT`.
1005   * @since 5.5.0 Added 'ID' as an alias of 'id' for the `$field` parameter.
1006   *
1007   * @see sanitize_term_field() The $context param lists the available values for get_term_by() $filter param.
1008   *
1009   * @param string     $field    Either 'slug', 'name', 'id' or 'ID' (term_id), or 'term_taxonomy_id'.
1010   * @param string|int $value    Search for this term value.
1011   * @param string     $taxonomy Taxonomy name. Optional, if `$field` is 'term_taxonomy_id'.
1012   * @param string     $output   Optional. The required return type. One of OBJECT, ARRAY_A, or ARRAY_N, which
1013   *                             correspond to a WP_Term object, an associative array, or a numeric array,
1014   *                             respectively. Default OBJECT.
1015   * @param string     $filter   Optional. How to sanitize term fields. Default 'raw'.
1016   * @return WP_Term|array|false WP_Term instance (or array) on success, depending on the `$output` value.
1017   *                             False if `$taxonomy` does not exist or `$term` was not found.
1018   */
1019  function get_term_by( $field, $value, $taxonomy = '', $output = OBJECT, $filter = 'raw' ) {
1020  
1021      // 'term_taxonomy_id' lookups don't require taxonomy checks.
1022      if ( 'term_taxonomy_id' !== $field && ! taxonomy_exists( $taxonomy ) ) {
1023          return false;
1024      }
1025  
1026      // No need to perform a query for empty 'slug' or 'name'.
1027      if ( 'slug' === $field || 'name' === $field ) {
1028          $value = (string) $value;
1029  
1030          if ( 0 === strlen( $value ) ) {
1031              return false;
1032          }
1033      }
1034  
1035      if ( 'id' === $field || 'ID' === $field || 'term_id' === $field ) {
1036          $term = get_term( (int) $value, $taxonomy, $output, $filter );
1037          if ( is_wp_error( $term ) || null === $term ) {
1038              $term = false;
1039          }
1040          return $term;
1041      }
1042  
1043      $args = array(
1044          'get'                    => 'all',
1045          'number'                 => 1,
1046          'taxonomy'               => $taxonomy,
1047          'update_term_meta_cache' => false,
1048          'orderby'                => 'none',
1049          'suppress_filter'        => true,
1050      );
1051  
1052      switch ( $field ) {
1053          case 'slug':
1054              $args['slug'] = $value;
1055              break;
1056          case 'name':
1057              $args['name'] = $value;
1058              break;
1059          case 'term_taxonomy_id':
1060              $args['term_taxonomy_id'] = $value;
1061              unset( $args['taxonomy'] );
1062              break;
1063          default:
1064              return false;
1065      }
1066  
1067      $terms = get_terms( $args );
1068      if ( is_wp_error( $terms ) || empty( $terms ) ) {
1069          return false;
1070      }
1071  
1072      $term = array_shift( $terms );
1073  
1074      // In the case of 'term_taxonomy_id', override the provided `$taxonomy` with whatever we find in the DB.
1075      if ( 'term_taxonomy_id' === $field ) {
1076          $taxonomy = $term->taxonomy;
1077      }
1078  
1079      return get_term( $term, $taxonomy, $output, $filter );
1080  }
1081  
1082  /**
1083   * Merge all term children into a single array of their IDs.
1084   *
1085   * This recursive function will merge all of the children of $term into the same
1086   * array of term IDs. Only useful for taxonomies which are hierarchical.
1087   *
1088   * Will return an empty array if $term does not exist in $taxonomy.
1089   *
1090   * @since 2.3.0
1091   *
1092   * @param int    $term_id  ID of Term to get children.
1093   * @param string $taxonomy Taxonomy Name.
1094   * @return array|WP_Error List of Term IDs. WP_Error returned if `$taxonomy` does not exist.
1095   */
1096  function get_term_children( $term_id, $taxonomy ) {
1097      if ( ! taxonomy_exists( $taxonomy ) ) {
1098          return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
1099      }
1100  
1101      $term_id = (int) $term_id;
1102  
1103      $terms = _get_term_hierarchy( $taxonomy );
1104  
1105      if ( ! isset( $terms[ $term_id ] ) ) {
1106          return array();
1107      }
1108  
1109      $children = $terms[ $term_id ];
1110  
1111      foreach ( (array) $terms[ $term_id ] as $child ) {
1112          if ( $term_id === $child ) {
1113              continue;
1114          }
1115  
1116          if ( isset( $terms[ $child ] ) ) {
1117              $children = array_merge( $children, get_term_children( $child, $taxonomy ) );
1118          }
1119      }
1120  
1121      return $children;
1122  }
1123  
1124  /**
1125   * Get sanitized Term field.
1126   *
1127   * The function is for contextual reasons and for simplicity of usage.
1128   *
1129   * @since 2.3.0
1130   * @since 4.4.0 The `$taxonomy` parameter was made optional. `$term` can also now accept a WP_Term object.
1131   *
1132   * @see sanitize_term_field()
1133   *
1134   * @param string      $field    Term field to fetch.
1135   * @param int|WP_Term $term     Term ID or object.
1136   * @param string      $taxonomy Optional. Taxonomy Name. Default empty.
1137   * @param string      $context  Optional. How to sanitize term fields. Look at sanitize_term_field() for available options.
1138   *                              Default 'display'.
1139   * @return string|int|null|WP_Error Will return an empty string if $term is not an object or if $field is not set in $term.
1140   */
1141  function get_term_field( $field, $term, $taxonomy = '', $context = 'display' ) {
1142      $term = get_term( $term, $taxonomy );
1143      if ( is_wp_error( $term ) ) {
1144          return $term;
1145      }
1146  
1147      if ( ! is_object( $term ) ) {
1148          return '';
1149      }
1150  
1151      if ( ! isset( $term->$field ) ) {
1152          return '';
1153      }
1154  
1155      return sanitize_term_field( $field, $term->$field, $term->term_id, $term->taxonomy, $context );
1156  }
1157  
1158  /**
1159   * Sanitizes Term for editing.
1160   *
1161   * Return value is sanitize_term() and usage is for sanitizing the term for
1162   * editing. Function is for contextual and simplicity.
1163   *
1164   * @since 2.3.0
1165   *
1166   * @param int|object $id       Term ID or object.
1167   * @param string     $taxonomy Taxonomy name.
1168   * @return string|int|null|WP_Error Will return empty string if $term is not an object.
1169   */
1170  function get_term_to_edit( $id, $taxonomy ) {
1171      $term = get_term( $id, $taxonomy );
1172  
1173      if ( is_wp_error( $term ) ) {
1174          return $term;
1175      }
1176  
1177      if ( ! is_object( $term ) ) {
1178          return '';
1179      }
1180  
1181      return sanitize_term( $term, $taxonomy, 'edit' );
1182  }
1183  
1184  /**
1185   * Retrieves the terms in a given taxonomy or list of taxonomies.
1186   *
1187   * You can fully inject any customizations to the query before it is sent, as
1188   * well as control the output with a filter.
1189   *
1190   * The return type varies depending on the value passed to `$args['fields']`. See
1191   * WP_Term_Query::get_terms() for details. In all cases, a `WP_Error` object will
1192   * be returned if an invalid taxonomy is requested.
1193   *
1194   * The {@see 'get_terms'} filter will be called when the cache has the term and will
1195   * pass the found term along with the array of $taxonomies and array of $args.
1196   * This filter is also called before the array of terms is passed and will pass
1197   * the array of terms, along with the $taxonomies and $args.
1198   *
1199   * The {@see 'list_terms_exclusions'} filter passes the compiled exclusions along with
1200   * the $args.
1201   *
1202   * The {@see 'get_terms_orderby'} filter passes the `ORDER BY` clause for the query
1203   * along with the $args array.
1204   *
1205   * Prior to 4.5.0, the first parameter of `get_terms()` was a taxonomy or list of taxonomies:
1206   *
1207   *     $terms = get_terms( 'post_tag', array(
1208   *         'hide_empty' => false,
1209   *     ) );
1210   *
1211   * Since 4.5.0, taxonomies should be passed via the 'taxonomy' argument in the `$args` array:
1212   *
1213   *     $terms = get_terms( array(
1214   *         'taxonomy' => 'post_tag',
1215   *         'hide_empty' => false,
1216   *     ) );
1217   *
1218   * @since 2.3.0
1219   * @since 4.2.0 Introduced 'name' and 'childless' parameters.
1220   * @since 4.4.0 Introduced the ability to pass 'term_id' as an alias of 'id' for the `orderby` parameter.
1221   *              Introduced the 'meta_query' and 'update_term_meta_cache' parameters. Converted to return
1222   *              a list of WP_Term objects.
1223   * @since 4.5.0 Changed the function signature so that the `$args` array can be provided as the first parameter.
1224   *              Introduced 'meta_key' and 'meta_value' parameters. Introduced the ability to order results by metadata.
1225   * @since 4.8.0 Introduced 'suppress_filter' parameter.
1226   *
1227   * @internal The `$deprecated` parameter is parsed for backward compatibility only.
1228   *
1229   * @param array|string $args       Optional. Array or string of arguments. See WP_Term_Query::__construct()
1230   *                                 for information on accepted arguments. Default empty array.
1231   * @param array|string $deprecated Optional. Argument array, when using the legacy function parameter format.
1232   *                                 If present, this parameter will be interpreted as `$args`, and the first
1233   *                                 function parameter will be parsed as a taxonomy or array of taxonomies.
1234   *                                 Default empty.
1235   * @return WP_Term[]|int[]|string[]|string|WP_Error Array of terms, a count thereof as a numeric string,
1236   *                                                  or WP_Error if any of the taxonomies do not exist.
1237   *                                                  See the function description for more information.
1238   */
1239  function get_terms( $args = array(), $deprecated = '' ) {
1240      $term_query = new WP_Term_Query();
1241  
1242      $defaults = array(
1243          'suppress_filter' => false,
1244      );
1245  
1246      /*
1247       * Legacy argument format ($taxonomy, $args) takes precedence.
1248       *
1249       * We detect legacy argument format by checking if
1250       * (a) a second non-empty parameter is passed, or
1251       * (b) the first parameter shares no keys with the default array (ie, it's a list of taxonomies)
1252       */
1253      $_args          = wp_parse_args( $args );
1254      $key_intersect  = array_intersect_key( $term_query->query_var_defaults, (array) $_args );
1255      $do_legacy_args = $deprecated || empty( $key_intersect );
1256  
1257      if ( $do_legacy_args ) {
1258          $taxonomies       = (array) $args;
1259          $args             = wp_parse_args( $deprecated, $defaults );
1260          $args['taxonomy'] = $taxonomies;
1261      } else {
1262          $args = wp_parse_args( $args, $defaults );
1263          if ( isset( $args['taxonomy'] ) && null !== $args['taxonomy'] ) {
1264              $args['taxonomy'] = (array) $args['taxonomy'];
1265          }
1266      }
1267  
1268      if ( ! empty( $args['taxonomy'] ) ) {
1269          foreach ( $args['taxonomy'] as $taxonomy ) {
1270              if ( ! taxonomy_exists( $taxonomy ) ) {
1271                  return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
1272              }
1273          }
1274      }
1275  
1276      // Don't pass suppress_filter to WP_Term_Query.
1277      $suppress_filter = $args['suppress_filter'];
1278      unset( $args['suppress_filter'] );
1279  
1280      $terms = $term_query->query( $args );
1281  
1282      // Count queries are not filtered, for legacy reasons.
1283      if ( ! is_array( $terms ) ) {
1284          return $terms;
1285      }
1286  
1287      if ( $suppress_filter ) {
1288          return $terms;
1289      }
1290  
1291      /**
1292       * Filters the found terms.
1293       *
1294       * @since 2.3.0
1295       * @since 4.6.0 Added the `$term_query` parameter.
1296       *
1297       * @param array         $terms      Array of found terms.
1298       * @param array         $taxonomies An array of taxonomies.
1299       * @param array         $args       An array of get_terms() arguments.
1300       * @param WP_Term_Query $term_query The WP_Term_Query object.
1301       */
1302      return apply_filters( 'get_terms', $terms, $term_query->query_vars['taxonomy'], $term_query->query_vars, $term_query );
1303  }
1304  
1305  /**
1306   * Adds metadata to a term.
1307   *
1308   * @since 4.4.0
1309   *
1310   * @param int    $term_id    Term ID.
1311   * @param string $meta_key   Metadata name.
1312   * @param mixed  $meta_value Metadata value. Must be serializable if non-scalar.
1313   * @param bool   $unique     Optional. Whether the same key should not be added.
1314   *                           Default false.
1315   * @return int|false|WP_Error Meta ID on success, false on failure.
1316   *                            WP_Error when term_id is ambiguous between taxonomies.
1317   */
1318  function add_term_meta( $term_id, $meta_key, $meta_value, $unique = false ) {
1319      if ( wp_term_is_shared( $term_id ) ) {
1320          return new WP_Error( 'ambiguous_term_id', __( 'Term meta cannot be added to terms that are shared between taxonomies.' ), $term_id );
1321      }
1322  
1323      return add_metadata( 'term', $term_id, $meta_key, $meta_value, $unique );
1324  }
1325  
1326  /**
1327   * Removes metadata matching criteria from a term.
1328   *
1329   * @since 4.4.0
1330   *
1331   * @param int    $term_id    Term ID.
1332   * @param string $meta_key   Metadata name.
1333   * @param mixed  $meta_value Optional. Metadata value. If provided,
1334   *                           rows will only be removed that match the value.
1335   *                           Must be serializable if non-scalar. Default empty.
1336   * @return bool True on success, false on failure.
1337   */
1338  function delete_term_meta( $term_id, $meta_key, $meta_value = '' ) {
1339      return delete_metadata( 'term', $term_id, $meta_key, $meta_value );
1340  }
1341  
1342  /**
1343   * Retrieves metadata for a term.
1344   *
1345   * @since 4.4.0
1346   *
1347   * @param int    $term_id Term ID.
1348   * @param string $key     Optional. The meta key to retrieve. By default,
1349   *                        returns data for all keys. Default empty.
1350   * @param bool   $single  Optional. Whether to return a single value.
1351   *                        This parameter has no effect if `$key` is not specified.
1352   *                        Default false.
1353   * @return mixed An array of values if `$single` is false.
1354   *               The value of the meta field if `$single` is true.
1355   *               False for an invalid `$term_id` (non-numeric, zero, or negative value).
1356   *               An empty string if a valid but non-existing term ID is passed.
1357   */
1358  function get_term_meta( $term_id, $key = '', $single = false ) {
1359      return get_metadata( 'term', $term_id, $key, $single );
1360  }
1361  
1362  /**
1363   * Updates term metadata.
1364   *
1365   * Use the `$prev_value` parameter to differentiate between meta fields with the same key and term ID.
1366   *
1367   * If the meta field for the term does not exist, it will be added.
1368   *
1369   * @since 4.4.0
1370   *
1371   * @param int    $term_id    Term ID.
1372   * @param string $meta_key   Metadata key.
1373   * @param mixed  $meta_value Metadata value. Must be serializable if non-scalar.
1374   * @param mixed  $prev_value Optional. Previous value to check before updating.
1375   *                           If specified, only update existing metadata entries with
1376   *                           this value. Otherwise, update all entries. Default empty.
1377   * @return int|bool|WP_Error Meta ID if the key didn't exist. true on successful update,
1378   *                           false on failure or if the value passed to the function
1379   *                           is the same as the one that is already in the database.
1380   *                           WP_Error when term_id is ambiguous between taxonomies.
1381   */
1382  function update_term_meta( $term_id, $meta_key, $meta_value, $prev_value = '' ) {
1383      if ( wp_term_is_shared( $term_id ) ) {
1384          return new WP_Error( 'ambiguous_term_id', __( 'Term meta cannot be added to terms that are shared between taxonomies.' ), $term_id );
1385      }
1386  
1387      return update_metadata( 'term', $term_id, $meta_key, $meta_value, $prev_value );
1388  }
1389  
1390  /**
1391   * Updates metadata cache for list of term IDs.
1392   *
1393   * Performs SQL query to retrieve all metadata for the terms matching `$term_ids` and stores them in the cache.
1394   * Subsequent calls to `get_term_meta()` will not need to query the database.
1395   *
1396   * @since 4.4.0
1397   *
1398   * @param array $term_ids List of term IDs.
1399   * @return array|false An array of metadata on success, false if there is nothing to update.
1400   */
1401  function update_termmeta_cache( $term_ids ) {
1402      return update_meta_cache( 'term', $term_ids );
1403  }
1404  
1405  /**
1406   * Get all meta data, including meta IDs, for the given term ID.
1407   *
1408   * @since 4.9.0
1409   *
1410   * @global wpdb $wpdb WordPress database abstraction object.
1411   *
1412   * @param int $term_id Term ID.
1413   * @return array|false Array with meta data, or false when the meta table is not installed.
1414   */
1415  function has_term_meta( $term_id ) {
1416      $check = wp_check_term_meta_support_prefilter( null );
1417      if ( null !== $check ) {
1418          return $check;
1419      }
1420  
1421      global $wpdb;
1422  
1423      return $wpdb->get_results( $wpdb->prepare( "SELECT meta_key, meta_value, meta_id, term_id FROM $wpdb->termmeta WHERE term_id = %d ORDER BY meta_key,meta_id", $term_id ), ARRAY_A );
1424  }
1425  
1426  /**
1427   * Registers a meta key for terms.
1428   *
1429   * @since 4.9.8
1430   *
1431   * @param string $taxonomy Taxonomy to register a meta key for. Pass an empty string
1432   *                         to register the meta key across all existing taxonomies.
1433   * @param string $meta_key The meta key to register.
1434   * @param array  $args     Data used to describe the meta key when registered. See
1435   *                         {@see register_meta()} for a list of supported arguments.
1436   * @return bool True if the meta key was successfully registered, false if not.
1437   */
1438  function register_term_meta( $taxonomy, $meta_key, array $args ) {
1439      $args['object_subtype'] = $taxonomy;
1440  
1441      return register_meta( 'term', $meta_key, $args );
1442  }
1443  
1444  /**
1445   * Unregisters a meta key for terms.
1446   *
1447   * @since 4.9.8
1448   *
1449   * @param string $taxonomy Taxonomy the meta key is currently registered for. Pass
1450   *                         an empty string if the meta key is registered across all
1451   *                         existing taxonomies.
1452   * @param string $meta_key The meta key to unregister.
1453   * @return bool True on success, false if the meta key was not previously registered.
1454   */
1455  function unregister_term_meta( $taxonomy, $meta_key ) {
1456      return unregister_meta_key( 'term', $meta_key, $taxonomy );
1457  }
1458  
1459  /**
1460   * Determines whether a taxonomy term exists.
1461   *
1462   * Formerly is_term(), introduced in 2.3.0.
1463   *
1464   * For more information on this and similar theme functions, check out
1465   * the {@link https://developer.wordpress.org/themes/basics/conditional-tags/
1466   * Conditional Tags} article in the Theme Developer Handbook.
1467   *
1468   * @since 3.0.0
1469   *
1470   * @global wpdb $wpdb WordPress database abstraction object.
1471   *
1472   * @param int|string $term     The term to check. Accepts term ID, slug, or name.
1473   * @param string     $taxonomy Optional. The taxonomy name to use.
1474   * @param int        $parent   Optional. ID of parent term under which to confine the exists search.
1475   * @return mixed Returns null if the term does not exist.
1476   *               Returns the term ID if no taxonomy is specified and the term ID exists.
1477   *               Returns an array of the term ID and the term taxonomy ID if the taxonomy is specified and the pairing exists.
1478   *               Returns 0 if term ID 0 is passed to the function.
1479   */
1480  function term_exists( $term, $taxonomy = '', $parent = null ) {
1481      global $wpdb;
1482  
1483      $select     = "SELECT term_id FROM $wpdb->terms as t WHERE ";
1484      $tax_select = "SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE ";
1485  
1486      if ( is_int( $term ) ) {
1487          if ( 0 === $term ) {
1488              return 0;
1489          }
1490          $where = 't.term_id = %d';
1491          if ( ! empty( $taxonomy ) ) {
1492              // phpcs:ignore WordPress.DB.PreparedSQLPlaceholders.ReplacementsWrongNumber
1493              return $wpdb->get_row( $wpdb->prepare( $tax_select . $where . ' AND tt.taxonomy = %s', $term, $taxonomy ), ARRAY_A );
1494          } else {
1495              return $wpdb->get_var( $wpdb->prepare( $select . $where, $term ) );
1496          }
1497      }
1498  
1499      $term = trim( wp_unslash( $term ) );
1500      $slug = sanitize_title( $term );
1501  
1502      $where             = 't.slug = %s';
1503      $else_where        = 't.name = %s';
1504      $where_fields      = array( $slug );
1505      $else_where_fields = array( $term );
1506      $orderby           = 'ORDER BY t.term_id ASC';
1507      $limit             = 'LIMIT 1';
1508      if ( ! empty( $taxonomy ) ) {
1509          if ( is_numeric( $parent ) ) {
1510              $parent              = (int) $parent;
1511              $where_fields[]      = $parent;
1512              $else_where_fields[] = $parent;
1513              $where              .= ' AND tt.parent = %d';
1514              $else_where         .= ' AND tt.parent = %d';
1515          }
1516  
1517          $where_fields[]      = $taxonomy;
1518          $else_where_fields[] = $taxonomy;
1519  
1520          $result = $wpdb->get_row( $wpdb->prepare( "SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $where AND tt.taxonomy = %s $orderby $limit", $where_fields ), ARRAY_A );
1521          if ( $result ) {
1522              return $result;
1523          }
1524  
1525          return $wpdb->get_row( $wpdb->prepare( "SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $else_where AND tt.taxonomy = %s $orderby $limit", $else_where_fields ), ARRAY_A );
1526      }
1527  
1528      // phpcs:ignore WordPress.DB.PreparedSQLPlaceholders.UnfinishedPrepare
1529      $result = $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->terms as t WHERE $where $orderby $limit", $where_fields ) );
1530      if ( $result ) {
1531          return $result;
1532      }
1533  
1534      // phpcs:ignore WordPress.DB.PreparedSQLPlaceholders.UnfinishedPrepare
1535      return $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->terms as t WHERE $else_where $orderby $limit", $else_where_fields ) );
1536  }
1537  
1538  /**
1539   * Check if a term is an ancestor of another term.
1540   *
1541   * You can use either an ID or the term object for both parameters.
1542   *
1543   * @since 3.4.0
1544   *
1545   * @param int|object $term1    ID or object to check if this is the parent term.
1546   * @param int|object $term2    The child term.
1547   * @param string     $taxonomy Taxonomy name that $term1 and `$term2` belong to.
1548   * @return bool Whether `$term2` is a child of `$term1`.
1549   */
1550  function term_is_ancestor_of( $term1, $term2, $taxonomy ) {
1551      if ( ! isset( $term1->term_id ) ) {
1552          $term1 = get_term( $term1, $taxonomy );
1553      }
1554      if ( ! isset( $term2->parent ) ) {
1555          $term2 = get_term( $term2, $taxonomy );
1556      }
1557  
1558      if ( empty( $term1->term_id ) || empty( $term2->parent ) ) {
1559          return false;
1560      }
1561      if ( $term2->parent === $term1->term_id ) {
1562          return true;
1563      }
1564  
1565      return term_is_ancestor_of( $term1, get_term( $term2->parent, $taxonomy ), $taxonomy );
1566  }
1567  
1568  /**
1569   * Sanitize all term fields.
1570   *
1571   * Relies on sanitize_term_field() to sanitize the term. The difference is that
1572   * this function will sanitize **all** fields. The context is based
1573   * on sanitize_term_field().
1574   *
1575   * The `$term` is expected to be either an array or an object.
1576   *
1577   * @since 2.3.0
1578   *
1579   * @param array|object $term     The term to check.
1580   * @param string       $taxonomy The taxonomy name to use.
1581   * @param string       $context  Optional. Context in which to sanitize the term.
1582   *                               Accepts 'raw', 'edit', 'db', 'display', 'rss',
1583   *                               'attribute', or 'js'. Default 'display'.
1584   * @return array|object Term with all fields sanitized.
1585   */
1586  function sanitize_term( $term, $taxonomy, $context = 'display' ) {
1587      $fields = array( 'term_id', 'name', 'description', 'slug', 'count', 'parent', 'term_group', 'term_taxonomy_id', 'object_id' );
1588  
1589      $do_object = is_object( $term );
1590  
1591      $term_id = $do_object ? $term->term_id : ( isset( $term['term_id'] ) ? $term['term_id'] : 0 );
1592  
1593      foreach ( (array) $fields as $field ) {
1594          if ( $do_object ) {
1595              if ( isset( $term->$field ) ) {
1596                  $term->$field = sanitize_term_field( $field, $term->$field, $term_id, $taxonomy, $context );
1597              }
1598          } else {
1599              if ( isset( $term[ $field ] ) ) {
1600                  $term[ $field ] = sanitize_term_field( $field, $term[ $field ], $term_id, $taxonomy, $context );
1601              }
1602          }
1603      }
1604  
1605      if ( $do_object ) {
1606          $term->filter = $context;
1607      } else {
1608          $term['filter'] = $context;
1609      }
1610  
1611      return $term;
1612  }
1613  
1614  /**
1615   * Cleanse the field value in the term based on the context.
1616   *
1617   * Passing a term field value through the function should be assumed to have
1618   * cleansed the value for whatever context the term field is going to be used.
1619   *
1620   * If no context or an unsupported context is given, then default filters will
1621   * be applied.
1622   *
1623   * There are enough filters for each context to support a custom filtering
1624   * without creating your own filter function. Simply create a function that
1625   * hooks into the filter you need.
1626   *
1627   * @since 2.3.0
1628   *
1629   * @param string $field    Term field to sanitize.
1630   * @param string $value    Search for this term value.
1631   * @param int    $term_id  Term ID.
1632   * @param string $taxonomy Taxonomy Name.
1633   * @param string $context  Context in which to sanitize the term field.
1634   *                         Accepts 'raw', 'edit', 'db', 'display', 'rss',
1635   *                         'attribute', or 'js'. Default 'display'.
1636   * @return mixed Sanitized field.
1637   */
1638  function sanitize_term_field( $field, $value, $term_id, $taxonomy, $context ) {
1639      $int_fields = array( 'parent', 'term_id', 'count', 'term_group', 'term_taxonomy_id', 'object_id' );
1640      if ( in_array( $field, $int_fields, true ) ) {
1641          $value = (int) $value;
1642          if ( $value < 0 ) {
1643              $value = 0;
1644          }
1645      }
1646  
1647      $context = strtolower( $context );
1648  
1649      if ( 'raw' === $context ) {
1650          return $value;
1651      }
1652  
1653      if ( 'edit' === $context ) {
1654  
1655          /**
1656           * Filters a term field to edit before it is sanitized.
1657           *
1658           * The dynamic portion of the filter name, `$field`, refers to the term field.
1659           *
1660           * @since 2.3.0
1661           *
1662           * @param mixed $value     Value of the term field.
1663           * @param int   $term_id   Term ID.
1664           * @param string $taxonomy Taxonomy slug.
1665           */
1666          $value = apply_filters( "edit_term_{$field}", $value, $term_id, $taxonomy );
1667  
1668          /**
1669           * Filters the taxonomy field to edit before it is sanitized.
1670           *
1671           * The dynamic portions of the filter name, `$taxonomy` and `$field`, refer
1672           * to the taxonomy slug and taxonomy field, respectively.
1673           *
1674           * @since 2.3.0
1675           *
1676           * @param mixed $value   Value of the taxonomy field to edit.
1677           * @param int   $term_id Term ID.
1678           */
1679          $value = apply_filters( "edit_{$taxonomy}_{$field}", $value, $term_id );
1680  
1681          if ( 'description' === $field ) {
1682              $value = esc_html( $value ); // textarea_escaped
1683          } else {
1684              $value = esc_attr( $value );
1685          }
1686      } elseif ( 'db' === $context ) {
1687  
1688          /**
1689           * Filters a term field value before it is sanitized.
1690           *
1691           * The dynamic portion of the filter name, `$field`, refers to the term field.
1692           *
1693           * @since 2.3.0
1694           *
1695           * @param mixed  $value    Value of the term field.
1696           * @param string $taxonomy Taxonomy slug.
1697           */
1698          $value = apply_filters( "pre_term_{$field}", $value, $taxonomy );
1699  
1700          /**
1701           * Filters a taxonomy field before it is sanitized.
1702           *
1703           * The dynamic portions of the filter name, `$taxonomy` and `$field`, refer
1704           * to the taxonomy slug and field name, respectively.
1705           *
1706           * @since 2.3.0
1707           *
1708           * @param mixed $value Value of the taxonomy field.
1709           */
1710          $value = apply_filters( "pre_{$taxonomy}_{$field}", $value );
1711  
1712          // Back compat filters.
1713          if ( 'slug' === $field ) {
1714              /**
1715               * Filters the category nicename before it is sanitized.
1716               *
1717               * Use the {@see 'pre_$taxonomy_$field'} hook instead.
1718               *
1719               * @since 2.0.3
1720               *
1721               * @param string $value The category nicename.
1722               */
1723              $value = apply_filters( 'pre_category_nicename', $value );
1724          }
1725      } elseif ( 'rss' === $context ) {
1726  
1727          /**
1728           * Filters the term field for use in RSS.
1729           *
1730           * The dynamic portion of the filter name, `$field`, refers to the term field.
1731           *
1732           * @since 2.3.0
1733           *
1734           * @param mixed  $value    Value of the term field.
1735           * @param string $taxonomy Taxonomy slug.
1736           */
1737          $value = apply_filters( "term_{$field}_rss", $value, $taxonomy );
1738  
1739          /**
1740           * Filters the taxonomy field for use in RSS.
1741           *
1742           * The dynamic portions of the hook name, `$taxonomy`, and `$field`, refer
1743           * to the taxonomy slug and field name, respectively.
1744           *
1745           * @since 2.3.0
1746           *
1747           * @param mixed $value Value of the taxonomy field.
1748           */
1749          $value = apply_filters( "{$taxonomy}_{$field}_rss", $value );
1750      } else {
1751          // Use display filters by default.
1752  
1753          /**
1754           * Filters the term field sanitized for display.
1755           *
1756           * The dynamic portion of the filter name, `$field`, refers to the term field name.
1757           *
1758           * @since 2.3.0
1759           *
1760           * @param mixed  $value    Value of the term field.
1761           * @param int    $term_id  Term ID.
1762           * @param string $taxonomy Taxonomy slug.
1763           * @param string $context  Context to retrieve the term field value.
1764           */
1765          $value = apply_filters( "term_{$field}", $value, $term_id, $taxonomy, $context );
1766  
1767          /**
1768           * Filters the taxonomy field sanitized for display.
1769           *
1770           * The dynamic portions of the filter name, `$taxonomy`, and `$field`, refer
1771           * to the taxonomy slug and taxonomy field, respectively.
1772           *
1773           * @since 2.3.0
1774           *
1775           * @param mixed  $value   Value of the taxonomy field.
1776           * @param int    $term_id Term ID.
1777           * @param string $context Context to retrieve the taxonomy field value.
1778           */
1779          $value = apply_filters( "{$taxonomy}_{$field}", $value, $term_id, $context );
1780      }
1781  
1782      if ( 'attribute' === $context ) {
1783          $value = esc_attr( $value );
1784      } elseif ( 'js' === $context ) {
1785          $value = esc_js( $value );
1786      }
1787  
1788      // Restore the type for integer fields after esc_attr().
1789      if ( in_array( $field, $int_fields, true ) ) {
1790          $value = (int) $value;
1791      }
1792  
1793      return $value;
1794  }
1795  
1796  /**
1797   * Count how many terms are in Taxonomy.
1798   *
1799   * Default $args is 'hide_empty' which can be 'hide_empty=true' or array('hide_empty' => true).
1800   *
1801   * @since 2.3.0
1802   * @since 5.6.0 Changed the function signature so that the `$args` array can be provided as the first parameter.
1803   *
1804   * @internal The `$deprecated` parameter is parsed for backward compatibility only.
1805   *
1806   * @param array|string $args       Optional. Array of arguments that get passed to get_terms().
1807   *                                 Default empty array.
1808   * @param array|string $deprecated Optional. Argument array, when using the legacy function parameter format.
1809   *                                 If present, this parameter will be interpreted as `$args`, and the first
1810   *                                 function parameter will be parsed as a taxonomy or array of taxonomies.
1811   *                                 Default empty.
1812   * @return string|WP_Error Numeric string containing the number of terms in that
1813   *                         taxonomy or WP_Error if the taxonomy does not exist.
1814   */
1815  function wp_count_terms( $args = array(), $deprecated = '' ) {
1816      $use_legacy_args = false;
1817  
1818      // Check whether function is used with legacy signature: `$taxonomy` and `$args`.
1819      if ( $args
1820          && ( is_string( $args ) && taxonomy_exists( $args )
1821              || is_array( $args ) && wp_is_numeric_array( $args ) )
1822      ) {
1823          $use_legacy_args = true;
1824      }
1825  
1826      $defaults = array( 'hide_empty' => false );
1827  
1828      if ( $use_legacy_args ) {
1829          $defaults['taxonomy'] = $args;
1830          $args                 = $deprecated;
1831      }
1832  
1833      $args = wp_parse_args( $args, $defaults );
1834  
1835      // Backward compatibility.
1836      if ( isset( $args['ignore_empty'] ) ) {
1837          $args['hide_empty'] = $args['ignore_empty'];
1838          unset( $args['ignore_empty'] );
1839      }
1840  
1841      $args['fields'] = 'count';
1842  
1843      return get_terms( $args );
1844  }
1845  
1846  /**
1847   * Will unlink the object from the taxonomy or taxonomies.
1848   *
1849   * Will remove all relationships between the object and any terms in
1850   * a particular taxonomy or taxonomies. Does not remove the term or
1851   * taxonomy itself.
1852   *
1853   * @since 2.3.0
1854   *
1855   * @param int          $object_id  The term Object Id that refers to the term.
1856   * @param string|array $taxonomies List of Taxonomy Names or single Taxonomy name.
1857   */
1858  function wp_delete_object_term_relationships( $object_id, $taxonomies ) {
1859      $object_id = (int) $object_id;
1860  
1861      if ( ! is_array( $taxonomies ) ) {
1862          $taxonomies = array( $taxonomies );
1863      }
1864  
1865      foreach ( (array) $taxonomies as $taxonomy ) {
1866          $term_ids = wp_get_object_terms( $object_id, $taxonomy, array( 'fields' => 'ids' ) );
1867          $term_ids = array_map( 'intval', $term_ids );
1868          wp_remove_object_terms( $object_id, $term_ids, $taxonomy );
1869      }
1870  }
1871  
1872  /**
1873   * Removes a term from the database.
1874   *
1875   * If the term is a parent of other terms, then the children will be updated to
1876   * that term's parent.
1877   *
1878   * Metadata associated with the term will be deleted.
1879   *
1880   * @since 2.3.0
1881   *
1882   * @global wpdb $wpdb WordPress database abstraction object.
1883   *
1884   * @param int          $term     Term ID.
1885   * @param string       $taxonomy Taxonomy Name.
1886   * @param array|string $args {
1887   *     Optional. Array of arguments to override the default term ID. Default empty array.
1888   *
1889   *     @type int  $default       The term ID to make the default term. This will only override
1890   *                               the terms found if there is only one term found. Any other and
1891   *                               the found terms are used.
1892   *     @type bool $force_default Optional. Whether to force the supplied term as default to be
1893   *                               assigned even if the object was not going to be term-less.
1894   *                               Default false.
1895   * }
1896   * @return bool|int|WP_Error True on success, false if term does not exist. Zero on attempted
1897   *                           deletion of default Category. WP_Error if the taxonomy does not exist.
1898   */
1899  function wp_delete_term( $term, $taxonomy, $args = array() ) {
1900      global $wpdb;
1901  
1902      $term = (int) $term;
1903  
1904      $ids = term_exists( $term, $taxonomy );
1905      if ( ! $ids ) {
1906          return false;
1907      }
1908      if ( is_wp_error( $ids ) ) {
1909          return $ids;
1910      }
1911  
1912      $tt_id = $ids['term_taxonomy_id'];
1913  
1914      $defaults = array();
1915  
1916      if ( 'category' === $taxonomy ) {
1917          $defaults['default'] = (int) get_option( 'default_category' );
1918          if ( $defaults['default'] === $term ) {
1919              return 0; // Don't delete the default category.
1920          }
1921      }
1922  
1923      // Don't delete the default custom taxonomy term.
1924      $taxonomy_object = get_taxonomy( $taxonomy );
1925      if ( ! empty( $taxonomy_object->default_term ) ) {
1926          $defaults['default'] = (int) get_option( 'default_term_' . $taxonomy );
1927          if ( $defaults['default'] === $term ) {
1928              return 0;
1929          }
1930      }
1931  
1932      $args = wp_parse_args( $args, $defaults );
1933  
1934      if ( isset( $args['default'] ) ) {
1935          $default = (int) $args['default'];
1936          if ( ! term_exists( $default, $taxonomy ) ) {
1937              unset( $default );
1938          }
1939      }
1940  
1941      if ( isset( $args['force_default'] ) ) {
1942          $force_default = $args['force_default'];
1943      }
1944  
1945      /**
1946       * Fires when deleting a term, before any modifications are made to posts or terms.
1947       *
1948       * @since 4.1.0
1949       *
1950       * @param int    $term     Term ID.
1951       * @param string $taxonomy Taxonomy Name.
1952       */
1953      do_action( 'pre_delete_term', $term, $taxonomy );
1954  
1955      // Update children to point to new parent.
1956      if ( is_taxonomy_hierarchical( $taxonomy ) ) {
1957          $term_obj = get_term( $term, $taxonomy );
1958          if ( is_wp_error( $term_obj ) ) {
1959              return $term_obj;
1960          }
1961          $parent = $term_obj->parent;
1962  
1963          $edit_ids    = $wpdb->get_results( "SELECT term_id, term_taxonomy_id FROM $wpdb->term_taxonomy WHERE `parent` = " . (int) $term_obj->term_id );
1964          $edit_tt_ids = wp_list_pluck( $edit_ids, 'term_taxonomy_id' );
1965  
1966          /**
1967           * Fires immediately before a term to delete's children are reassigned a parent.
1968           *
1969           * @since 2.9.0
1970           *
1971           * @param array $edit_tt_ids An array of term taxonomy IDs for the given term.
1972           */
1973          do_action( 'edit_term_taxonomies', $edit_tt_ids );
1974  
1975          $wpdb->update( $wpdb->term_taxonomy, compact( 'parent' ), array( 'parent' => $term_obj->term_id ) + compact( 'taxonomy' ) );
1976  
1977          // Clean the cache for all child terms.
1978          $edit_term_ids = wp_list_pluck( $edit_ids, 'term_id' );
1979          clean_term_cache( $edit_term_ids, $taxonomy );
1980  
1981          /**
1982           * Fires immediately after a term to delete's children are reassigned a parent.
1983           *
1984           * @since 2.9.0
1985           *
1986           * @param array $edit_tt_ids An array of term taxonomy IDs for the given term.
1987           */
1988          do_action( 'edited_term_taxonomies', $edit_tt_ids );
1989      }
1990  
1991      // Get the term before deleting it or its term relationships so we can pass to actions below.
1992      $deleted_term = get_term( $term, $taxonomy );
1993  
1994      $object_ids = (array) $wpdb->get_col( $wpdb->prepare( "SELECT object_id FROM $wpdb->term_relationships WHERE term_taxonomy_id = %d", $tt_id ) );
1995  
1996      foreach ( $object_ids as $object_id ) {
1997          if ( ! isset( $default ) ) {
1998              wp_remove_object_terms( $object_id, $term, $taxonomy );
1999              continue;
2000          }
2001  
2002          $terms = wp_get_object_terms(
2003              $object_id,
2004              $taxonomy,
2005              array(
2006                  'fields'  => 'ids',
2007                  'orderby' => 'none',
2008              )
2009          );
2010  
2011          if ( 1 === count( $terms ) && isset( $default ) ) {
2012              $terms = array( $default );
2013          } else {
2014              $terms = array_diff( $terms, array( $term ) );
2015              if ( isset( $default ) && isset( $force_default ) && $force_default ) {
2016                  $terms = array_merge( $terms, array( $default ) );
2017              }
2018          }
2019  
2020          $terms = array_map( 'intval', $terms );
2021          wp_set_object_terms( $object_id, $terms, $taxonomy );
2022      }
2023  
2024      // Clean the relationship caches for all object types using this term.
2025      $tax_object = get_taxonomy( $taxonomy );
2026      foreach ( $tax_object->object_type as $object_type ) {
2027          clean_object_term_cache( $object_ids, $object_type );
2028      }
2029  
2030      $term_meta_ids = $wpdb->get_col( $wpdb->prepare( "SELECT meta_id FROM $wpdb->termmeta WHERE term_id = %d ", $term ) );
2031      foreach ( $term_meta_ids as $mid ) {
2032          delete_metadata_by_mid( 'term', $mid );
2033      }
2034  
2035      /**
2036       * Fires immediately before a term taxonomy ID is deleted.
2037       *
2038       * @since 2.9.0
2039       *
2040       * @param int $tt_id Term taxonomy ID.
2041       */
2042      do_action( 'delete_term_taxonomy', $tt_id );
2043  
2044      $wpdb->delete( $wpdb->term_taxonomy, array( 'term_taxonomy_id' => $tt_id ) );
2045  
2046      /**
2047       * Fires immediately after a term taxonomy ID is deleted.
2048       *
2049       * @since 2.9.0
2050       *
2051       * @param int $tt_id Term taxonomy ID.
2052       */
2053      do_action( 'deleted_term_taxonomy', $tt_id );
2054  
2055      // Delete the term if no taxonomies use it.
2056      if ( ! $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_taxonomy WHERE term_id = %d", $term ) ) ) {
2057          $wpdb->delete( $wpdb->terms, array( 'term_id' => $term ) );
2058      }
2059  
2060      clean_term_cache( $term, $taxonomy );
2061  
2062      /**
2063       * Fires after a term is deleted from the database and the cache is cleaned.
2064       *
2065       * The {@see 'delete_$taxonomy'} hook is also available for targeting a specific
2066       * taxonomy.
2067       *
2068       * @since 2.5.0
2069       * @since 4.5.0 Introduced the `$object_ids` argument.
2070       *
2071       * @param int     $term         Term ID.
2072       * @param int     $tt_id        Term taxonomy ID.
2073       * @param string  $taxonomy     Taxonomy slug.
2074       * @param WP_Term $deleted_term Copy of the already-deleted term.
2075       * @param array   $object_ids   List of term object IDs.
2076       */
2077      do_action( 'delete_term', $term, $tt_id, $taxonomy, $deleted_term, $object_ids );
2078  
2079      /**
2080       * Fires after a term in a specific taxonomy is deleted.
2081       *
2082       * The dynamic portion of the hook name, `$taxonomy`, refers to the specific
2083       * taxonomy the term belonged to.
2084       *
2085       * Possible hook names include:
2086       *
2087       *  - `delete_category`
2088       *  - `delete_post_tag`
2089       *
2090       * @since 2.3.0
2091       * @since 4.5.0 Introduced the `$object_ids` argument.
2092       *
2093       * @param int     $term         Term ID.
2094       * @param int     $tt_id        Term taxonomy ID.
2095       * @param WP_Term $deleted_term Copy of the already-deleted term.
2096       * @param array   $object_ids   List of term object IDs.
2097       */
2098      do_action( "delete_{$taxonomy}", $term, $tt_id, $deleted_term, $object_ids );
2099  
2100      return true;
2101  }
2102  
2103  /**
2104   * Deletes one existing category.
2105   *
2106   * @since 2.0.0
2107   *
2108   * @param int $cat_ID Category term ID.
2109   * @return bool|int|WP_Error Returns true if completes delete action; false if term doesn't exist;
2110   *  Zero on attempted deletion of default Category; WP_Error object is also a possibility.
2111   */
2112  function wp_delete_category( $cat_ID ) {
2113      return wp_delete_term( $cat_ID, 'category' );
2114  }
2115  
2116  /**
2117   * Retrieves the terms associated with the given object(s), in the supplied taxonomies.
2118   *
2119   * @since 2.3.0
2120   * @since 4.2.0 Added support for 'taxonomy', 'parent', and 'term_taxonomy_id' values of `$orderby`.
2121   *              Introduced `$parent` argument.
2122   * @since 4.4.0 Introduced `$meta_query` and `$update_term_meta_cache` arguments. When `$fields` is 'all' or
2123   *              'all_with_object_id', an array of `WP_Term` objects will be returned.
2124   * @since 4.7.0 Refactored to use WP_Term_Query, and to support any WP_Term_Query arguments.
2125   *
2126   * @param int|int[]       $object_ids The ID(s) of the object(s) to retrieve.
2127   * @param string|string[] $taxonomies The taxonomy names to retrieve terms from.
2128   * @param array|string    $args       See WP_Term_Query::__construct() for supported arguments.
2129   * @return WP_Term[]|WP_Error Array of terms or empty array if no terms found.
2130   *                            WP_Error if any of the taxonomies don't exist.
2131   */
2132  function wp_get_object_terms( $object_ids, $taxonomies, $args = array() ) {
2133      if ( empty( $object_ids ) || empty( $taxonomies ) ) {
2134          return array();
2135      }
2136  
2137      if ( ! is_array( $taxonomies ) ) {
2138          $taxonomies = array( $taxonomies );
2139      }
2140  
2141      foreach ( $taxonomies as $taxonomy ) {
2142          if ( ! taxonomy_exists( $taxonomy ) ) {
2143              return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
2144          }
2145      }
2146  
2147      if ( ! is_array( $object_ids ) ) {
2148          $object_ids = array( $object_ids );
2149      }
2150      $object_ids = array_map( 'intval', $object_ids );
2151  
2152      $args = wp_parse_args( $args );
2153  
2154      /**
2155       * Filters arguments for retrieving object terms.
2156       *
2157       * @since 4.9.0
2158       *
2159       * @param array    $args       An array of arguments for retrieving terms for the given object(s).
2160       *                             See {@see wp_get_object_terms()} for details.
2161       * @param int[]    $object_ids Array of object IDs.
2162       * @param string[] $taxonomies Array of taxonomy names to retrieve terms from.
2163       */
2164      $args = apply_filters( 'wp_get_object_terms_args', $args, $object_ids, $taxonomies );
2165  
2166      /*
2167       * When one or more queried taxonomies is registered with an 'args' array,
2168       * those params override the `$args` passed to this function.
2169       */
2170      $terms = array();
2171      if ( count( $taxonomies ) > 1 ) {
2172          foreach ( $taxonomies as $index => $taxonomy ) {
2173              $t = get_taxonomy( $taxonomy );
2174              if ( isset( $t->args ) && is_array( $t->args ) && array_merge( $args, $t->args ) != $args ) {
2175                  unset( $taxonomies[ $index ] );
2176                  $terms = array_merge( $terms, wp_get_object_terms( $object_ids, $taxonomy, array_merge( $args, $t->args ) ) );
2177              }
2178          }
2179      } else {
2180          $t = get_taxonomy( $taxonomies[0] );
2181          if ( isset( $t->args ) && is_array( $t->args ) ) {
2182              $args = array_merge( $args, $t->args );
2183          }
2184      }
2185  
2186      $args['taxonomy']   = $taxonomies;
2187      $args['object_ids'] = $object_ids;
2188  
2189      // Taxonomies registered without an 'args' param are handled here.
2190      if ( ! empty( $taxonomies ) ) {
2191          $terms_from_remaining_taxonomies = get_terms( $args );
2192  
2193          // Array keys should be preserved for values of $fields that use term_id for keys.
2194          if ( ! empty( $args['fields'] ) && 0 === strpos( $args['fields'], 'id=>' ) ) {
2195              $terms = $terms + $terms_from_remaining_taxonomies;
2196          } else {
2197              $terms = array_merge( $terms, $terms_from_remaining_taxonomies );
2198          }
2199      }
2200  
2201      /**
2202       * Filters the terms for a given object or objects.
2203       *
2204       * @since 4.2.0
2205       *
2206       * @param WP_Term[] $terms      Array of terms for the given object or objects.
2207       * @param int[]     $object_ids Array of object IDs for which terms were retrieved.
2208       * @param string[]  $taxonomies Array of taxonomy names from which terms were retrieved.
2209       * @param array     $args       Array of arguments for retrieving terms for the given
2210       *                              object(s). See wp_get_object_terms() for details.
2211       */
2212      $terms = apply_filters( 'get_object_terms', $terms, $object_ids, $taxonomies, $args );
2213  
2214      $object_ids = implode( ',', $object_ids );
2215      $taxonomies = "'" . implode( "', '", array_map( 'esc_sql', $taxonomies ) ) . "'";
2216  
2217      /**
2218       * Filters the terms for a given object or objects.
2219       *
2220       * The `$taxonomies` parameter passed to this filter is formatted as a SQL fragment. The
2221       * {@see 'get_object_terms'} filter is recommended as an alternative.
2222       *
2223       * @since 2.8.0
2224       *
2225       * @param WP_Term[] $terms      Array of terms for the given object or objects.
2226       * @param string    $object_ids Comma separated list of object IDs for which terms were retrieved.
2227       * @param string    $taxonomies SQL fragment of taxonomy names from which terms were retrieved.
2228       * @param array     $args       Array of arguments for retrieving terms for the given
2229       *                              object(s). See wp_get_object_terms() for details.
2230       */
2231      return apply_filters( 'wp_get_object_terms', $terms, $object_ids, $taxonomies, $args );
2232  }
2233  
2234  /**
2235   * Add a new term to the database.
2236   *
2237   * A non-existent term is inserted in the following sequence:
2238   * 1. The term is added to the term table, then related to the taxonomy.
2239   * 2. If everything is correct, several actions are fired.
2240   * 3. The 'term_id_filter' is evaluated.
2241   * 4. The term cache is cleaned.
2242   * 5. Several more actions are fired.
2243   * 6. An array is returned containing the `term_id` and `term_taxonomy_id`.
2244   *
2245   * If the 'slug' argument is not empty, then it is checked to see if the term
2246   * is invalid. If it is not a valid, existing term, it is added and the term_id
2247   * is given.
2248   *
2249   * If the taxonomy is hierarchical, and the 'parent' argument is not empty,
2250   * the term is inserted and the term_id will be given.
2251   *
2252   * Error handling:
2253   * If `$taxonomy` does not exist or `$term` is empty,
2254   * a WP_Error object will be returned.
2255   *
2256   * If the term already exists on the same hierarchical level,
2257   * or the term slug and name are not unique, a WP_Error object will be returned.
2258   *
2259   * @global wpdb $wpdb WordPress database abstraction object.
2260   *
2261   * @since 2.3.0
2262   *
2263   * @param string       $term     The term name to add.
2264   * @param string       $taxonomy The taxonomy to which to add the term.
2265   * @param array|string $args {
2266   *     Optional. Array or query string of arguments for inserting a term.
2267   *
2268   *     @type string $alias_of    Slug of the term to make this term an alias of.
2269   *                               Default empty string. Accepts a term slug.
2270   *     @type string $description The term description. Default empty string.
2271   *     @type int    $parent      The id of the parent term. Default 0.
2272   *     @type string $slug        The term slug to use. Default empty string.
2273   * }
2274   * @return array|WP_Error {
2275   *     An array of the new term data, WP_Error otherwise.
2276   *
2277   *     @type int        $term_id          The new term ID.
2278   *     @type int|string $term_taxonomy_id The new term taxonomy ID. Can be a numeric string.
2279   * }
2280   */
2281  function wp_insert_term( $term, $taxonomy, $args = array() ) {
2282      global $wpdb;
2283  
2284      if ( ! taxonomy_exists( $taxonomy ) ) {
2285          return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
2286      }
2287  
2288      /**
2289       * Filters a term before it is sanitized and inserted into the database.
2290       *
2291       * @since 3.0.0
2292       *
2293       * @param string|WP_Error $term     The term name to add, or a WP_Error object if there's an error.
2294       * @param string          $taxonomy Taxonomy slug.
2295       */
2296      $term = apply_filters( 'pre_insert_term', $term, $taxonomy );
2297  
2298      if ( is_wp_error( $term ) ) {
2299          return $term;
2300      }
2301  
2302      if ( is_int( $term ) && 0 === $term ) {
2303          return new WP_Error( 'invalid_term_id', __( 'Invalid term ID.' ) );
2304      }
2305  
2306      if ( '' === trim( $term ) ) {
2307          return new WP_Error( 'empty_term_name', __( 'A name is required for this term.' ) );
2308      }
2309  
2310      $defaults = array(
2311          'alias_of'    => '',
2312          'description' => '',
2313          'parent'      => 0,
2314          'slug'        => '',
2315      );
2316      $args     = wp_parse_args( $args, $defaults );
2317  
2318      if ( (int) $args['parent'] > 0 && ! term_exists( (int) $args['parent'] ) ) {
2319          return new WP_Error( 'missing_parent', __( 'Parent term does not exist.' ) );
2320      }
2321  
2322      $args['name']     = $term;
2323      $args['taxonomy'] = $taxonomy;
2324  
2325      // Coerce null description to strings, to avoid database errors.
2326      $args['description'] = (string) $args['description'];
2327  
2328      $args = sanitize_term( $args, $taxonomy, 'db' );
2329  
2330      // expected_slashed ($name)
2331      $name        = wp_unslash( $args['name'] );
2332      $description = wp_unslash( $args['description'] );
2333      $parent      = (int) $args['parent'];
2334  
2335      $slug_provided = ! empty( $args['slug'] );
2336      if ( ! $slug_provided ) {
2337          $slug = sanitize_title( $name );
2338      } else {
2339          $slug = $args['slug'];
2340      }
2341  
2342      $term_group = 0;
2343      if ( $args['alias_of'] ) {
2344          $alias = get_term_by( 'slug', $args['alias_of'], $taxonomy );
2345          if ( ! empty( $alias->term_group ) ) {
2346              // The alias we want is already in a group, so let's use that one.
2347              $term_group = $alias->term_group;
2348          } elseif ( ! empty( $alias->term_id ) ) {
2349              /*
2350               * The alias is not in a group, so we create a new one
2351               * and add the alias to it.
2352               */
2353              $term_group = $wpdb->get_var( "SELECT MAX(term_group) FROM $wpdb->terms" ) + 1;
2354  
2355              wp_update_term(
2356                  $alias->term_id,
2357                  $taxonomy,
2358                  array(
2359                      'term_group' => $term_group,
2360                  )
2361              );
2362          }
2363      }
2364  
2365      /*
2366       * Prevent the creation of terms with duplicate names at the same level of a taxonomy hierarchy,
2367       * unless a unique slug has been explicitly provided.
2368       */
2369      $name_matches = get_terms(
2370          array(
2371              'taxonomy'               => $taxonomy,
2372              'name'                   => $name,
2373              'hide_empty'             => false,
2374              'parent'                 => $args['parent'],
2375              'update_term_meta_cache' => false,
2376          )
2377      );
2378  
2379      /*
2380       * The `name` match in `get_terms()` doesn't differentiate accented characters,
2381       * so we do a stricter comparison here.
2382       */
2383      $name_match = null;
2384      if ( $name_matches ) {
2385          foreach ( $name_matches as $_match ) {
2386              if ( strtolower( $name ) === strtolower( $_match->name ) ) {
2387                  $name_match = $_match;
2388                  break;
2389              }
2390          }
2391      }
2392  
2393      if ( $name_match ) {
2394          $slug_match = get_term_by( 'slug', $slug, $taxonomy );
2395          if ( ! $slug_provided || $name_match->slug === $slug || $slug_match ) {
2396              if ( is_taxonomy_hierarchical( $taxonomy ) ) {
2397                  $siblings = get_terms(
2398                      array(
2399                          'taxonomy'               => $taxonomy,
2400                          'get'                    => 'all',
2401                          'parent'                 => $parent,
2402                          'update_term_meta_cache' => false,
2403                      )
2404                  );
2405  
2406                  $existing_term = null;
2407                  $sibling_names = wp_list_pluck( $siblings, 'name' );
2408                  $sibling_slugs = wp_list_pluck( $siblings, 'slug' );
2409  
2410                  if ( ( ! $slug_provided || $name_match->slug === $slug ) && in_array( $name, $sibling_names, true ) ) {
2411                      $existing_term = $name_match;
2412                  } elseif ( $slug_match && in_array( $slug, $sibling_slugs, true ) ) {
2413                      $existing_term = $slug_match;
2414                  }
2415  
2416                  if ( $existing_term ) {
2417                      return new WP_Error( 'term_exists', __( 'A term with the name provided already exists with this parent.' ), $existing_term->term_id );
2418                  }
2419              } else {
2420                  return new WP_Error( 'term_exists', __( 'A term with the name provided already exists in this taxonomy.' ), $name_match->term_id );
2421              }
2422          }
2423      }
2424  
2425      $slug = wp_unique_term_slug( $slug, (object) $args );
2426  
2427      $data = compact( 'name', 'slug', 'term_group' );
2428  
2429      /**
2430       * Filters term data before it is inserted into the database.
2431       *
2432       * @since 4.7.0
2433       *
2434       * @param array  $data     Term data to be inserted.
2435       * @param string $taxonomy Taxonomy slug.
2436       * @param array  $args     Arguments passed to wp_insert_term().
2437       */
2438      $data = apply_filters( 'wp_insert_term_data', $data, $taxonomy, $args );
2439  
2440      if ( false === $wpdb->insert( $wpdb->terms, $data ) ) {
2441          return new WP_Error( 'db_insert_error', __( 'Could not insert term into the database.' ), $wpdb->last_error );
2442      }
2443  
2444      $term_id = (int) $wpdb->insert_id;
2445  
2446      // Seems unreachable. However, is used in the case that a term name is provided, which sanitizes to an empty string.
2447      if ( empty( $slug ) ) {
2448          $slug = sanitize_title( $slug, $term_id );
2449  
2450          /** This action is documented in wp-includes/taxonomy.php */
2451          do_action( 'edit_terms', $term_id, $taxonomy );
2452          $wpdb->update( $wpdb->terms, compact( 'slug' ), compact( 'term_id' ) );
2453  
2454          /** This action is documented in wp-includes/taxonomy.php */
2455          do_action( 'edited_terms', $term_id, $taxonomy );
2456      }
2457  
2458      $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 ) );
2459  
2460      if ( ! empty( $tt_id ) ) {
2461          return array(
2462              'term_id'          => $term_id,
2463              'term_taxonomy_id' => $tt_id,
2464          );
2465      }
2466  
2467      if ( false === $wpdb->insert( $wpdb->term_taxonomy, compact( 'term_id', 'taxonomy', 'description', 'parent' ) + array( 'count' => 0 ) ) ) {
2468          return new WP_Error( 'db_insert_error', __( 'Could not insert term taxonomy into the database.' ), $wpdb->last_error );
2469      }
2470  
2471      $tt_id = (int) $wpdb->insert_id;
2472  
2473      /*
2474       * Sanity check: if we just created a term with the same parent + taxonomy + slug but a higher term_id than
2475       * an existing term, then we have unwittingly created a duplicate term. Delete the dupe, and use the term_id
2476       * and term_taxonomy_id of the older term instead. Then return out of the function so that the "create" hooks
2477       * are not fired.
2478       */
2479      $duplicate_term = $wpdb->get_row( $wpdb->prepare( "SELECT t.term_id, t.slug, tt.term_taxonomy_id, tt.taxonomy FROM $wpdb->terms t INNER JOIN $wpdb->term_taxonomy tt ON ( tt.term_id = t.term_id ) WHERE t.slug = %s AND tt.parent = %d AND tt.taxonomy = %s AND t.term_id < %d AND tt.term_taxonomy_id != %d", $slug, $parent, $taxonomy, $term_id, $tt_id ) );
2480  
2481      /**
2482       * Filters the duplicate term check that takes place during term creation.
2483       *
2484       * Term parent+taxonomy+slug combinations are meant to be unique, and wp_insert_term()
2485       * performs a last-minute confirmation of this uniqueness before allowing a new term
2486       * to be created. Plugins with different uniqueness requirements may use this filter
2487       * to bypass or modify the duplicate-term check.
2488       *
2489       * @since 5.1.0
2490       *
2491       * @param object $duplicate_term Duplicate term row from terms table, if found.
2492       * @param string $term           Term being inserted.
2493       * @param string $taxonomy       Taxonomy name.
2494       * @param array  $args           Term arguments passed to the function.
2495       * @param int    $tt_id          term_taxonomy_id for the newly created term.
2496       */
2497      $duplicate_term = apply_filters( 'wp_insert_term_duplicate_term_check', $duplicate_term, $term, $taxonomy, $args, $tt_id );
2498  
2499      if ( $duplicate_term ) {
2500          $wpdb->delete( $wpdb->terms, array( 'term_id' => $term_id ) );
2501          $wpdb->delete( $wpdb->term_taxonomy, array( 'term_taxonomy_id' => $tt_id ) );
2502  
2503          $term_id = (int) $duplicate_term->term_id;
2504          $tt_id   = (int) $duplicate_term->term_taxonomy_id;
2505  
2506          clean_term_cache( $term_id, $taxonomy );
2507          return array(
2508              'term_id'          => $term_id,
2509              'term_taxonomy_id' => $tt_id,
2510          );
2511      }
2512  
2513      /**
2514       * Fires immediately after a new term is created, before the term cache is cleaned.
2515       *
2516       * The {@see 'create_$taxonomy'} hook is also available for targeting a specific
2517       * taxonomy.
2518       *
2519       * @since 2.3.0
2520       *
2521       * @param int    $term_id  Term ID.
2522       * @param int    $tt_id    Term taxonomy ID.
2523       * @param string $taxonomy Taxonomy slug.
2524       */
2525      do_action( 'create_term', $term_id, $tt_id, $taxonomy );
2526  
2527      /**
2528       * Fires after a new term is created for a specific taxonomy.
2529       *
2530       * The dynamic portion of the hook name, `$taxonomy`, refers
2531       * to the slug of the taxonomy the term was created for.
2532       *
2533       * Possible hook names include:
2534       *
2535       *  - `create_category`
2536       *  - `create_post_tag`
2537       *
2538       * @since 2.3.0
2539       *
2540       * @param int $term_id Term ID.
2541       * @param int $tt_id   Term taxonomy ID.
2542       */
2543      do_action( "create_{$taxonomy}", $term_id, $tt_id );
2544  
2545      /**
2546       * Filters the term ID after a new term is created.
2547       *
2548       * @since 2.3.0
2549       *
2550       * @param int $term_id Term ID.
2551       * @param int $tt_id   Term taxonomy ID.
2552       */
2553      $term_id = apply_filters( 'term_id_filter', $term_id, $tt_id );
2554  
2555      clean_term_cache( $term_id, $taxonomy );
2556  
2557      /**
2558       * Fires after a new term is created, and after the term cache has been cleaned.
2559       *
2560       * The {@see 'created_$taxonomy'} hook is also available for targeting a specific
2561       * taxonomy.
2562       *
2563       * @since 2.3.0
2564       *
2565       * @param int    $term_id  Term ID.
2566       * @param int    $tt_id    Term taxonomy ID.
2567       * @param string $taxonomy Taxonomy slug.
2568       */
2569      do_action( 'created_term', $term_id, $tt_id, $taxonomy );
2570  
2571      /**
2572       * Fires after a new term in a specific taxonomy is created, and after the term
2573       * cache has been cleaned.
2574       *
2575       * The dynamic portion of the hook name, `$taxonomy`, refers to the taxonomy slug.
2576       *
2577       * Possible hook names include:
2578       *
2579       *  - `created_category`
2580       *  - `created_post_tag`
2581       *
2582       * @since 2.3.0
2583       *
2584       * @param int $term_id Term ID.
2585       * @param int $tt_id   Term taxonomy ID.
2586       */
2587      do_action( "created_{$taxonomy}", $term_id, $tt_id );
2588  
2589      /**
2590       * Fires after a term has been saved, and the term cache has been cleared.
2591       *
2592       * The {@see 'saved_$taxonomy'} hook is also available for targeting a specific
2593       * taxonomy.
2594       *
2595       * @since 5.5.0
2596       *
2597       * @param int    $term_id  Term ID.
2598       * @param int    $tt_id    Term taxonomy ID.
2599       * @param string $taxonomy Taxonomy slug.
2600       * @param bool   $update   Whether this is an existing term being updated.
2601       */
2602      do_action( 'saved_term', $term_id, $tt_id, $taxonomy, false );
2603  
2604      /**
2605       * Fires after a term in a specific taxonomy has been saved, and the term
2606       * cache has been cleared.
2607       *
2608       * The dynamic portion of the hook name, `$taxonomy`, refers to the taxonomy slug.
2609       *
2610       * Possible hook names include:
2611       *
2612       *  - `saved_category`
2613       *  - `saved_post_tag`
2614       *
2615       * @since 5.5.0
2616       *
2617       * @param int  $term_id Term ID.
2618       * @param int  $tt_id   Term taxonomy ID.
2619       * @param bool $update  Whether this is an existing term being updated.
2620       */
2621      do_action( "saved_{$taxonomy}", $term_id, $tt_id, false );
2622  
2623      return array(
2624          'term_id'          => $term_id,
2625          'term_taxonomy_id' => $tt_id,
2626      );
2627  }
2628  
2629  /**
2630   * Create Term and Taxonomy Relationships.
2631   *
2632   * Relates an object (post, link etc) to a term and taxonomy type. Creates the
2633   * term and taxonomy relationship if it doesn't already exist. Creates a term if
2634   * it doesn't exist (using the slug).
2635   *
2636   * A relationship means that the term is grouped in or belongs to the taxonomy.
2637   * A term has no meaning until it is given context by defining which taxonomy it
2638   * exists under.
2639   *
2640   * @since 2.3.0
2641   *
2642   * @global wpdb $wpdb WordPress database abstraction object.
2643   *
2644   * @param int              $object_id The object to relate to.
2645   * @param string|int|array $terms     A single term slug, single term ID, or array of either term slugs or IDs.
2646   *                                    Will replace all existing related terms in this taxonomy. Passing an
2647   *                                    empty value will remove all related terms.
2648   * @param string           $taxonomy  The context in which to relate the term to the object.
2649   * @param bool             $append    Optional. If false will delete difference of terms. Default false.
2650   * @return array|WP_Error Term taxonomy IDs of the affected terms or WP_Error on failure.
2651   */
2652  function wp_set_object_terms( $object_id, $terms, $taxonomy, $append = false ) {
2653      global $wpdb;
2654  
2655      $object_id = (int) $object_id;
2656  
2657      if ( ! taxonomy_exists( $taxonomy ) ) {
2658          return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
2659      }
2660  
2661      if ( ! is_array( $terms ) ) {
2662          $terms = array( $terms );
2663      }
2664  
2665      if ( ! $append ) {
2666          $old_tt_ids = wp_get_object_terms(
2667              $object_id,
2668              $taxonomy,
2669              array(
2670                  'fields'                 => 'tt_ids',
2671                  'orderby'                => 'none',
2672                  'update_term_meta_cache' => false,
2673              )
2674          );
2675      } else {
2676          $old_tt_ids = array();
2677      }
2678  
2679      $tt_ids     = array();
2680      $term_ids   = array();
2681      $new_tt_ids = array();
2682  
2683      foreach ( (array) $terms as $term ) {
2684          if ( '' === trim( $term ) ) {
2685              continue;
2686          }
2687  
2688          $term_info = term_exists( $term, $taxonomy );
2689  
2690          if ( ! $term_info ) {
2691              // Skip if a non-existent term ID is passed.
2692              if ( is_int( $term ) ) {
2693                  continue;
2694              }
2695  
2696              $term_info = wp_insert_term( $term, $taxonomy );
2697          }
2698  
2699          if ( is_wp_error( $term_info ) ) {
2700              return $term_info;
2701          }
2702  
2703          $term_ids[] = $term_info['term_id'];
2704          $tt_id      = $term_info['term_taxonomy_id'];
2705          $tt_ids[]   = $tt_id;
2706  
2707          if ( $wpdb->get_var( $wpdb->prepare( "SELECT term_taxonomy_id FROM $wpdb->term_relationships WHERE object_id = %d AND term_taxonomy_id = %d", $object_id, $tt_id ) ) ) {
2708              continue;
2709          }
2710  
2711          /**
2712           * Fires immediately before an object-term relationship is added.
2713           *
2714           * @since 2.9.0
2715           * @since 4.7.0 Added the `$taxonomy` parameter.
2716           *
2717           * @param int    $object_id Object ID.
2718           * @param int    $tt_id     Term taxonomy ID.
2719           * @param string $taxonomy  Taxonomy slug.
2720           */
2721          do_action( 'add_term_relationship', $object_id, $tt_id, $taxonomy );
2722  
2723          $wpdb->insert(
2724              $wpdb->term_relationships,
2725              array(
2726                  'object_id'        => $object_id,
2727                  'term_taxonomy_id' => $tt_id,
2728              )
2729          );
2730  
2731          /**
2732           * Fires immediately after an object-term relationship is added.
2733           *
2734           * @since 2.9.0
2735           * @since 4.7.0 Added the `$taxonomy` parameter.
2736           *
2737           * @param int    $object_id Object ID.
2738           * @param int    $tt_id     Term taxonomy ID.
2739           * @param string $taxonomy  Taxonomy slug.
2740           */
2741          do_action( 'added_term_relationship', $object_id, $tt_id, $taxonomy );
2742  
2743          $new_tt_ids[] = $tt_id;
2744      }
2745  
2746      if ( $new_tt_ids ) {
2747          wp_update_term_count( $new_tt_ids, $taxonomy );
2748      }
2749  
2750      if ( ! $append ) {
2751          $delete_tt_ids = array_diff( $old_tt_ids, $tt_ids );
2752  
2753          if ( $delete_tt_ids ) {
2754              $in_delete_tt_ids = "'" . implode( "', '", $delete_tt_ids ) . "'";
2755              $delete_term_ids  = $wpdb->get_col( $wpdb->prepare( "SELECT tt.term_id FROM $wpdb->term_taxonomy AS tt WHERE tt.taxonomy = %s AND tt.term_taxonomy_id IN ($in_delete_tt_ids)", $taxonomy ) );
2756              $delete_term_ids  = array_map( 'intval', $delete_term_ids );
2757  
2758              $remove = wp_remove_object_terms( $object_id, $delete_term_ids, $taxonomy );
2759              if ( is_wp_error( $remove ) ) {
2760                  return $remove;
2761              }
2762          }
2763      }
2764  
2765      $t = get_taxonomy( $taxonomy );
2766  
2767      if ( ! $append && isset( $t->sort ) && $t->sort ) {
2768          $values     = array();
2769          $term_order = 0;
2770  
2771          $final_tt_ids = wp_get_object_terms(
2772              $object_id,
2773              $taxonomy,
2774              array(
2775                  'fields'                 => 'tt_ids',
2776                  'update_term_meta_cache' => false,
2777              )
2778          );
2779  
2780          foreach ( $tt_ids as $tt_id ) {
2781              if ( in_array( (int) $tt_id, $final_tt_ids, true ) ) {
2782                  $values[] = $wpdb->prepare( '(%d, %d, %d)', $object_id, $tt_id, ++$term_order );
2783              }
2784          }
2785  
2786          if ( $values ) {
2787              if ( false === $wpdb->query( "INSERT INTO $wpdb->term_relationships (object_id, term_taxonomy_id, term_order) VALUES " . implode( ',', $values ) . ' ON DUPLICATE KEY UPDATE term_order = VALUES(term_order)' ) ) {
2788                  return new WP_Error( 'db_insert_error', __( 'Could not insert term relationship into the database.' ), $wpdb->last_error );
2789              }
2790          }
2791      }
2792  
2793      wp_cache_delete( $object_id, $taxonomy . '_relationships' );
2794      wp_cache_delete( 'last_changed', 'terms' );
2795  
2796      /**
2797       * Fires after an object's terms have been set.
2798       *
2799       * @since 2.8.0
2800       *
2801       * @param int    $object_id  Object ID.
2802       * @param array  $terms      An array of object term IDs or slugs.
2803       * @param array  $tt_ids     An array of term taxonomy IDs.
2804       * @param string $taxonomy   Taxonomy slug.
2805       * @param bool   $append     Whether to append new terms to the old terms.
2806       * @param array  $old_tt_ids Old array of term taxonomy IDs.
2807       */
2808      do_action( 'set_object_terms', $object_id, $terms, $tt_ids, $taxonomy, $append, $old_tt_ids );
2809  
2810      return $tt_ids;
2811  }
2812  
2813  /**
2814   * Add term(s) associated with a given object.
2815   *
2816   * @since 3.6.0
2817   *
2818   * @param int              $object_id The ID of the object to which the terms will be added.
2819   * @param string|int|array $terms     The slug(s) or ID(s) of the term(s) to add.
2820   * @param array|string     $taxonomy  Taxonomy name.
2821   * @return array|WP_Error Term taxonomy IDs of the affected terms.
2822   */
2823  function wp_add_object_terms( $object_id, $terms, $taxonomy ) {
2824      return wp_set_object_terms( $object_id, $terms, $taxonomy, true );
2825  }
2826  
2827  /**
2828   * Remove term(s) associated with a given object.
2829   *
2830   * @since 3.6.0
2831   *
2832   * @global wpdb $wpdb WordPress database abstraction object.
2833   *
2834   * @param int              $object_id The ID of the object from which the terms will be removed.
2835   * @param string|int|array $terms     The slug(s) or ID(s) of the term(s) to remove.
2836   * @param array|string     $taxonomy  Taxonomy name.
2837   * @return bool|WP_Error True on success, false or WP_Error on failure.
2838   */
2839  function wp_remove_object_terms( $object_id, $terms, $taxonomy ) {
2840      global $wpdb;
2841  
2842      $object_id = (int) $object_id;
2843  
2844      if ( ! taxonomy_exists( $taxonomy ) ) {
2845          return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
2846      }
2847  
2848      if ( ! is_array( $terms ) ) {
2849          $terms = array( $terms );
2850      }
2851  
2852      $tt_ids = array();
2853  
2854      foreach ( (array) $terms as $term ) {
2855          if ( '' === trim( $term ) ) {
2856              continue;
2857          }
2858  
2859          $term_info = term_exists( $term, $taxonomy );
2860          if ( ! $term_info ) {
2861              // Skip if a non-existent term ID is passed.
2862              if ( is_int( $term ) ) {
2863                  continue;
2864              }
2865          }
2866  
2867          if ( is_wp_error( $term_info ) ) {
2868              return $term_info;
2869          }
2870  
2871          $tt_ids[] = $term_info['term_taxonomy_id'];
2872      }
2873  
2874      if ( $tt_ids ) {
2875          $in_tt_ids = "'" . implode( "', '", $tt_ids ) . "'";
2876  
2877          /**
2878           * Fires immediately before an object-term relationship is deleted.
2879           *
2880           * @since 2.9.0
2881           * @since 4.7.0 Added the `$taxonomy` parameter.
2882           *
2883           * @param int   $object_id Object ID.
2884           * @param array $tt_ids    An array of term taxonomy IDs.
2885           * @param string $taxonomy  Taxonomy slug.
2886           */
2887          do_action( 'delete_term_relationships', $object_id, $tt_ids, $taxonomy );
2888  
2889          $deleted = $wpdb->query( $wpdb->prepare( "DELETE FROM $wpdb->term_relationships WHERE object_id = %d AND term_taxonomy_id IN ($in_tt_ids)", $object_id ) );
2890  
2891          wp_cache_delete( $object_id, $taxonomy . '_relationships' );
2892          wp_cache_delete( 'last_changed', 'terms' );
2893  
2894          /**
2895           * Fires immediately after an object-term relationship is deleted.
2896           *
2897           * @since 2.9.0
2898           * @since 4.7.0 Added the `$taxonomy` parameter.
2899           *
2900           * @param int    $object_id Object ID.
2901           * @param array  $tt_ids    An array of term taxonomy IDs.
2902           * @param string $taxonomy  Taxonomy slug.
2903           */
2904          do_action( 'deleted_term_relationships', $object_id, $tt_ids, $taxonomy );
2905  
2906          wp_update_term_count( $tt_ids, $taxonomy );
2907  
2908          return (bool) $deleted;
2909      }
2910  
2911      return false;
2912  }
2913  
2914  /**
2915   * Will make slug unique, if it isn't already.
2916   *
2917   * The `$slug` has to be unique global to every taxonomy, meaning that one
2918   * taxonomy term can't have a matching slug with another taxonomy term. Each
2919   * slug has to be globally unique for every taxonomy.
2920   *
2921   * The way this works is that if the taxonomy that the term belongs to is
2922   * hierarchical and has a parent, it will append that parent to the $slug.
2923   *
2924   * If that still doesn't return a unique slug, then it tries to append a number
2925   * until it finds a number that is truly unique.
2926   *
2927   * The only purpose for `$term` is for appending a parent, if one exists.
2928   *
2929   * @since 2.3.0
2930   *
2931   * @global wpdb $wpdb WordPress database abstraction object.
2932   *
2933   * @param string $slug The string that will be tried for a unique slug.
2934   * @param object $term The term object that the `$slug` will belong to.
2935   * @return string Will return a true unique slug.
2936   */
2937  function wp_unique_term_slug( $slug, $term ) {
2938      global $wpdb;
2939  
2940      $needs_suffix  = true;
2941      $original_slug = $slug;
2942  
2943      // As of 4.1, duplicate slugs are allowed as long as they're in different taxonomies.
2944      if ( ! term_exists( $slug ) || get_option( 'db_version' ) >= 30133 && ! get_term_by( 'slug', $slug, $term->taxonomy ) ) {
2945          $needs_suffix = false;
2946      }
2947  
2948      /*
2949       * If the taxonomy supports hierarchy and the term has a parent, make the slug unique
2950       * by incorporating parent slugs.
2951       */
2952      $parent_suffix = '';
2953      if ( $needs_suffix && is_taxonomy_hierarchical( $term->taxonomy ) && ! empty( $term->parent ) ) {
2954          $the_parent = $term->parent;
2955          while ( ! empty( $the_parent ) ) {
2956              $parent_term = get_term( $the_parent, $term->taxonomy );
2957              if ( is_wp_error( $parent_term ) || empty( $parent_term ) ) {
2958                  break;
2959              }
2960              $parent_suffix .= '-' . $parent_term->slug;
2961              if ( ! term_exists( $slug . $parent_suffix ) ) {
2962                  break;
2963              }
2964  
2965              if ( empty( $parent_term->parent ) ) {
2966                  break;
2967              }
2968              $the_parent = $parent_term->parent;
2969          }
2970      }
2971  
2972      // If we didn't get a unique slug, try appending a number to make it unique.
2973  
2974      /**
2975       * Filters whether the proposed unique term slug is bad.
2976       *
2977       * @since 4.3.0
2978       *
2979       * @param bool   $needs_suffix Whether the slug needs to be made unique with a suffix.
2980       * @param string $slug         The slug.
2981       * @param object $term         Term object.
2982       */
2983      if ( apply_filters( 'wp_unique_term_slug_is_bad_slug', $needs_suffix, $slug, $term ) ) {
2984          if ( $parent_suffix ) {
2985              $slug .= $parent_suffix;
2986          }
2987  
2988          if ( ! empty( $term->term_id ) ) {
2989              $query = $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s AND term_id != %d", $slug, $term->term_id );
2990          } else {
2991              $query = $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s", $slug );
2992          }
2993  
2994          if ( $wpdb->get_var( $query ) ) { // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared
2995              $num = 2;
2996              do {
2997                  $alt_slug = $slug . "-$num";
2998                  $num++;
2999                  $slug_check = $wpdb->get_var( $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s", $alt_slug ) );
3000              } while ( $slug_check );
3001              $slug = $alt_slug;
3002          }
3003      }
3004  
3005      /**
3006       * Filters the unique term slug.
3007       *
3008       * @since 4.3.0
3009       *
3010       * @param string $slug          Unique term slug.
3011       * @param object $term          Term object.
3012       * @param string $original_slug Slug originally passed to the function for testing.
3013       */
3014      return apply_filters( 'wp_unique_term_slug', $slug, $term, $original_slug );
3015  }
3016  
3017  /**
3018   * Update term based on arguments provided.
3019   *
3020   * The `$args` will indiscriminately override all values with the same field name.
3021   * Care must be taken to not override important information need to update or
3022   * update will fail (or perhaps create a new term, neither would be acceptable).
3023   *
3024   * Defaults will set 'alias_of', 'description', 'parent', and 'slug' if not
3025   * defined in `$args` already.
3026   *
3027   * 'alias_of' will create a term group, if it doesn't already exist, and
3028   * update it for the `$term`.
3029   *
3030   * If the 'slug' argument in `$args` is missing, then the 'name' will be used.
3031   * If you set 'slug' and it isn't unique, then a WP_Error is returned.
3032   * If you don't pass any slug, then a unique one will be created.
3033   *
3034   * @since 2.3.0
3035   *
3036   * @global wpdb $wpdb WordPress database abstraction object.
3037   *
3038   * @param int          $term_id  The ID of the term.
3039   * @param string       $taxonomy The taxonomy of the term.
3040   * @param array|string $args {
3041   *     Optional. Array or string of arguments for updating a term.
3042   *
3043   *     @type string $alias_of    Slug of the term to make this term an alias of.
3044   *                               Default empty string. Accepts a term slug.
3045   *     @type string $description The term description. Default empty string.
3046   *     @type int    $parent      The id of the parent term. Default 0.
3047   *     @type string $slug        The term slug to use. Default empty string.
3048   * }
3049   * @return array|WP_Error An array containing the `term_id` and `term_taxonomy_id`,
3050   *                        WP_Error otherwise.
3051   */
3052  function wp_update_term( $term_id, $taxonomy, $args = array() ) {
3053      global $wpdb;
3054  
3055      if ( ! taxonomy_exists( $taxonomy ) ) {
3056          return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
3057      }
3058  
3059      $term_id = (int) $term_id;
3060  
3061      // First, get all of the original args.
3062      $term = get_term( $term_id, $taxonomy );
3063  
3064      if ( is_wp_error( $term ) ) {
3065          return $term;
3066      }
3067  
3068      if ( ! $term ) {
3069          return new WP_Error( 'invalid_term', __( 'Empty Term.' ) );
3070      }
3071  
3072      $term = (array) $term->data;
3073  
3074      // Escape data pulled from DB.
3075      $term = wp_slash( $term );
3076  
3077      // Merge old and new args with new args overwriting old ones.
3078      $args = array_merge( $term, $args );
3079  
3080      $defaults    = array(
3081          'alias_of'    => '',
3082          'description' => '',
3083          'parent'      => 0,
3084          'slug'        => '',
3085      );
3086      $args        = wp_parse_args( $args, $defaults );
3087      $args        = sanitize_term( $args, $taxonomy, 'db' );
3088      $parsed_args = $args;
3089  
3090      // expected_slashed ($name)
3091      $name        = wp_unslash( $args['name'] );
3092      $description = wp_unslash( $args['description'] );
3093  
3094      $parsed_args['name']        = $name;
3095      $parsed_args['description'] = $description;
3096  
3097      if ( '' === trim( $name ) ) {
3098          return new WP_Error( 'empty_term_name', __( 'A name is required for this term.' ) );
3099      }
3100  
3101      if ( (int) $parsed_args['parent'] > 0 && ! term_exists( (int) $parsed_args['parent'] ) ) {
3102          return new WP_Error( 'missing_parent', __( 'Parent term does not exist.' ) );
3103      }
3104  
3105      $empty_slug = false;
3106      if ( empty( $args['slug'] ) ) {
3107          $empty_slug = true;
3108          $slug       = sanitize_title( $name );
3109      } else {
3110          $slug = $args['slug'];
3111      }
3112  
3113      $parsed_args['slug'] = $slug;
3114  
3115      $term_group = isset( $parsed_args['term_group'] ) ? $parsed_args['term_group'] : 0;
3116      if ( $args['alias_of'] ) {
3117          $alias = get_term_by( 'slug', $args['alias_of'], $taxonomy );
3118          if ( ! empty( $alias->term_group ) ) {
3119              // The alias we want is already in a group, so let's use that one.
3120              $term_group = $alias->term_group;
3121          } elseif ( ! empty( $alias->term_id ) ) {
3122              /*
3123               * The alias is not in a group, so we create a new one
3124               * and add the alias to it.
3125               */
3126              $term_group = $wpdb->get_var( "SELECT MAX(term_group) FROM $wpdb->terms" ) + 1;
3127  
3128              wp_update_term(
3129                  $alias->term_id,
3130                  $taxonomy,
3131                  array(
3132                      'term_group' => $term_group,
3133                  )
3134              );
3135          }
3136  
3137          $parsed_args['term_group'] = $term_group;
3138      }
3139  
3140      /**
3141       * Filters the term parent.
3142       *
3143       * Hook to this filter to see if it will cause a hierarchy loop.
3144       *
3145       * @since 3.1.0
3146       *
3147       * @param int    $parent      ID of the parent term.
3148       * @param int    $term_id     Term ID.
3149       * @param string $taxonomy    Taxonomy slug.
3150       * @param array  $parsed_args An array of potentially altered update arguments for the given term.
3151       * @param array  $args        An array of update arguments for the given term.
3152       */
3153      $parent = (int) apply_filters( 'wp_update_term_parent', $args['parent'], $term_id, $taxonomy, $parsed_args, $args );
3154  
3155      // Check for duplicate slug.
3156      $duplicate = get_term_by( 'slug', $slug, $taxonomy );
3157      if ( $duplicate && $duplicate->term_id !== $term_id ) {
3158          // If an empty slug was passed or the parent changed, reset the slug to something unique.
3159          // Otherwise, bail.
3160          if ( $empty_slug || ( $parent !== (int) $term['parent'] ) ) {
3161              $slug = wp_unique_term_slug( $slug, (object) $args );
3162          } else {
3163              /* translators: %s: Taxonomy term slug. */
3164              return new WP_Error( 'duplicate_term_slug', sprintf( __( 'The slug &#8220;%s&#8221; is already in use by another term.' ), $slug ) );
3165          }
3166      }
3167  
3168      $tt_id = (int) $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 ) );
3169  
3170      // Check whether this is a shared term that needs splitting.
3171      $_term_id = _split_shared_term( $term_id, $tt_id );
3172      if ( ! is_wp_error( $_term_id ) ) {
3173          $term_id = $_term_id;
3174      }
3175  
3176      /**
3177       * Fires immediately before the given terms are edited.
3178       *
3179       * @since 2.9.0
3180       *
3181       * @param int    $term_id  Term ID.
3182       * @param string $taxonomy Taxonomy slug.
3183       */
3184      do_action( 'edit_terms', $term_id, $taxonomy );
3185  
3186      $data = compact( 'name', 'slug', 'term_group' );
3187  
3188      /**
3189       * Filters term data before it is updated in the database.
3190       *
3191       * @since 4.7.0
3192       *
3193       * @param array  $data     Term data to be updated.
3194       * @param int    $term_id  Term ID.
3195       * @param string $taxonomy Taxonomy slug.
3196       * @param array  $args     Arguments passed to wp_update_term().
3197       */
3198      $data = apply_filters( 'wp_update_term_data', $data, $term_id, $taxonomy, $args );
3199  
3200      $wpdb->update( $wpdb->terms, $data, compact( 'term_id' ) );
3201  
3202      if ( empty( $slug ) ) {
3203          $slug = sanitize_title( $name, $term_id );
3204          $wpdb->update( $wpdb->terms, compact( 'slug' ), compact( 'term_id' ) );
3205      }
3206  
3207      /**
3208       * Fires immediately after a term is updated in the database, but before its
3209       * term-taxonomy relationship is updated.
3210       *
3211       * @since 2.9.0
3212       *
3213       * @param int    $term_id  Term ID
3214       * @param string $taxonomy Taxonomy slug.
3215       */
3216      do_action( 'edited_terms', $term_id, $taxonomy );
3217  
3218      /**
3219       * Fires immediate before a term-taxonomy relationship is updated.
3220       *
3221       * @since 2.9.0
3222       *
3223       * @param int    $tt_id    Term taxonomy ID.
3224       * @param string $taxonomy Taxonomy slug.
3225       */
3226      do_action( 'edit_term_taxonomy', $tt_id, $taxonomy );
3227  
3228      $wpdb->update( $wpdb->term_taxonomy, compact( 'term_id', 'taxonomy', 'description', 'parent' ), array( 'term_taxonomy_id' => $tt_id ) );
3229  
3230      /**
3231       * Fires immediately after a term-taxonomy relationship is updated.
3232       *
3233       * @since 2.9.0
3234       *
3235       * @param int    $tt_id    Term taxonomy ID.
3236       * @param string $taxonomy Taxonomy slug.
3237       */
3238      do_action( 'edited_term_taxonomy', $tt_id, $taxonomy );
3239  
3240      /**
3241       * Fires after a term has been updated, but before the term cache has been cleaned.
3242       *
3243       * The {@see 'edit_$taxonomy'} hook is also available for targeting a specific
3244       * taxonomy.
3245       *
3246       * @since 2.3.0
3247       *
3248       * @param int    $term_id  Term ID.
3249       * @param int    $tt_id    Term taxonomy ID.
3250       * @param string $taxonomy Taxonomy slug.
3251       */
3252      do_action( 'edit_term', $term_id, $tt_id, $taxonomy );
3253  
3254      /**
3255       * Fires after a term in a specific taxonomy has been updated, but before the term
3256       * cache has been cleaned.
3257       *
3258       * The dynamic portion of the hook name, `$taxonomy`, refers to the taxonomy slug.
3259       *
3260       * Possible hook names include:
3261       *
3262       *  - `edit_category`
3263       *  - `edit_post_tag`
3264       *
3265       * @since 2.3.0
3266       *
3267       * @param int $term_id Term ID.
3268       * @param int $tt_id   Term taxonomy ID.
3269       */
3270      do_action( "edit_{$taxonomy}", $term_id, $tt_id );
3271  
3272      /** This filter is documented in wp-includes/taxonomy.php */
3273      $term_id = apply_filters( 'term_id_filter', $term_id, $tt_id );
3274  
3275      clean_term_cache( $term_id, $taxonomy );
3276  
3277      /**
3278       * Fires after a term has been updated, and the term cache has been cleaned.
3279       *
3280       * The {@see 'edited_$taxonomy'} hook is also available for targeting a specific
3281       * taxonomy.
3282       *
3283       * @since 2.3.0
3284       *
3285       * @param int    $term_id  Term ID.
3286       * @param int    $tt_id    Term taxonomy ID.
3287       * @param string $taxonomy Taxonomy slug.
3288       */
3289      do_action( 'edited_term', $term_id, $tt_id, $taxonomy );
3290  
3291      /**
3292       * Fires after a term for a specific taxonomy has been updated, and the term
3293       * cache has been cleaned.
3294       *
3295       * The dynamic portion of the hook name, `$taxonomy`, refers to the taxonomy slug.
3296       *
3297       * Possible hook names include:
3298       *
3299       *  - `edited_category`
3300       *  - `edited_post_tag`
3301       *
3302       * @since 2.3.0
3303       *
3304       * @param int $term_id Term ID.
3305       * @param int $tt_id   Term taxonomy ID.
3306       */
3307      do_action( "edited_{$taxonomy}", $term_id, $tt_id );
3308  
3309      /** This action is documented in wp-includes/taxonomy.php */
3310      do_action( 'saved_term', $term_id, $tt_id, $taxonomy, true );
3311  
3312      /** This action is documented in wp-includes/taxonomy.php */
3313      do_action( "saved_{$taxonomy}", $term_id, $tt_id, true );
3314  
3315      return array(
3316          'term_id'          => $term_id,
3317          'term_taxonomy_id' => $tt_id,
3318      );
3319  }
3320  
3321  /**
3322   * Enable or disable term counting.
3323   *
3324   * @since 2.5.0
3325   *
3326   * @param bool $defer Optional. Enable if true, disable if false.
3327   * @return bool Whether term counting is enabled or disabled.
3328   */
3329  function wp_defer_term_counting( $defer = null ) {
3330      static $_defer = false;
3331  
3332      if ( is_bool( $defer ) ) {
3333          $_defer = $defer;
3334          // Flush any deferred counts.
3335          if ( ! $defer ) {
3336              wp_update_term_count( null, null, true );
3337          }
3338      }
3339  
3340      return $_defer;
3341  }
3342  
3343  /**
3344   * Updates the amount of terms in taxonomy.
3345   *
3346   * If there is a taxonomy callback applied, then it will be called for updating
3347   * the count.
3348   *
3349   * The default action is to count what the amount of terms have the relationship
3350   * of term ID. Once that is done, then update the database.
3351   *
3352   * @since 2.3.0
3353   *
3354   * @param int|array $terms       The term_taxonomy_id of the terms.
3355   * @param string    $taxonomy    The context of the term.
3356   * @param bool      $do_deferred Whether to flush the deferred term counts too. Default false.
3357   * @return bool If no terms will return false, and if successful will return true.
3358   */
3359  function wp_update_term_count( $terms, $taxonomy, $do_deferred = false ) {
3360      static $_deferred = array();
3361  
3362      if ( $do_deferred ) {
3363          foreach ( (array) array_keys( $_deferred ) as $tax ) {
3364              wp_update_term_count_now( $_deferred[ $tax ], $tax );
3365              unset( $_deferred[ $tax ] );
3366          }
3367      }
3368  
3369      if ( empty( $terms ) ) {
3370          return false;
3371      }
3372  
3373      if ( ! is_array( $terms ) ) {
3374          $terms = array( $terms );
3375      }
3376  
3377      if ( wp_defer_term_counting() ) {
3378          if ( ! isset( $_deferred[ $taxonomy ] ) ) {
3379              $_deferred[ $taxonomy ] = array();
3380          }
3381          $_deferred[ $taxonomy ] = array_unique( array_merge( $_deferred[ $taxonomy ], $terms ) );
3382          return true;
3383      }
3384  
3385      return wp_update_term_count_now( $terms, $taxonomy );
3386  }
3387  
3388  /**
3389   * Perform term count update immediately.
3390   *
3391   * @since 2.5.0
3392   *
3393   * @param array  $terms    The term_taxonomy_id of terms to update.
3394   * @param string $taxonomy The context of the term.
3395   * @return true Always true when complete.
3396   */
3397  function wp_update_term_count_now( $terms, $taxonomy ) {
3398      $terms = array_map( 'intval', $terms );
3399  
3400      $taxonomy = get_taxonomy( $taxonomy );
3401      if ( ! empty( $taxonomy->update_count_callback ) ) {
3402          call_user_func( $taxonomy->update_count_callback, $terms, $taxonomy );
3403      } else {
3404          $object_types = (array) $taxonomy->object_type;
3405          foreach ( $object_types as &$object_type ) {
3406              if ( 0 === strpos( $object_type, 'attachment:' ) ) {
3407                  list( $object_type ) = explode( ':', $object_type );
3408              }
3409          }
3410  
3411          if ( array_filter( $object_types, 'post_type_exists' ) == $object_types ) {
3412              // Only post types are attached to this taxonomy.
3413              _update_post_term_count( $terms, $taxonomy );
3414          } else {
3415              // Default count updater.
3416              _update_generic_term_count( $terms, $taxonomy );
3417          }
3418      }
3419  
3420      clean_term_cache( $terms, '', false );
3421  
3422      return true;
3423  }
3424  
3425  //
3426  // Cache.
3427  //
3428  
3429  /**
3430   * Removes the taxonomy relationship to terms from the cache.
3431   *
3432   * Will remove the entire taxonomy relationship containing term `$object_id`. The
3433   * term IDs have to exist within the taxonomy `$object_type` for the deletion to
3434   * take place.
3435   *
3436   * @since 2.3.0
3437   *
3438   * @global bool $_wp_suspend_cache_invalidation
3439   *
3440   * @see get_object_taxonomies() for more on $object_type.
3441   *
3442   * @param int|array    $object_ids  Single or list of term object ID(s).
3443   * @param array|string $object_type The taxonomy object type.
3444   */
3445  function clean_object_term_cache( $object_ids, $object_type ) {
3446      global $_wp_suspend_cache_invalidation;
3447  
3448      if ( ! empty( $_wp_suspend_cache_invalidation ) ) {
3449          return;
3450      }
3451  
3452      if ( ! is_array( $object_ids ) ) {
3453          $object_ids = array( $object_ids );
3454      }
3455  
3456      $taxonomies = get_object_taxonomies( $object_type );
3457  
3458      foreach ( $object_ids as $id ) {
3459          foreach ( $taxonomies as $taxonomy ) {
3460              wp_cache_delete( $id, "{$taxonomy}_relationships" );
3461          }
3462      }
3463  
3464      /**
3465       * Fires after the object term cache has been cleaned.
3466       *
3467       * @since 2.5.0
3468       *
3469       * @param array  $object_ids An array of object IDs.
3470       * @param string $object_type Object type.
3471       */
3472      do_action( 'clean_object_term_cache', $object_ids, $object_type );
3473  }
3474  
3475  /**
3476   * Will remove all of the term IDs from the cache.
3477   *
3478   * @since 2.3.0
3479   *
3480   * @global wpdb $wpdb                           WordPress database abstraction object.
3481   * @global bool $_wp_suspend_cache_invalidation
3482   *
3483   * @param int|int[] $ids            Single or array of term IDs.
3484   * @param string    $taxonomy       Optional. Taxonomy slug. Can be empty, in which case the taxonomies of the passed
3485   *                                  term IDs will be used. Default empty.
3486   * @param bool      $clean_taxonomy Optional. Whether to clean taxonomy wide caches (true), or just individual
3487   *                                  term object caches (false). Default true.
3488   */
3489  function clean_term_cache( $ids, $taxonomy = '', $clean_taxonomy = true ) {
3490      global $wpdb, $_wp_suspend_cache_invalidation;
3491  
3492      if ( ! empty( $_wp_suspend_cache_invalidation ) ) {
3493          return;
3494      }
3495  
3496      if ( ! is_array( $ids ) ) {
3497          $ids = array( $ids );
3498      }
3499  
3500      $taxonomies = array();
3501      // If no taxonomy, assume tt_ids.
3502      if ( empty( $taxonomy ) ) {
3503          $tt_ids = array_map( 'intval', $ids );
3504          $tt_ids = implode( ', ', $tt_ids );
3505          $terms  = $wpdb->get_results( "SELECT term_id, taxonomy FROM $wpdb->term_taxonomy WHERE term_taxonomy_id IN ($tt_ids)" );
3506          $ids    = array();
3507  
3508          foreach ( (array) $terms as $term ) {
3509              $taxonomies[] = $term->taxonomy;
3510              $ids[]        = $term->term_id;
3511              wp_cache_delete( $term->term_id, 'terms' );
3512          }
3513  
3514          $taxonomies = array_unique( $taxonomies );
3515      } else {
3516          $taxonomies = array( $taxonomy );
3517  
3518          foreach ( $taxonomies as $taxonomy ) {
3519              foreach ( $ids as $id ) {
3520                  wp_cache_delete( $id, 'terms' );
3521              }
3522          }
3523      }
3524  
3525      foreach ( $taxonomies as $taxonomy ) {
3526          if ( $clean_taxonomy ) {
3527              clean_taxonomy_cache( $taxonomy );
3528          }
3529  
3530          /**
3531           * Fires once after each taxonomy's term cache has been cleaned.
3532           *
3533           * @since 2.5.0
3534           * @since 4.5.0 Added the `$clean_taxonomy` parameter.
3535           *
3536           * @param array  $ids            An array of term IDs.
3537           * @param string $taxonomy       Taxonomy slug.
3538           * @param bool   $clean_taxonomy Whether or not to clean taxonomy-wide caches
3539           */
3540          do_action( 'clean_term_cache', $ids, $taxonomy, $clean_taxonomy );
3541      }
3542  
3543      wp_cache_set( 'last_changed', microtime(), 'terms' );
3544  }
3545  
3546  /**
3547   * Clean the caches for a taxonomy.
3548   *
3549   * @since 4.9.0
3550   *
3551   * @param string $taxonomy Taxonomy slug.
3552   */
3553  function clean_taxonomy_cache( $taxonomy ) {
3554      wp_cache_delete( 'all_ids', $taxonomy );
3555      wp_cache_delete( 'get', $taxonomy );
3556  
3557      // Regenerate cached hierarchy.
3558      delete_option( "{$taxonomy}_children" );
3559      _get_term_hierarchy( $taxonomy );
3560  
3561      /**
3562       * Fires after a taxonomy's caches have been cleaned.
3563       *
3564       * @since 4.9.0
3565       *
3566       * @param string $taxonomy Taxonomy slug.
3567       */
3568      do_action( 'clean_taxonomy_cache', $taxonomy );
3569  }
3570  
3571  /**
3572   * Retrieves the cached term objects for the given object ID.
3573   *
3574   * Upstream functions (like get_the_terms() and is_object_in_term()) are
3575   * responsible for populating the object-term relationship cache. The current
3576   * function only fetches relationship data that is already in the cache.
3577   *
3578   * @since 2.3.0
3579   * @since 4.7.0 Returns a `WP_Error` object if there's an error with
3580   *              any of the matched terms.
3581   *
3582   * @param int    $id       Term object ID, for example a post, comment, or user ID.
3583   * @param string $taxonomy Taxonomy name.
3584   * @return bool|WP_Term[]|WP_Error Array of `WP_Term` objects, if cached.
3585   *                                 False if cache is empty for `$taxonomy` and `$id`.
3586   *                                 WP_Error if get_term() returns an error object for any term.
3587   */
3588  function get_object_term_cache( $id, $taxonomy ) {
3589      $_term_ids = wp_cache_get( $id, "{$taxonomy}_relationships" );
3590  
3591      // We leave the priming of relationship caches to upstream functions.
3592      if ( false === $_term_ids ) {
3593          return false;
3594      }
3595  
3596      // Backward compatibility for if a plugin is putting objects into the cache, rather than IDs.
3597      $term_ids = array();
3598      foreach ( $_term_ids as $term_id ) {
3599          if ( is_numeric( $term_id ) ) {
3600              $term_ids[] = (int) $term_id;
3601          } elseif ( isset( $term_id->term_id ) ) {
3602              $term_ids[] = (int) $term_id->term_id;
3603          }
3604      }
3605  
3606      // Fill the term objects.
3607      _prime_term_caches( $term_ids );
3608  
3609      $terms = array();
3610      foreach ( $term_ids as $term_id ) {
3611          $term = get_term( $term_id, $taxonomy );
3612          if ( is_wp_error( $term ) ) {
3613              return $term;
3614          }
3615  
3616          $terms[] = $term;
3617      }
3618  
3619      return $terms;
3620  }
3621  
3622  /**
3623   * Updates the cache for the given term object ID(s).
3624   *
3625   * Note: Due to performance concerns, great care should be taken to only update
3626   * term caches when necessary. Processing time can increase exponentially depending
3627   * on both the number of passed term IDs and the number of taxonomies those terms
3628   * belong to.
3629   *
3630   * Caches will only be updated for terms not already cached.
3631   *
3632   * @since 2.3.0
3633   *
3634   * @param string|int[]    $object_ids  Comma-separated list or array of term object IDs.
3635   * @param string|string[] $object_type The taxonomy object type or array of the same.
3636   * @return void|false Void on success or if the `$object_ids` parameter is empty,
3637   *                    false if all of the terms in `$object_ids` are already cached.
3638   */
3639  function update_object_term_cache( $object_ids, $object_type ) {
3640      if ( empty( $object_ids ) ) {
3641          return;
3642      }
3643  
3644      if ( ! is_array( $object_ids ) ) {
3645          $object_ids = explode( ',', $object_ids );
3646      }
3647  
3648      $object_ids     = array_map( 'intval', $object_ids );
3649      $non_cached_ids = array();
3650  
3651      $taxonomies = get_object_taxonomies( $object_type );
3652  
3653      foreach ( $taxonomies as $taxonomy ) {
3654          $cache_values = wp_cache_get_multiple( (array) $object_ids, "{$taxonomy}_relationships" );
3655  
3656          foreach ( $cache_values as $id => $value ) {
3657              if ( false === $value ) {
3658                  $non_cached_ids[] = $id;
3659              }
3660          }
3661      }
3662  
3663      if ( empty( $non_cached_ids ) ) {
3664          return false;
3665      }
3666  
3667      $non_cached_ids = array_unique( $non_cached_ids );
3668  
3669      $terms = wp_get_object_terms(
3670          $non_cached_ids,
3671          $taxonomies,
3672          array(
3673              'fields'                 => 'all_with_object_id',
3674              'orderby'                => 'name',
3675              'update_term_meta_cache' => false,
3676          )
3677      );
3678  
3679      $object_terms = array();
3680      foreach ( (array) $terms as $term ) {
3681          $object_terms[ $term->object_id ][ $term->taxonomy ][] = $term->term_id;
3682      }
3683  
3684      foreach ( $non_cached_ids as $id ) {
3685          foreach ( $taxonomies as $taxonomy ) {
3686              if ( ! isset( $object_terms[ $id ][ $taxonomy ] ) ) {
3687                  if ( ! isset( $object_terms[ $id ] ) ) {
3688                      $object_terms[ $id ] = array();
3689                  }
3690                  $object_terms[ $id ][ $taxonomy ] = array();
3691              }
3692          }
3693      }
3694  
3695      foreach ( $object_terms as $id => $value ) {
3696          foreach ( $value as $taxonomy => $terms ) {
3697              wp_cache_add( $id, $terms, "{$taxonomy}_relationships" );
3698          }
3699      }
3700  }
3701  
3702  /**
3703   * Updates Terms to Taxonomy in cache.
3704   *
3705   * @since 2.3.0
3706   *
3707   * @param WP_Term[] $terms    Array of term objects to change.
3708   * @param string    $taxonomy Not used.
3709   */
3710  function update_term_cache( $terms, $taxonomy = '' ) {
3711      foreach ( (array) $terms as $term ) {
3712          // Create a copy in case the array was passed by reference.
3713          $_term = clone $term;
3714  
3715          // Object ID should not be cached.
3716          unset( $_term->object_id );
3717  
3718          wp_cache_add( $term->term_id, $_term, 'terms' );
3719      }
3720  }
3721  
3722  //
3723  // Private.
3724  //
3725  
3726  /**
3727   * Retrieves children of taxonomy as Term IDs.
3728   *
3729   * @access private
3730   * @since 2.3.0
3731   *
3732   * @param string $taxonomy Taxonomy name.
3733   * @return array Empty if $taxonomy isn't hierarchical or returns children as Term IDs.
3734   */
3735  function _get_term_hierarchy( $taxonomy ) {
3736      if ( ! is_taxonomy_hierarchical( $taxonomy ) ) {
3737          return array();
3738      }
3739      $children = get_option( "{$taxonomy}_children" );
3740  
3741      if ( is_array( $children ) ) {
3742          return $children;
3743      }
3744      $children = array();
3745      $terms    = get_terms(
3746          array(
3747              'taxonomy'               => $taxonomy,
3748              'get'                    => 'all',
3749              'orderby'                => 'id',
3750              'fields'                 => 'id=>parent',
3751              'update_term_meta_cache' => false,
3752          )
3753      );
3754      foreach ( $terms as $term_id => $parent ) {
3755          if ( $parent > 0 ) {
3756              $children[ $parent ][] = $term_id;
3757          }
3758      }
3759      update_option( "{$taxonomy}_children", $children );
3760  
3761      return $children;
3762  }
3763  
3764  /**
3765   * Get the subset of $terms that are descendants of $term_id.
3766   *
3767   * If `$terms` is an array of objects, then _get_term_children() returns an array of objects.
3768   * If `$terms` is an array of IDs, then _get_term_children() returns an array of IDs.
3769   *
3770   * @access private
3771   * @since 2.3.0
3772   *
3773   * @param int    $term_id   The ancestor term: all returned terms should be descendants of `$term_id`.
3774   * @param array  $terms     The set of terms - either an array of term objects or term IDs - from which those that
3775   *                          are descendants of $term_id will be chosen.
3776   * @param string $taxonomy  The taxonomy which determines the hierarchy of the terms.
3777   * @param array  $ancestors Optional. Term ancestors that have already been identified. Passed by reference, to keep
3778   *                          track of found terms when recursing the hierarchy. The array of located ancestors is used
3779   *                          to prevent infinite recursion loops. For performance, `term_ids` are used as array keys,
3780   *                          with 1 as value. Default empty array.
3781   * @return array|WP_Error The subset of $terms that are descendants of $term_id.
3782   */
3783  function _get_term_children( $term_id, $terms, $taxonomy, &$ancestors = array() ) {
3784      $empty_array = array();
3785      if ( empty( $terms ) ) {
3786          return $empty_array;
3787      }
3788  
3789      $term_id      = (int) $term_id;
3790      $term_list    = array();
3791      $has_children = _get_term_hierarchy( $taxonomy );
3792  
3793      if ( $term_id && ! isset( $has_children[ $term_id ] ) ) {
3794          return $empty_array;
3795      }
3796  
3797      // Include the term itself in the ancestors array, so we can properly detect when a loop has occurred.
3798      if ( empty( $ancestors ) ) {
3799          $ancestors[ $term_id ] = 1;
3800      }
3801  
3802      foreach ( (array) $terms as $term ) {
3803          $use_id = false;
3804          if ( ! is_object( $term ) ) {
3805              $term = get_term( $term, $taxonomy );
3806              if ( is_wp_error( $term ) ) {
3807                  return $term;
3808              }
3809              $use_id = true;
3810          }
3811  
3812          // Don't recurse if we've already identified the term as a child - this indicates a loop.
3813          if ( isset( $ancestors[ $term->term_id ] ) ) {
3814              continue;
3815          }
3816  
3817          if ( (int) $term->parent === $term_id ) {
3818              if ( $use_id ) {
3819                  $term_list[] = $term->term_id;
3820              } else {
3821                  $term_list[] = $term;
3822              }
3823  
3824              if ( ! isset( $has_children[ $term->term_id ] ) ) {
3825                  continue;
3826              }
3827  
3828              $ancestors[ $term->term_id ] = 1;
3829  
3830              $children = _get_term_children( $term->term_id, $terms, $taxonomy, $ancestors );
3831              if ( $children ) {
3832                  $term_list = array_merge( $term_list, $children );
3833              }
3834          }
3835      }
3836  
3837      return $term_list;
3838  }
3839  
3840  /**
3841   * Add count of children to parent count.
3842   *
3843   * Recalculates term counts by including items from child terms. Assumes all
3844   * relevant children are already in the $terms argument.
3845   *
3846   * @access private
3847   * @since 2.3.0
3848   *
3849   * @global wpdb $wpdb WordPress database abstraction object.
3850   *
3851   * @param object[]|WP_Term[] $terms    List of term objects (passed by reference).
3852   * @param string             $taxonomy Term context.
3853   */
3854  function _pad_term_counts( &$terms, $taxonomy ) {
3855      global $wpdb;
3856  
3857      // This function only works for hierarchical taxonomies like post categories.
3858      if ( ! is_taxonomy_hierarchical( $taxonomy ) ) {
3859          return;
3860      }
3861  
3862      $term_hier = _get_term_hierarchy( $taxonomy );
3863  
3864      if ( empty( $term_hier ) ) {
3865          return;
3866      }
3867  
3868      $term_items  = array();
3869      $terms_by_id = array();
3870      $term_ids    = array();
3871  
3872      foreach ( (array) $terms as $key => $term ) {
3873          $terms_by_id[ $term->term_id ]       = & $terms[ $key ];
3874          $term_ids[ $term->term_taxonomy_id ] = $term->term_id;
3875      }
3876  
3877      // Get the object and term IDs and stick them in a lookup table.
3878      $tax_obj      = get_taxonomy( $taxonomy );
3879      $object_types = esc_sql( $tax_obj->object_type );
3880      $results      = $wpdb->get_results( "SELECT object_id, term_taxonomy_id FROM $wpdb->term_relationships INNER JOIN $wpdb->posts ON object_id = ID WHERE term_taxonomy_id IN (" . implode( ',', array_keys( $term_ids ) ) . ") AND post_type IN ('" . implode( "', '", $object_types ) . "') AND post_status = 'publish'" );
3881  
3882      foreach ( $results as $row ) {
3883          $id = $term_ids[ $row->term_taxonomy_id ];
3884  
3885          $term_items[ $id ][ $row->object_id ] = isset( $term_items[ $id ][ $row->object_id ] ) ? ++$term_items[ $id ][ $row->object_id ] : 1;
3886      }
3887  
3888      // Touch every ancestor's lookup row for each post in each term.
3889      foreach ( $term_ids as $term_id ) {
3890          $child     = $term_id;
3891          $ancestors = array();
3892          while ( ! empty( $terms_by_id[ $child ] ) && $parent = $terms_by_id[ $child ]->parent ) {
3893              $ancestors[] = $child;
3894  
3895              if ( ! empty( $term_items[ $term_id ] ) ) {
3896                  foreach ( $term_items[ $term_id ] as $item_id => $touches ) {
3897                      $term_items[ $parent ][ $item_id ] = isset( $term_items[ $parent ][ $item_id ] ) ? ++$term_items[ $parent ][ $item_id ] : 1;
3898                  }
3899              }
3900  
3901              $child = $parent;
3902  
3903              if ( in_array( $parent, $ancestors, true ) ) {
3904                  break;
3905              }
3906          }
3907      }
3908  
3909      // Transfer the touched cells.
3910      foreach ( (array) $term_items as $id => $items ) {
3911          if ( isset( $terms_by_id[ $id ] ) ) {
3912              $terms_by_id[ $id ]->count = count( $items );
3913          }
3914      }
3915  }
3916  
3917  /**
3918   * Adds any terms from the given IDs to the cache that do not already exist in cache.
3919   *
3920   * @since 4.6.0
3921   * @access private
3922   *
3923   * @global wpdb $wpdb WordPress database abstraction object.
3924   *
3925   * @param array $term_ids          Array of term IDs.
3926   * @param bool  $update_meta_cache Optional. Whether to update the meta cache. Default true.
3927   */
3928  function _prime_term_caches( $term_ids, $update_meta_cache = true ) {
3929      global $wpdb;
3930  
3931      $non_cached_ids = _get_non_cached_ids( $term_ids, 'terms' );
3932      if ( ! empty( $non_cached_ids ) ) {
3933          $fresh_terms = $wpdb->get_results( sprintf( "SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE t.term_id IN (%s)", implode( ',', array_map( 'intval', $non_cached_ids ) ) ) );
3934  
3935          update_term_cache( $fresh_terms, $update_meta_cache );
3936  
3937          if ( $update_meta_cache ) {
3938              update_termmeta_cache( $non_cached_ids );
3939          }
3940      }
3941  }
3942  
3943  //
3944  // Default callbacks.
3945  //
3946  
3947  /**
3948   * Will update term count based on object types of the current taxonomy.
3949   *
3950   * Private function for the default callback for post_tag and category
3951   * taxonomies.
3952   *
3953   * @access private
3954   * @since 2.3.0
3955   *
3956   * @global wpdb $wpdb WordPress database abstraction object.
3957   *
3958   * @param int[]       $terms    List of Term taxonomy IDs.
3959   * @param WP_Taxonomy $taxonomy Current taxonomy object of terms.
3960   */
3961  function _update_post_term_count( $terms, $taxonomy ) {
3962      global $wpdb;
3963  
3964      $object_types = (array) $taxonomy->object_type;
3965  
3966      foreach ( $object_types as &$object_type ) {
3967          list( $object_type ) = explode( ':', $object_type );
3968      }
3969  
3970      $object_types = array_unique( $object_types );
3971  
3972      $check_attachments = array_search( 'attachment', $object_types, true );
3973      if ( false !== $check_attachments ) {
3974          unset( $object_types[ $check_attachments ] );
3975          $check_attachments = true;
3976      }
3977  
3978      if ( $object_types ) {
3979          $object_types = esc_sql( array_filter( $object_types, 'post_type_exists' ) );
3980      }
3981  
3982      $post_statuses = array( 'publish' );
3983  
3984      /**
3985       * Filters the post statuses for updating the term count.
3986       *
3987       * @since 5.7.0
3988       *
3989       * @param string[]    $post_statuses List of post statuses to include in the count. Default is 'publish'.
3990       * @param WP_Taxonomy $taxonomy      Current taxonomy object.
3991       */
3992      $post_statuses = esc_sql( apply_filters( 'update_post_term_count_statuses', $post_statuses, $taxonomy ) );
3993  
3994      foreach ( (array) $terms as $term ) {
3995          $count = 0;
3996  
3997          // Attachments can be 'inherit' status, we need to base count off the parent's status if so.
3998          if ( $check_attachments ) {
3999              // phpcs:ignore WordPress.DB.PreparedSQLPlaceholders.QuotedDynamicPlaceholderGeneration
4000              $count += (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_relationships, $wpdb->posts p1 WHERE p1.ID = $wpdb->term_relationships.object_id AND ( post_status IN ('" . implode( "', '", $post_statuses ) . "') OR ( post_status = 'inherit' AND post_parent > 0 AND ( SELECT post_status FROM $wpdb->posts WHERE ID = p1.post_parent ) IN ('" . implode( "', '", $post_statuses ) . "') ) ) AND post_type = 'attachment' AND term_taxonomy_id = %d", $term ) );
4001          }
4002  
4003          if ( $object_types ) {
4004              // phpcs:ignore WordPress.DB.PreparedSQLPlaceholders.QuotedDynamicPlaceholderGeneration
4005              $count += (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_relationships, $wpdb->posts WHERE $wpdb->posts.ID = $wpdb->term_relationships.object_id AND post_status IN ('" . implode( "', '", $post_statuses ) . "') AND post_type IN ('" . implode( "', '", $object_types ) . "') AND term_taxonomy_id = %d", $term ) );
4006          }
4007  
4008          /** This action is documented in wp-includes/taxonomy.php */
4009          do_action( 'edit_term_taxonomy', $term, $taxonomy->name );
4010          $wpdb->update( $wpdb->term_taxonomy, compact( 'count' ), array( 'term_taxonomy_id' => $term ) );
4011  
4012          /** This action is documented in wp-includes/taxonomy.php */
4013          do_action( 'edited_term_taxonomy', $term, $taxonomy->name );
4014      }
4015  }
4016  
4017  /**
4018   * Will update term count based on number of objects.
4019   *
4020   * Default callback for the 'link_category' taxonomy.
4021   *
4022   * @since 3.3.0
4023   *
4024   * @global wpdb $wpdb WordPress database abstraction object.
4025   *
4026   * @param int[]       $terms    List of term taxonomy IDs.
4027   * @param WP_Taxonomy $taxonomy Current taxonomy object of terms.
4028   */
4029  function _update_generic_term_count( $terms, $taxonomy ) {
4030      global $wpdb;
4031  
4032      foreach ( (array) $terms as $term ) {
4033          $count = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_relationships WHERE term_taxonomy_id = %d", $term ) );
4034  
4035          /** This action is documented in wp-includes/taxonomy.php */
4036          do_action( 'edit_term_taxonomy', $term, $taxonomy->name );
4037          $wpdb->update( $wpdb->term_taxonomy, compact( 'count' ), array( 'term_taxonomy_id' => $term ) );
4038  
4039          /** This action is documented in wp-includes/taxonomy.php */
4040          do_action( 'edited_term_taxonomy', $term, $taxonomy->name );
4041      }
4042  }
4043  
4044  /**
4045   * Create a new term for a term_taxonomy item that currently shares its term
4046   * with another term_taxonomy.
4047   *
4048   * @ignore
4049   * @since 4.2.0
4050   * @since 4.3.0 Introduced `$record` parameter. Also, `$term_id` and
4051   *              `$term_taxonomy_id` can now accept objects.
4052   *
4053   * @global wpdb $wpdb WordPress database abstraction object.
4054   *
4055   * @param int|object $term_id          ID of the shared term, or the shared term object.
4056   * @param int|object $term_taxonomy_id ID of the term_taxonomy item to receive a new term, or the term_taxonomy object
4057   *                                     (corresponding to a row from the term_taxonomy table).
4058   * @param bool       $record           Whether to record data about the split term in the options table. The recording
4059   *                                     process has the potential to be resource-intensive, so during batch operations
4060   *                                     it can be beneficial to skip inline recording and do it just once, after the
4061   *                                     batch is processed. Only set this to `false` if you know what you are doing.
4062   *                                     Default: true.
4063   * @return int|WP_Error When the current term does not need to be split (or cannot be split on the current
4064   *                      database schema), `$term_id` is returned. When the term is successfully split, the
4065   *                      new term_id is returned. A WP_Error is returned for miscellaneous errors.
4066   */
4067  function _split_shared_term( $term_id, $term_taxonomy_id, $record = true ) {
4068      global $wpdb;
4069  
4070      if ( is_object( $term_id ) ) {
4071          $shared_term = $term_id;
4072          $term_id     = (int) $shared_term->term_id;
4073      }
4074  
4075      if ( is_object( $term_taxonomy_id ) ) {
4076          $term_taxonomy    = $term_taxonomy_id;
4077          $term_taxonomy_id = (int) $term_taxonomy->term_taxonomy_id;
4078      }
4079  
4080      // If there are no shared term_taxonomy rows, there's nothing to do here.
4081      $shared_tt_count = (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_taxonomy tt WHERE tt.term_id = %d AND tt.term_taxonomy_id != %d", $term_id, $term_taxonomy_id ) );
4082  
4083      if ( ! $shared_tt_count ) {
4084          return $term_id;
4085      }
4086  
4087      /*
4088       * Verify that the term_taxonomy_id passed to the function is actually associated with the term_id.
4089       * If there's a mismatch, it may mean that the term is already split. Return the actual term_id from the db.
4090       */
4091      $check_term_id = (int) $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->term_taxonomy WHERE term_taxonomy_id = %d", $term_taxonomy_id ) );
4092      if ( $check_term_id !== $term_id ) {
4093          return $check_term_id;
4094      }
4095  
4096      // Pull up data about the currently shared slug, which we'll use to populate the new one.
4097      if ( empty( $shared_term ) ) {
4098          $shared_term = $wpdb->get_row( $wpdb->prepare( "SELECT t.* FROM $wpdb->terms t WHERE t.term_id = %d", $term_id ) );
4099      }
4100  
4101      $new_term_data = array(
4102          'name'       => $shared_term->name,
4103          'slug'       => $shared_term->slug,
4104          'term_group' => $shared_term->term_group,
4105      );
4106  
4107      if ( false === $wpdb->insert( $wpdb->terms, $new_term_data ) ) {
4108          return new WP_Error( 'db_insert_error', __( 'Could not split shared term.' ), $wpdb->last_error );
4109      }
4110  
4111      $new_term_id = (int) $wpdb->insert_id;
4112  
4113      // Update the existing term_taxonomy to point to the newly created term.
4114      $wpdb->update(
4115          $wpdb->term_taxonomy,
4116          array( 'term_id' => $new_term_id ),
4117          array( 'term_taxonomy_id' => $term_taxonomy_id )
4118      );
4119  
4120      // Reassign child terms to the new parent.
4121      if ( empty( $term_taxonomy ) ) {
4122          $term_taxonomy = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $wpdb->term_taxonomy WHERE term_taxonomy_id = %d", $term_taxonomy_id ) );
4123      }
4124  
4125      $children_tt_ids = $wpdb->get_col( $wpdb->prepare( "SELECT term_taxonomy_id FROM $wpdb->term_taxonomy WHERE parent = %d AND taxonomy = %s", $term_id, $term_taxonomy->taxonomy ) );
4126      if ( ! empty( $children_tt_ids ) ) {
4127          foreach ( $children_tt_ids as $child_tt_id ) {
4128              $wpdb->update(
4129                  $wpdb->term_taxonomy,
4130                  array( 'parent' => $new_term_id ),
4131                  array( 'term_taxonomy_id' => $child_tt_id )
4132              );
4133              clean_term_cache( (int) $child_tt_id, '', false );
4134          }
4135      } else {
4136          // If the term has no children, we must force its taxonomy cache to be rebuilt separately.
4137          clean_term_cache( $new_term_id, $term_taxonomy->taxonomy, false );
4138      }
4139  
4140      clean_term_cache( $term_id, $term_taxonomy->taxonomy, false );
4141  
4142      /*
4143       * Taxonomy cache clearing is delayed to avoid race conditions that may occur when
4144       * regenerating the taxonomy's hierarchy tree.
4145       */
4146      $taxonomies_to_clean = array( $term_taxonomy->taxonomy );
4147  
4148      // Clean the cache for term taxonomies formerly shared with the current term.
4149      $shared_term_taxonomies = $wpdb->get_col( $wpdb->prepare( "SELECT taxonomy FROM $wpdb->term_taxonomy WHERE term_id = %d", $term_id ) );
4150      $taxonomies_to_clean    = array_merge( $taxonomies_to_clean, $shared_term_taxonomies );
4151  
4152      foreach ( $taxonomies_to_clean as $taxonomy_to_clean ) {
4153          clean_taxonomy_cache( $taxonomy_to_clean );
4154      }
4155  
4156      // Keep a record of term_ids that have been split, keyed by old term_id. See wp_get_split_term().
4157      if ( $record ) {
4158          $split_term_data = get_option( '_split_terms', array() );
4159          if ( ! isset( $split_term_data[ $term_id ] ) ) {
4160              $split_term_data[ $term_id ] = array();
4161          }
4162  
4163          $split_term_data[ $term_id ][ $term_taxonomy->taxonomy ] = $new_term_id;
4164          update_option( '_split_terms', $split_term_data );
4165      }
4166  
4167      // If we've just split the final shared term, set the "finished" flag.
4168      $shared_terms_exist = $wpdb->get_results(
4169          "SELECT tt.term_id, t.*, count(*) as term_tt_count FROM {$wpdb->term_taxonomy} tt
4170           LEFT JOIN {$wpdb->terms} t ON t.term_id = tt.term_id
4171           GROUP BY t.term_id
4172           HAVING term_tt_count > 1
4173           LIMIT 1"
4174      );
4175      if ( ! $shared_terms_exist ) {
4176          update_option( 'finished_splitting_shared_terms', true );
4177      }
4178  
4179      /**
4180       * Fires after a previously shared taxonomy term is split into two separate terms.
4181       *
4182       * @since 4.2.0
4183       *
4184       * @param int    $term_id          ID of the formerly shared term.
4185       * @param int    $new_term_id      ID of the new term created for the $term_taxonomy_id.
4186       * @param int    $term_taxonomy_id ID for the term_taxonomy row affected by the split.
4187       * @param string $taxonomy         Taxonomy for the split term.
4188       */
4189      do_action( 'split_shared_term', $term_id, $new_term_id, $term_taxonomy_id, $term_taxonomy->taxonomy );
4190  
4191      return $new_term_id;
4192  }
4193  
4194  /**
4195   * Splits a batch of shared taxonomy terms.
4196   *
4197   * @since 4.3.0
4198   *
4199   * @global wpdb $wpdb WordPress database abstraction object.
4200   */
4201  function _wp_batch_split_terms() {
4202      global $wpdb;
4203  
4204      $lock_name = 'term_split.lock';
4205  
4206      // Try to lock.
4207      $lock_result = $wpdb->query( $wpdb->prepare( "INSERT IGNORE INTO `$wpdb->options` ( `option_name`, `option_value`, `autoload` ) VALUES (%s, %s, 'no') /* LOCK */", $lock_name, time() ) );
4208  
4209      if ( ! $lock_result ) {
4210          $lock_result = get_option( $lock_name );
4211  
4212          // Bail if we were unable to create a lock, or if the existing lock is still valid.
4213          if ( ! $lock_result || ( $lock_result > ( time() - HOUR_IN_SECONDS ) ) ) {
4214              wp_schedule_single_event( time() + ( 5 * MINUTE_IN_SECONDS ), 'wp_split_shared_term_batch' );
4215              return;
4216          }
4217      }
4218  
4219      // Update the lock, as by this point we've definitely got a lock, just need to fire the actions.
4220      update_option( $lock_name, time() );
4221  
4222      // Get a list of shared terms (those with more than one associated row in term_taxonomy).
4223      $shared_terms = $wpdb->get_results(
4224          "SELECT tt.term_id, t.*, count(*) as term_tt_count FROM {$wpdb->term_taxonomy} tt
4225           LEFT JOIN {$wpdb->terms} t ON t.term_id = tt.term_id
4226           GROUP BY t.term_id
4227           HAVING term_tt_count > 1
4228           LIMIT 10"
4229      );
4230  
4231      // No more terms, we're done here.
4232      if ( ! $shared_terms ) {
4233          update_option( 'finished_splitting_shared_terms', true );
4234          delete_option( $lock_name );
4235          return;
4236      }
4237  
4238      // Shared terms found? We'll need to run this script again.
4239      wp_schedule_single_event( time() + ( 2 * MINUTE_IN_SECONDS ), 'wp_split_shared_term_batch' );
4240  
4241      // Rekey shared term array for faster lookups.
4242      $_shared_terms = array();
4243      foreach ( $shared_terms as $shared_term ) {
4244          $term_id                   = (int) $shared_term->term_id;
4245          $_shared_terms[ $term_id ] = $shared_term;
4246      }
4247      $shared_terms = $_shared_terms;
4248  
4249      // Get term taxonomy data for all shared terms.
4250      $shared_term_ids = implode( ',', array_keys( $shared_terms ) );
4251      $shared_tts      = $wpdb->get_results( "SELECT * FROM {$wpdb->term_taxonomy} WHERE `term_id` IN ({$shared_term_ids})" );
4252  
4253      // Split term data recording is slow, so we do it just once, outside the loop.
4254      $split_term_data    = get_option( '_split_terms', array() );
4255      $skipped_first_term = array();
4256      $taxonomies         = array();
4257      foreach ( $shared_tts as $shared_tt ) {
4258          $term_id = (int) $shared_tt->term_id;
4259  
4260          // Don't split the first tt belonging to a given term_id.
4261          if ( ! isset( $skipped_first_term[ $term_id ] ) ) {
4262              $skipped_first_term[ $term_id ] = 1;
4263              continue;
4264          }
4265  
4266          if ( ! isset( $split_term_data[ $term_id ] ) ) {
4267              $split_term_data[ $term_id ] = array();
4268          }
4269  
4270          // Keep track of taxonomies whose hierarchies need flushing.
4271          if ( ! isset( $taxonomies[ $shared_tt->taxonomy ] ) ) {
4272              $taxonomies[ $shared_tt->taxonomy ] = 1;
4273          }
4274  
4275          // Split the term.
4276          $split_term_data[ $term_id ][ $shared_tt->taxonomy ] = _split_shared_term( $shared_terms[ $term_id ], $shared_tt, false );
4277      }
4278  
4279      // Rebuild the cached hierarchy for each affected taxonomy.
4280      foreach ( array_keys( $taxonomies ) as $tax ) {
4281          delete_option( "{$tax}_children" );
4282          _get_term_hierarchy( $tax );
4283      }
4284  
4285      update_option( '_split_terms', $split_term_data );
4286  
4287      delete_option( $lock_name );
4288  }
4289  
4290  /**
4291   * In order to avoid the _wp_batch_split_terms() job being accidentally removed,
4292   * check that it's still scheduled while we haven't finished splitting terms.
4293   *
4294   * @ignore
4295   * @since 4.3.0
4296   */
4297  function _wp_check_for_scheduled_split_terms() {
4298      if ( ! get_option( 'finished_splitting_shared_terms' ) && ! wp_next_scheduled( 'wp_split_shared_term_batch' ) ) {
4299          wp_schedule_single_event( time() + MINUTE_IN_SECONDS, 'wp_split_shared_term_batch' );
4300      }
4301  }
4302  
4303  /**
4304   * Check default categories when a term gets split to see if any of them need to be updated.
4305   *
4306   * @ignore
4307   * @since 4.2.0
4308   *
4309   * @param int    $term_id          ID of the formerly shared term.
4310   * @param int    $new_term_id      ID of the new term created for the $term_taxonomy_id.
4311   * @param int    $term_taxonomy_id ID for the term_taxonomy row affected by the split.
4312   * @param string $taxonomy         Taxonomy for the split term.
4313   */
4314  function _wp_check_split_default_terms( $term_id, $new_term_id, $term_taxonomy_id, $taxonomy ) {
4315      if ( 'category' !== $taxonomy ) {
4316          return;
4317      }
4318  
4319      foreach ( array( 'default_category', 'default_link_category', 'default_email_category' ) as $option ) {
4320          if ( (int) get_option( $option, -1 ) === $term_id ) {
4321              update_option( $option, $new_term_id );
4322          }
4323      }
4324  }
4325  
4326  /**
4327   * Check menu items when a term gets split to see if any of them need to be updated.
4328   *
4329   * @ignore
4330   * @since 4.2.0
4331   *
4332   * @global wpdb $wpdb WordPress database abstraction object.
4333   *
4334   * @param int    $term_id          ID of the formerly shared term.
4335   * @param int    $new_term_id      ID of the new term created for the $term_taxonomy_id.
4336   * @param int    $term_taxonomy_id ID for the term_taxonomy row affected by the split.
4337   * @param string $taxonomy         Taxonomy for the split term.
4338   */
4339  function _wp_check_split_terms_in_menus( $term_id, $new_term_id, $term_taxonomy_id, $taxonomy ) {
4340      global $wpdb;
4341      $post_ids = $wpdb->get_col(
4342          $wpdb->prepare(
4343              "SELECT m1.post_id
4344          FROM {$wpdb->postmeta} AS m1
4345              INNER JOIN {$wpdb->postmeta} AS m2 ON ( m2.post_id = m1.post_id )
4346              INNER JOIN {$wpdb->postmeta} AS m3 ON ( m3.post_id = m1.post_id )
4347          WHERE ( m1.meta_key = '_menu_item_type' AND m1.meta_value = 'taxonomy' )
4348              AND ( m2.meta_key = '_menu_item_object' AND m2.meta_value = %s )
4349              AND ( m3.meta_key = '_menu_item_object_id' AND m3.meta_value = %d )",
4350              $taxonomy,
4351              $term_id
4352          )
4353      );
4354  
4355      if ( $post_ids ) {
4356          foreach ( $post_ids as $post_id ) {
4357              update_post_meta( $post_id, '_menu_item_object_id', $new_term_id, $term_id );
4358          }
4359      }
4360  }
4361  
4362  /**
4363   * If the term being split is a nav_menu, change associations.
4364   *
4365   * @ignore
4366   * @since 4.3.0
4367   *
4368   * @param int    $term_id          ID of the formerly shared term.
4369   * @param int    $new_term_id      ID of the new term created for the $term_taxonomy_id.
4370   * @param int    $term_taxonomy_id ID for the term_taxonomy row affected by the split.
4371   * @param string $taxonomy         Taxonomy for the split term.
4372   */
4373  function _wp_check_split_nav_menu_terms( $term_id, $new_term_id, $term_taxonomy_id, $taxonomy ) {
4374      if ( 'nav_menu' !== $taxonomy ) {
4375          return;
4376      }
4377  
4378      // Update menu locations.
4379      $locations = get_nav_menu_locations();
4380      foreach ( $locations as $location => $menu_id ) {
4381          if ( $term_id === $menu_id ) {
4382              $locations[ $location ] = $new_term_id;
4383          }
4384      }
4385      set_theme_mod( 'nav_menu_locations', $locations );
4386  }
4387  
4388  /**
4389   * Get data about terms that previously shared a single term_id, but have since been split.
4390   *
4391   * @since 4.2.0
4392   *
4393   * @param int $old_term_id Term ID. This is the old, pre-split term ID.
4394   * @return array Array of new term IDs, keyed by taxonomy.
4395   */
4396  function wp_get_split_terms( $old_term_id ) {
4397      $split_terms = get_option( '_split_terms', array() );
4398  
4399      $terms = array();
4400      if ( isset( $split_terms[ $old_term_id ] ) ) {
4401          $terms = $split_terms[ $old_term_id ];
4402      }
4403  
4404      return $terms;
4405  }
4406  
4407  /**
4408   * Get the new term ID corresponding to a previously split term.
4409   *
4410   * @since 4.2.0
4411   *
4412   * @param int    $old_term_id Term ID. This is the old, pre-split term ID.
4413   * @param string $taxonomy    Taxonomy that the term belongs to.
4414   * @return int|false If a previously split term is found corresponding to the old term_id and taxonomy,
4415   *                   the new term_id will be returned. If no previously split term is found matching
4416   *                   the parameters, returns false.
4417   */
4418  function wp_get_split_term( $old_term_id, $taxonomy ) {
4419      $split_terms = wp_get_split_terms( $old_term_id );
4420  
4421      $term_id = false;
4422      if ( isset( $split_terms[ $taxonomy ] ) ) {
4423          $term_id = (int) $split_terms[ $taxonomy ];
4424      }
4425  
4426      return $term_id;
4427  }
4428  
4429  /**
4430   * Determine whether a term is shared between multiple taxonomies.
4431   *
4432   * Shared taxonomy terms began to be split in 4.3, but failed cron tasks or
4433   * other delays in upgrade routines may cause shared terms to remain.
4434   *
4435   * @since 4.4.0
4436   *
4437   * @param int $term_id Term ID.
4438   * @return bool Returns false if a term is not shared between multiple taxonomies or
4439   *              if splitting shared taxonomy terms is finished.
4440   */
4441  function wp_term_is_shared( $term_id ) {
4442      global $wpdb;
4443  
4444      if ( get_option( 'finished_splitting_shared_terms' ) ) {
4445          return false;
4446      }
4447  
4448      $tt_count = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_taxonomy WHERE term_id = %d", $term_id ) );
4449  
4450      return $tt_count > 1;
4451  }
4452  
4453  /**
4454   * Generate a permalink for a taxonomy term archive.
4455   *
4456   * @since 2.5.0
4457   *
4458   * @global WP_Rewrite $wp_rewrite WordPress rewrite component.
4459   *
4460   * @param WP_Term|int|string $term     The term object, ID, or slug whose link will be retrieved.
4461   * @param string             $taxonomy Optional. Taxonomy. Default empty.
4462   * @return string|WP_Error URL of the taxonomy term archive on success, WP_Error if term does not exist.
4463   */
4464  function get_term_link( $term, $taxonomy = '' ) {
4465      global $wp_rewrite;
4466  
4467      if ( ! is_object( $term ) ) {
4468          if ( is_int( $term ) ) {
4469              $term = get_term( $term, $taxonomy );
4470          } else {
4471              $term = get_term_by( 'slug', $term, $taxonomy );
4472          }
4473      }
4474  
4475      if ( ! is_object( $term ) ) {
4476          $term = new WP_Error( 'invalid_term', __( 'Empty Term.' ) );
4477      }
4478  
4479      if ( is_wp_error( $term ) ) {
4480          return $term;
4481      }
4482  
4483      $taxonomy = $term->taxonomy;
4484  
4485      $termlink = $wp_rewrite->get_extra_permastruct( $taxonomy );
4486  
4487      /**
4488       * Filters the permalink structure for a term before token replacement occurs.
4489       *
4490       * @since 4.9.0
4491       *
4492       * @param string  $termlink The permalink structure for the term's taxonomy.
4493       * @param WP_Term $term     The term object.
4494       */
4495      $termlink = apply_filters( 'pre_term_link', $termlink, $term );
4496  
4497      $slug = $term->slug;
4498      $t    = get_taxonomy( $taxonomy );
4499  
4500      if ( empty( $termlink ) ) {
4501          if ( 'category' === $taxonomy ) {
4502              $termlink = '?cat=' . $term->term_id;
4503          } elseif ( $t->query_var ) {
4504              $termlink = "?$t->query_var=$slug";
4505          } else {
4506              $termlink = "?taxonomy=$taxonomy&term=$slug";
4507          }
4508          $termlink = home_url( $termlink );
4509      } else {
4510          if ( ! empty( $t->rewrite['hierarchical'] ) ) {
4511              $hierarchical_slugs = array();
4512              $ancestors          = get_ancestors( $term->term_id, $taxonomy, 'taxonomy' );
4513              foreach ( (array) $ancestors as $ancestor ) {
4514                  $ancestor_term        = get_term( $ancestor, $taxonomy );
4515                  $hierarchical_slugs[] = $ancestor_term->slug;
4516              }
4517              $hierarchical_slugs   = array_reverse( $hierarchical_slugs );
4518              $hierarchical_slugs[] = $slug;
4519              $termlink             = str_replace( "%$taxonomy%", implode( '/', $hierarchical_slugs ), $termlink );
4520          } else {
4521              $termlink = str_replace( "%$taxonomy%", $slug, $termlink );
4522          }
4523          $termlink = home_url( user_trailingslashit( $termlink, 'category' ) );
4524      }
4525  
4526      // Back compat filters.
4527      if ( 'post_tag' === $taxonomy ) {
4528  
4529          /**
4530           * Filters the tag link.
4531           *
4532           * @since 2.3.0
4533           * @since 2.5.0 Deprecated in favor of {@see 'term_link'} filter.
4534           * @since 5.4.1 Restored (un-deprecated).
4535           *
4536           * @param string $termlink Tag link URL.
4537           * @param int    $term_id  Term ID.
4538           */
4539          $termlink = apply_filters( 'tag_link', $termlink, $term->term_id );
4540      } elseif ( 'category' === $taxonomy ) {
4541  
4542          /**
4543           * Filters the category link.
4544           *
4545           * @since 1.5.0
4546           * @since 2.5.0 Deprecated in favor of {@see 'term_link'} filter.
4547           * @since 5.4.1 Restored (un-deprecated).
4548           *
4549           * @param string $termlink Category link URL.
4550           * @param int    $term_id  Term ID.
4551           */
4552          $termlink = apply_filters( 'category_link', $termlink, $term->term_id );
4553      }
4554  
4555      /**
4556       * Filters the term link.
4557       *
4558       * @since 2.5.0
4559       *
4560       * @param string  $termlink Term link URL.
4561       * @param WP_Term $term     Term object.
4562       * @param string  $taxonomy Taxonomy slug.
4563       */
4564      return apply_filters( 'term_link', $termlink, $term, $taxonomy );
4565  }
4566  
4567  /**
4568   * Display the taxonomies of a post with available options.
4569   *
4570   * This function can be used within the loop to display the taxonomies for a
4571   * post without specifying the Post ID. You can also use it outside the Loop to
4572   * display the taxonomies for a specific post.
4573   *
4574   * @since 2.5.0
4575   *
4576   * @param array $args {
4577   *     Arguments about which post to use and how to format the output. Shares all of the arguments
4578   *     supported by get_the_taxonomies(), in addition to the following.
4579   *
4580   *     @type  int|WP_Post $post   Post ID or object to get taxonomies of. Default current post.
4581   *     @type  string      $before Displays before the taxonomies. Default empty string.
4582   *     @type  string      $sep    Separates each taxonomy. Default is a space.
4583   *     @type  string      $after  Displays after the taxonomies. Default empty string.
4584   * }
4585   */
4586  function the_taxonomies( $args = array() ) {
4587      $defaults = array(
4588          'post'   => 0,
4589          'before' => '',
4590          'sep'    => ' ',
4591          'after'  => '',
4592      );
4593  
4594      $parsed_args = wp_parse_args( $args, $defaults );
4595  
4596      echo $parsed_args['before'] . implode( $parsed_args['sep'], get_the_taxonomies( $parsed_args['post'], $parsed_args ) ) . $parsed_args['after'];
4597  }
4598  
4599  /**
4600   * Retrieve all taxonomies associated with a post.
4601   *
4602   * This function can be used within the loop. It will also return an array of
4603   * the taxonomies with links to the taxonomy and name.
4604   *
4605   * @since 2.5.0
4606   *
4607   * @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post.
4608   * @param array       $args {
4609   *           Optional. Arguments about how to format the list of taxonomies. Default empty array.
4610   *
4611   *     @type string $template      Template for displaying a taxonomy label and list of terms.
4612   *                                 Default is "Label: Terms."
4613   *     @type string $term_template Template for displaying a single term in the list. Default is the term name
4614   *                                 linked to its archive.
4615   * }
4616   * @return array List of taxonomies.
4617   */
4618  function get_the_taxonomies( $post = 0, $args = array() ) {
4619      $post = get_post( $post );
4620  
4621      $args = wp_parse_args(
4622          $args,
4623          array(
4624              /* translators: %s: Taxonomy label, %l: List of terms formatted as per $term_template. */
4625              'template'      => __( '%s: %l.' ),
4626              'term_template' => '<a href="%1$s">%2$s</a>',
4627          )
4628      );
4629  
4630      $taxonomies = array();
4631  
4632      if ( ! $post ) {
4633          return $taxonomies;
4634      }
4635  
4636      foreach ( get_object_taxonomies( $post ) as $taxonomy ) {
4637          $t = (array) get_taxonomy( $taxonomy );
4638          if ( empty( $t['label'] ) ) {
4639              $t['label'] = $taxonomy;
4640          }
4641          if ( empty( $t['args'] ) ) {
4642              $t['args'] = array();
4643          }
4644          if ( empty( $t['template'] ) ) {
4645              $t['template'] = $args['template'];
4646          }
4647          if ( empty( $t['term_template'] ) ) {
4648              $t['term_template'] = $args['term_template'];
4649          }
4650  
4651          $terms = get_object_term_cache( $post->ID, $taxonomy );
4652          if ( false === $terms ) {
4653              $terms = wp_get_object_terms( $post->ID, $taxonomy, $t['args'] );
4654          }
4655          $links = array();
4656  
4657          foreach ( $terms as $term ) {
4658              $links[] = wp_sprintf( $t['term_template'], esc_attr( get_term_link( $term ) ), $term->name );
4659          }
4660          if ( $links ) {
4661              $taxonomies[ $taxonomy ] = wp_sprintf( $t['template'], $t['label'], $links, $terms );
4662          }
4663      }
4664      return $taxonomies;
4665  }
4666  
4667  /**
4668   * Retrieve all taxonomy names for the given post.
4669   *
4670   * @since 2.5.0
4671   *
4672   * @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post.
4673   * @return string[] An array of all taxonomy names for the given post.
4674   */
4675  function get_post_taxonomies( $post = 0 ) {
4676      $post = get_post( $post );
4677  
4678      return get_object_taxonomies( $post );
4679  }
4680  
4681  /**
4682   * Determine if the given object is associated with any of the given terms.
4683   *
4684   * The given terms are checked against the object's terms' term_ids, names and slugs.
4685   * Terms given as integers will only be checked against the object's terms' term_ids.
4686   * If no terms are given, determines if object is associated with any terms in the given taxonomy.
4687   *
4688   * @since 2.7.0
4689   *
4690   * @param int                       $object_id ID of the object (post ID, link ID, ...).
4691   * @param string                    $taxonomy  Single taxonomy name.
4692   * @param int|string|int[]|string[] $terms     Optional. Term ID, name, slug, or array of such
4693   *                                             to check against. Default null.
4694   * @return bool|WP_Error WP_Error on input error.
4695   */
4696  function is_object_in_term( $object_id, $taxonomy, $terms = null ) {
4697      $object_id = (int) $object_id;
4698      if ( ! $object_id ) {
4699          return new WP_Error( 'invalid_object', __( 'Invalid object ID.' ) );
4700      }
4701  
4702      $object_terms = get_object_term_cache( $object_id, $taxonomy );
4703      if ( false === $object_terms ) {
4704          $object_terms = wp_get_object_terms( $object_id, $taxonomy, array( 'update_term_meta_cache' => false ) );
4705          if ( is_wp_error( $object_terms ) ) {
4706              return $object_terms;
4707          }
4708  
4709          wp_cache_set( $object_id, wp_list_pluck( $object_terms, 'term_id' ), "{$taxonomy}_relationships" );
4710      }
4711  
4712      if ( is_wp_error( $object_terms ) ) {
4713          return $object_terms;
4714      }
4715      if ( empty( $object_terms ) ) {
4716          return false;
4717      }
4718      if ( empty( $terms ) ) {
4719          return ( ! empty( $object_terms ) );
4720      }
4721  
4722      $terms = (array) $terms;
4723  
4724      $ints = array_filter( $terms, 'is_int' );
4725      if ( $ints ) {
4726          $strs = array_diff( $terms, $ints );
4727      } else {
4728          $strs =& $terms;
4729      }
4730  
4731      foreach ( $object_terms as $object_term ) {
4732          // If term is an int, check against term_ids only.
4733          if ( $ints && in_array( $object_term->term_id, $ints, true ) ) {
4734              return true;
4735          }
4736  
4737          if ( $strs ) {
4738              // Only check numeric strings against term_id, to avoid false matches due to type juggling.
4739              $numeric_strs = array_map( 'intval', array_filter( $strs, 'is_numeric' ) );
4740              if ( in_array( $object_term->term_id, $numeric_strs, true ) ) {
4741                  return true;
4742              }
4743  
4744              if ( in_array( $object_term->name, $strs, true ) ) {
4745                  return true;
4746              }
4747              if ( in_array( $object_term->slug, $strs, true ) ) {
4748                  return true;
4749              }
4750          }
4751      }
4752  
4753      return false;
4754  }
4755  
4756  /**
4757   * Determine if the given object type is associated with the given taxonomy.
4758   *
4759   * @since 3.0.0
4760   *
4761   * @param string $object_type Object type string.
4762   * @param string $taxonomy    Single taxonomy name.
4763   * @return bool True if object is associated with the taxonomy, otherwise false.
4764   */
4765  function is_object_in_taxonomy( $object_type, $taxonomy ) {
4766      $taxonomies = get_object_taxonomies( $object_type );
4767      if ( empty( $taxonomies ) ) {
4768          return false;
4769      }
4770      return in_array( $taxonomy, $taxonomies, true );
4771  }
4772  
4773  /**
4774   * Get an array of ancestor IDs for a given object.
4775   *
4776   * @since 3.1.0
4777   * @since 4.1.0 Introduced the `$resource_type` argument.
4778   *
4779   * @param int    $object_id     Optional. The ID of the object. Default 0.
4780   * @param string $object_type   Optional. The type of object for which we'll be retrieving
4781   *                              ancestors. Accepts a post type or a taxonomy name. Default empty.
4782   * @param string $resource_type Optional. Type of resource $object_type is. Accepts 'post_type'
4783   *                              or 'taxonomy'. Default empty.
4784   * @return int[] An array of IDs of ancestors from lowest to highest in the hierarchy.
4785   */
4786  function get_ancestors( $object_id = 0, $object_type = '', $resource_type = '' ) {
4787      $object_id = (int) $object_id;
4788  
4789      $ancestors = array();
4790  
4791      if ( empty( $object_id ) ) {
4792  
4793          /** This filter is documented in wp-includes/taxonomy.php */
4794          return apply_filters( 'get_ancestors', $ancestors, $object_id, $object_type, $resource_type );
4795      }
4796  
4797      if ( ! $resource_type ) {
4798          if ( is_taxonomy_hierarchical( $object_type ) ) {
4799              $resource_type = 'taxonomy';
4800          } elseif ( post_type_exists( $object_type ) ) {
4801              $resource_type = 'post_type';
4802          }
4803      }
4804  
4805      if ( 'taxonomy' === $resource_type ) {
4806          $term = get_term( $object_id, $object_type );
4807          while ( ! is_wp_error( $term ) && ! empty( $term->parent ) && ! in_array( $term->parent, $ancestors, true ) ) {
4808              $ancestors[] = (int) $term->parent;
4809              $term        = get_term( $term->parent, $object_type );
4810          }
4811      } elseif ( 'post_type' === $resource_type ) {
4812          $ancestors = get_post_ancestors( $object_id );
4813      }
4814  
4815      /**
4816       * Filters a given object's ancestors.
4817       *
4818       * @since 3.1.0
4819       * @since 4.1.1 Introduced the `$resource_type` parameter.
4820       *
4821       * @param int[]  $ancestors     An array of IDs of object ancestors.
4822       * @param int    $object_id     Object ID.
4823       * @param string $object_type   Type of object.
4824       * @param string $resource_type Type of resource $object_type is.
4825       */
4826      return apply_filters( 'get_ancestors', $ancestors, $object_id, $object_type, $resource_type );
4827  }
4828  
4829  /**
4830   * Returns the term's parent's term_ID.
4831   *
4832   * @since 3.1.0
4833   *
4834   * @param int    $term_id  Term ID.
4835   * @param string $taxonomy Taxonomy name.
4836   * @return int|false Parent term ID on success, false on failure.
4837   */
4838  function wp_get_term_taxonomy_parent_id( $term_id, $taxonomy ) {
4839      $term = get_term( $term_id, $taxonomy );
4840      if ( ! $term || is_wp_error( $term ) ) {
4841          return false;
4842      }
4843      return (int) $term->parent;
4844  }
4845  
4846  /**
4847   * Checks the given subset of the term hierarchy for hierarchy loops.
4848   * Prevents loops from forming and breaks those that it finds.
4849   *
4850   * Attached to the {@see 'wp_update_term_parent'} filter.
4851   *
4852   * @since 3.1.0
4853   *
4854   * @param int    $parent   `term_id` of the parent for the term we're checking.
4855   * @param int    $term_id  The term we're checking.
4856   * @param string $taxonomy The taxonomy of the term we're checking.
4857   * @return int The new parent for the term.
4858   */
4859  function wp_check_term_hierarchy_for_loops( $parent, $term_id, $taxonomy ) {
4860      // Nothing fancy here - bail.
4861      if ( ! $parent ) {
4862          return 0;
4863      }
4864  
4865      // Can't be its own parent.
4866      if ( $parent === $term_id ) {
4867          return 0;
4868      }
4869  
4870      // Now look for larger loops.
4871