WordPress.org

Make WordPress Core

Changeset 37572


Ignore:
Timestamp:
05/26/16 04:32:30 (11 months ago)
Author:
boonebgorges
Message:

Introduce WP_Term_Query and use in get_terms().

WP_Term_Query is modeled on existing query classes, such as those used
for comments and users. It provides a more consistent structure for generating
term queries, and should make it easier to add new functionality in the future.

Props flixos90, boonebgorges.
See #35381.

Location:
trunk/src
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/wp-includes/taxonomy.php

    r37567 r37572  
    11751175    global $wpdb; 
    11761176 
    1177     $defaults = array( 
    1178         'taxonomy'               => null, 
    1179         'orderby'                => 'name', 
    1180         'order'                  => 'ASC', 
    1181         'hide_empty'             => true, 
    1182         'include'                => array(), 
    1183         'exclude'                => array(), 
    1184         'exclude_tree'           => array(), 
    1185         'number'                 => '', 
    1186         'offset'                 => '', 
    1187         'fields'                 => 'all', 
    1188         'name'                   => '', 
    1189         'slug'                   => '', 
    1190         'hierarchical'           => true, 
    1191         'search'                 => '', 
    1192         'name__like'             => '', 
    1193         'description__like'      => '', 
    1194         'pad_counts'             => false, 
    1195         'get'                    => '', 
    1196         'child_of'               => 0, 
    1197         'parent'                 => '', 
    1198         'childless'              => false, 
    1199         'cache_domain'           => 'core', 
    1200         'update_term_meta_cache' => true, 
    1201         'meta_query'             => '' 
    1202     ); 
     1177    $term_query = new WP_Term_Query(); 
    12031178 
    12041179    /* 
     
    12091184     * (b) the first parameter shares no keys with the default array (ie, it's a list of taxonomies) 
    12101185     */ 
    1211     $key_intersect  = array_intersect_key( $defaults, (array) $args ); 
     1186    $key_intersect  = array_intersect_key( $term_query->query_var_defaults, (array) $args ); 
    12121187    $do_legacy_args = $deprecated || empty( $key_intersect ); 
    12131188 
    1214     $taxonomies = null; 
    12151189    if ( $do_legacy_args ) { 
    12161190        $taxonomies = (array) $args; 
    12171191        $args = $deprecated; 
     1192        $args['taxonomy'] = $taxonomies; 
    12181193    } elseif ( isset( $args['taxonomy'] ) && null !== $args['taxonomy'] ) { 
    1219         $taxonomies = (array) $args['taxonomy']; 
    1220         unset( $args['taxonomy'] ); 
     1194        $args['taxonomy'] = (array) $args['taxonomy']; 
    12211195    } 
    12221196 
    12231197    $empty_array = array(); 
    12241198 
    1225     if ( $taxonomies ) { 
    1226         foreach ( $taxonomies as $taxonomy ) { 
    1227             if ( ! taxonomy_exists($taxonomy) ) { 
     1199    if ( ! empty( $args['taxonomy'] ) ) { 
     1200        foreach ( $args['taxonomy'] as $taxonomy ) { 
     1201            if ( ! taxonomy_exists( $taxonomy ) ) { 
    12281202                return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy' ) ); 
    12291203            } 
     
    12311205    } 
    12321206 
     1207    $terms = $term_query->query( $args ); 
     1208 
     1209    $taxonomies = isset( $args['taxonomy'] ) ? (array) $args['taxonomy'] : null; 
     1210 
    12331211    /** 
    1234      * Filters the terms query default arguments. 
    1235      * 
    1236      * Use {@see 'get_terms_args'} to filter the passed arguments. 
    1237      * 
    1238      * @since 4.4.0 
    1239      * 
    1240      * @param array $defaults   An array of default get_terms() arguments. 
    1241      * @param array $taxonomies An array of taxonomies. 
     1212     * Filters the found terms. 
     1213     * 
     1214     * @since 2.3.0 
     1215     * @since 4.6.0 Added `$term_query`. 
     1216     * 
     1217     * @param array         $terms      Array of found terms. 
     1218     * @param array         $taxonomies An array of taxonomies. 
     1219     * @param array         $args       An array of get_terms() arguments. 
     1220     * @param WP_Term_Query $term_query The WP_Term_Query object. 
    12421221     */ 
    1243     $args = wp_parse_args( $args, apply_filters( 'get_terms_defaults', $defaults, $taxonomies ) ); 
    1244  
    1245     $args['number'] = absint( $args['number'] ); 
    1246     $args['offset'] = absint( $args['offset'] ); 
    1247  
    1248     // Save queries by not crawling the tree in the case of multiple taxes or a flat tax. 
    1249     $has_hierarchical_tax = false; 
    1250     if ( $taxonomies ) { 
    1251         foreach ( $taxonomies as $_tax ) { 
    1252             if ( is_taxonomy_hierarchical( $_tax ) ) { 
    1253                 $has_hierarchical_tax = true; 
    1254             } 
    1255         } 
    1256     } 
    1257  
    1258     if ( ! $has_hierarchical_tax ) { 
    1259         $args['hierarchical'] = false; 
    1260         $args['pad_counts'] = false; 
    1261     } 
    1262  
    1263     // 'parent' overrides 'child_of'. 
    1264     if ( 0 < intval( $args['parent'] ) ) { 
    1265         $args['child_of'] = false; 
    1266     } 
    1267  
    1268     if ( 'all' == $args['get'] ) { 
    1269         $args['childless'] = false; 
    1270         $args['child_of'] = 0; 
    1271         $args['hide_empty'] = 0; 
    1272         $args['hierarchical'] = false; 
    1273         $args['pad_counts'] = false; 
    1274     } 
    1275  
    1276     /** 
    1277      * Filters the terms query arguments. 
    1278      * 
    1279      * @since 3.1.0 
    1280      * 
    1281      * @param array $args       An array of get_terms() arguments. 
    1282      * @param array $taxonomies An array of taxonomies. 
    1283      */ 
    1284     $args = apply_filters( 'get_terms_args', $args, $taxonomies ); 
    1285  
    1286     // Avoid the query if the queried parent/child_of term has no descendants. 
    1287     $child_of = $args['child_of']; 
    1288     $parent   = $args['parent']; 
    1289  
    1290     if ( $child_of ) { 
    1291         $_parent = $child_of; 
    1292     } elseif ( $parent ) { 
    1293         $_parent = $parent; 
    1294     } else { 
    1295         $_parent = false; 
    1296     } 
    1297  
    1298     if ( $_parent ) { 
    1299         $in_hierarchy = false; 
    1300         foreach ( $taxonomies as $_tax ) { 
    1301             $hierarchy = _get_term_hierarchy( $_tax ); 
    1302  
    1303             if ( isset( $hierarchy[ $_parent ] ) ) { 
    1304                 $in_hierarchy = true; 
    1305             } 
    1306         } 
    1307  
    1308         if ( ! $in_hierarchy ) { 
    1309             return $empty_array; 
    1310         } 
    1311     } 
    1312  
    1313     $_orderby = strtolower( $args['orderby'] ); 
    1314     if ( 'count' == $_orderby ) { 
    1315         $orderby = 'tt.count'; 
    1316     } elseif ( 'name' == $_orderby ) { 
    1317         $orderby = 't.name'; 
    1318     } elseif ( 'slug' == $_orderby ) { 
    1319         $orderby = 't.slug'; 
    1320     } elseif ( 'include' == $_orderby && ! empty( $args['include'] ) ) { 
    1321         $include = implode( ',', array_map( 'absint', $args['include'] ) ); 
    1322         $orderby = "FIELD( t.term_id, $include )"; 
    1323     } elseif ( 'term_group' == $_orderby ) { 
    1324         $orderby = 't.term_group'; 
    1325     } elseif ( 'description' == $_orderby ) { 
    1326         $orderby = 'tt.description'; 
    1327     } elseif ( 'none' == $_orderby ) { 
    1328         $orderby = ''; 
    1329     } elseif ( empty( $_orderby ) || 'id' == $_orderby || 'term_id' === $_orderby ) { 
    1330         $orderby = 't.term_id'; 
    1331     } else { 
    1332         $orderby = 't.name'; 
    1333     } 
    1334  
    1335     /** 
    1336      * Filters the ORDERBY clause of the terms query. 
    1337      * 
    1338      * @since 2.8.0 
    1339      * 
    1340      * @param string $orderby    `ORDERBY` clause of the terms query. 
    1341      * @param array  $args       An array of terms query arguments. 
    1342      * @param array  $taxonomies An array of taxonomies. 
    1343      */ 
    1344     $orderby = apply_filters( 'get_terms_orderby', $orderby, $args, $taxonomies ); 
    1345  
    1346     $order = strtoupper( $args['order'] ); 
    1347     if ( ! empty( $orderby ) ) { 
    1348         $orderby = "ORDER BY $orderby"; 
    1349     } else { 
    1350         $order = ''; 
    1351     } 
    1352  
    1353     if ( '' !== $order && ! in_array( $order, array( 'ASC', 'DESC' ) ) ) { 
    1354         $order = 'ASC'; 
    1355     } 
    1356  
    1357     $where_conditions = array(); 
    1358  
    1359     if ( $taxonomies ) { 
    1360         $where_conditions[] = "tt.taxonomy IN ('" . implode("', '", array_map( 'esc_sql', $taxonomies ) ) . "')"; 
    1361     } 
    1362  
    1363     $exclude = $args['exclude']; 
    1364     $exclude_tree = $args['exclude_tree']; 
    1365     $include = $args['include']; 
    1366  
    1367     $inclusions = ''; 
    1368     if ( ! empty( $include ) ) { 
    1369         $exclude = ''; 
    1370         $exclude_tree = ''; 
    1371         $inclusions = implode( ',', wp_parse_id_list( $include ) ); 
    1372     } 
    1373  
    1374     if ( ! empty( $inclusions ) ) { 
    1375         $where_conditions[] = 't.term_id IN ( ' . $inclusions . ' )'; 
    1376     } 
    1377  
    1378     $exclusions = array(); 
    1379     if ( ! empty( $exclude_tree ) ) { 
    1380         $exclude_tree = wp_parse_id_list( $exclude_tree ); 
    1381         $excluded_children = $exclude_tree; 
    1382         foreach ( $exclude_tree as $extrunk ) { 
    1383             $excluded_children = array_merge( 
    1384                 $excluded_children, 
    1385                 (array) get_terms( $taxonomies[0], array( 'child_of' => intval( $extrunk ), 'fields' => 'ids', 'hide_empty' => 0 ) ) 
    1386             ); 
    1387         } 
    1388         $exclusions = array_merge( $excluded_children, $exclusions ); 
    1389     } 
    1390  
    1391     if ( ! empty( $exclude ) ) { 
    1392         $exclusions = array_merge( wp_parse_id_list( $exclude ), $exclusions ); 
    1393     } 
    1394  
    1395     // 'childless' terms are those without an entry in the flattened term hierarchy. 
    1396     $childless = (bool) $args['childless']; 
    1397     if ( $childless ) { 
    1398         foreach ( $taxonomies as $_tax ) { 
    1399             $term_hierarchy = _get_term_hierarchy( $_tax ); 
    1400             $exclusions = array_merge( array_keys( $term_hierarchy ), $exclusions ); 
    1401         } 
    1402     } 
    1403  
    1404     if ( ! empty( $exclusions ) ) { 
    1405         $exclusions = 't.term_id NOT IN (' . implode( ',', array_map( 'intval', $exclusions ) ) . ')'; 
    1406     } else { 
    1407         $exclusions = ''; 
    1408     } 
    1409  
    1410     /** 
    1411      * Filters the terms to exclude from the terms query. 
    1412      * 
    1413      * @since 2.3.0 
    1414      * 
    1415      * @param string $exclusions `NOT IN` clause of the terms query. 
    1416      * @param array  $args       An array of terms query arguments. 
    1417      * @param array  $taxonomies An array of taxonomies. 
    1418      */ 
    1419     $exclusions = apply_filters( 'list_terms_exclusions', $exclusions, $args, $taxonomies ); 
    1420  
    1421     if ( ! empty( $exclusions ) ) { 
    1422         // Must do string manipulation here for backward compatibility with filter. 
    1423         $where_conditions[] = preg_replace( '/^\s*AND\s*/', '', $exclusions ); 
    1424     } 
    1425  
    1426     if ( ! empty( $args['name'] ) ) { 
    1427         $names = (array) $args['name']; 
    1428         foreach ( $names as &$_name ) { 
    1429             // `sanitize_term_field()` returns slashed data. 
    1430             $_name = stripslashes( sanitize_term_field( 'name', $_name, 0, reset( $taxonomies ), 'db' ) ); 
    1431         } 
    1432  
    1433         $where_conditions[] = "t.name IN ('" . implode( "', '", array_map( 'esc_sql', $names ) ) . "')"; 
    1434     } 
    1435  
    1436     if ( ! empty( $args['slug'] ) ) { 
    1437         if ( is_array( $args['slug'] ) ) { 
    1438             $slug = array_map( 'sanitize_title', $args['slug'] ); 
    1439             $where_conditions[] = "t.slug IN ('" . implode( "', '", $slug ) . "')"; 
    1440         } else { 
    1441             $slug = sanitize_title( $args['slug'] ); 
    1442             $where_conditions[] = "t.slug = '$slug'"; 
    1443         } 
    1444     } 
    1445  
    1446     if ( ! empty( $args['name__like'] ) ) { 
    1447         $where_conditions[] = $wpdb->prepare( "t.name LIKE %s", '%' . $wpdb->esc_like( $args['name__like'] ) . '%' ); 
    1448     } 
    1449  
    1450     if ( ! empty( $args['description__like'] ) ) { 
    1451         $where_conditions[] = $wpdb->prepare( "tt.description LIKE %s", '%' . $wpdb->esc_like( $args['description__like'] ) . '%' ); 
    1452     } 
    1453  
    1454     if ( '' !== $parent ) { 
    1455         $parent = (int) $parent; 
    1456         $where_conditions[] = "tt.parent = '$parent'"; 
    1457     } 
    1458  
    1459     $hierarchical = $args['hierarchical']; 
    1460     if ( 'count' == $args['fields'] ) { 
    1461         $hierarchical = false; 
    1462     } 
    1463     if ( $args['hide_empty'] && !$hierarchical ) { 
    1464         $where_conditions[] = 'tt.count > 0'; 
    1465     } 
    1466  
    1467     $number = $args['number']; 
    1468     $offset = $args['offset']; 
    1469  
    1470     // Don't limit the query results when we have to descend the family tree. 
    1471     if ( $number && ! $hierarchical && ! $child_of && '' === $parent ) { 
    1472         if ( $offset ) { 
    1473             $limits = 'LIMIT ' . $offset . ',' . $number; 
    1474         } else { 
    1475             $limits = 'LIMIT ' . $number; 
    1476         } 
    1477     } else { 
    1478         $limits = ''; 
    1479     } 
    1480  
    1481     if ( ! empty( $args['search'] ) ) { 
    1482         $like = '%' . $wpdb->esc_like( $args['search'] ) . '%'; 
    1483         $where_conditions[] = $wpdb->prepare( '((t.name LIKE %s) OR (t.slug LIKE %s))', $like, $like ); 
    1484     } 
    1485  
    1486     // Meta query support. 
    1487     $join = ''; 
    1488     $distinct = ''; 
    1489  
    1490     $mquery = new WP_Meta_Query(); 
    1491     $mquery->parse_query_vars( $args ); 
    1492     $mq_sql = $mquery->get_sql( 'term', 't', 'term_id' ); 
    1493     $meta_clauses = $mquery->get_clauses(); 
    1494  
    1495     if ( ! empty( $meta_clauses ) ) { 
    1496         $join .= $mq_sql['join']; 
    1497         $where_conditions[] = preg_replace( '/^\s*AND\s*/', '', $mq_sql['where'] ); 
    1498         $distinct .= "DISTINCT"; 
    1499  
    1500         // 'orderby' support. 
    1501         $allowed_keys = array(); 
    1502         $primary_meta_key   = null; 
    1503         $primary_meta_query = reset( $meta_clauses ); 
    1504         if ( ! empty( $primary_meta_query['key'] ) ) { 
    1505             $primary_meta_key = $primary_meta_query['key']; 
    1506             $allowed_keys[] = $primary_meta_key; 
    1507         } 
    1508         $allowed_keys[] = 'meta_value'; 
    1509         $allowed_keys[] = 'meta_value_num'; 
    1510         $allowed_keys   = array_merge( $allowed_keys, array_keys( $meta_clauses ) ); 
    1511  
    1512         if ( ! empty( $args['orderby'] ) && in_array( $args['orderby'], $allowed_keys ) ) { 
    1513             switch( $args['orderby'] ) { 
    1514                 case $primary_meta_key: 
    1515                 case 'meta_value': 
    1516                     if ( ! empty( $primary_meta_query['type'] ) ) { 
    1517                         $orderby = "ORDER BY CAST({$primary_meta_query['alias']}.meta_value AS {$primary_meta_query['cast']})"; 
    1518                     } else { 
    1519                         $orderby = "ORDER BY {$primary_meta_query['alias']}.meta_value"; 
    1520                     } 
    1521                     break; 
    1522  
    1523                 case 'meta_value_num': 
    1524                     $orderby = "ORDER BY {$primary_meta_query['alias']}.meta_value+0"; 
    1525                     break; 
    1526  
    1527                 default: 
    1528                     if ( array_key_exists( $args['orderby'], $meta_clauses ) ) { 
    1529                         // $orderby corresponds to a meta_query clause. 
    1530                         $meta_clause = $meta_clauses[ $args['orderby'] ]; 
    1531                         $orderby = "ORDER BY CAST({$meta_clause['alias']}.meta_value AS {$meta_clause['cast']})"; 
    1532                     } 
    1533                     break; 
    1534             } 
    1535         } 
    1536     } 
    1537  
    1538     $selects = array(); 
    1539     switch ( $args['fields'] ) { 
    1540         case 'all': 
    1541             $selects = array( 't.*', 'tt.*' ); 
    1542             break; 
    1543         case 'ids': 
    1544         case 'id=>parent': 
    1545             $selects = array( 't.term_id', 'tt.parent', 'tt.count', 'tt.taxonomy' ); 
    1546             break; 
    1547         case 'names': 
    1548             $selects = array( 't.term_id', 'tt.parent', 'tt.count', 't.name', 'tt.taxonomy' ); 
    1549             break; 
    1550         case 'count': 
    1551             $orderby = ''; 
    1552             $order = ''; 
    1553             $selects = array( 'COUNT(*)' ); 
    1554             break; 
    1555         case 'id=>name': 
    1556             $selects = array( 't.term_id', 't.name', 'tt.count', 'tt.taxonomy' ); 
    1557             break; 
    1558         case 'id=>slug': 
    1559             $selects = array( 't.term_id', 't.slug', 'tt.count', 'tt.taxonomy' ); 
    1560             break; 
    1561     } 
    1562  
    1563     $_fields = $args['fields']; 
    1564  
    1565     /** 
    1566      * Filters the fields to select in the terms query. 
    1567      * 
    1568      * Field lists modified using this filter will only modify the term fields returned 
    1569      * by the function when the `$fields` parameter set to 'count' or 'all'. In all other 
    1570      * cases, the term fields in the results array will be determined by the `$fields` 
    1571      * parameter alone. 
    1572      * 
    1573      * Use of this filter can result in unpredictable behavior, and is not recommended. 
    1574      * 
    1575      * @since 2.8.0 
    1576      * 
    1577      * @param array $selects    An array of fields to select for the terms query. 
    1578      * @param array $args       An array of term query arguments. 
    1579      * @param array $taxonomies An array of taxonomies. 
    1580      */ 
    1581     $fields = implode( ', ', apply_filters( 'get_terms_fields', $selects, $args, $taxonomies ) ); 
    1582  
    1583     $join .= " INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id"; 
    1584  
    1585     $where = implode( ' AND ', $where_conditions ); 
    1586  
    1587     $pieces = array( 'fields', 'join', 'where', 'distinct', 'orderby', 'order', 'limits' ); 
    1588  
    1589     /** 
    1590      * Filters the terms query SQL clauses. 
    1591      * 
    1592      * @since 3.1.0 
    1593      * 
    1594      * @param array $pieces     Terms query SQL clauses. 
    1595      * @param array $taxonomies An array of taxonomies. 
    1596      * @param array $args       An array of terms query arguments. 
    1597      */ 
    1598     $clauses = apply_filters( 'terms_clauses', compact( $pieces ), $taxonomies, $args ); 
    1599  
    1600     $fields = isset( $clauses[ 'fields' ] ) ? $clauses[ 'fields' ] : ''; 
    1601     $join = isset( $clauses[ 'join' ] ) ? $clauses[ 'join' ] : ''; 
    1602     $where = isset( $clauses[ 'where' ] ) ? $clauses[ 'where' ] : ''; 
    1603     $distinct = isset( $clauses[ 'distinct' ] ) ? $clauses[ 'distinct' ] : ''; 
    1604     $orderby = isset( $clauses[ 'orderby' ] ) ? $clauses[ 'orderby' ] : ''; 
    1605     $order = isset( $clauses[ 'order' ] ) ? $clauses[ 'order' ] : ''; 
    1606     $limits = isset( $clauses[ 'limits' ] ) ? $clauses[ 'limits' ] : ''; 
    1607  
    1608     if ( $where ) { 
    1609         $where = "WHERE $where"; 
    1610     } 
    1611  
    1612     $query = "SELECT $distinct $fields FROM $wpdb->terms AS t $join $where $orderby $order $limits"; 
    1613  
    1614     // $args can be anything. Only use the args defined in defaults to compute the key. 
    1615     $key = md5( serialize( wp_array_slice_assoc( $args, array_keys( $defaults ) ) ) . serialize( $taxonomies ) . $query ); 
    1616     $last_changed = wp_cache_get( 'last_changed', 'terms' ); 
    1617     if ( ! $last_changed ) { 
    1618         $last_changed = microtime(); 
    1619         wp_cache_set( 'last_changed', $last_changed, 'terms' ); 
    1620     } 
    1621     $cache_key = "get_terms:$key:$last_changed"; 
    1622     $cache = wp_cache_get( $cache_key, 'terms' ); 
    1623     if ( false !== $cache ) { 
    1624         if ( 'all' === $_fields ) { 
    1625             $cache = array_map( 'get_term', $cache ); 
    1626         } 
    1627  
    1628         /** 
    1629          * Filters the given taxonomy's terms cache. 
    1630          * 
    1631          * @since 2.3.0 
    1632          * 
    1633          * @param array $cache      Cached array of terms for the given taxonomy. 
    1634          * @param array $taxonomies An array of taxonomies. 
    1635          * @param array $args       An array of get_terms() arguments. 
    1636          */ 
    1637         return apply_filters( 'get_terms', $cache, $taxonomies, $args ); 
    1638     } 
    1639  
    1640     if ( 'count' == $_fields ) { 
    1641         return $wpdb->get_var( $query ); 
    1642     } 
    1643  
    1644     $terms = $wpdb->get_results($query); 
    1645     if ( 'all' == $_fields ) { 
    1646         update_term_cache( $terms ); 
    1647     } 
    1648  
    1649     // Prime termmeta cache. 
    1650     if ( $args['update_term_meta_cache'] ) { 
    1651         $term_ids = wp_list_pluck( $terms, 'term_id' ); 
    1652         update_termmeta_cache( $term_ids ); 
    1653     } 
    1654  
    1655     if ( empty($terms) ) { 
    1656         wp_cache_add( $cache_key, array(), 'terms', DAY_IN_SECONDS ); 
    1657  
    1658         /** This filter is documented in wp-includes/taxonomy.php */ 
    1659         return apply_filters( 'get_terms', array(), $taxonomies, $args ); 
    1660     } 
    1661  
    1662     if ( $child_of ) { 
    1663         foreach ( $taxonomies as $_tax ) { 
    1664             $children = _get_term_hierarchy( $_tax ); 
    1665             if ( ! empty( $children ) ) { 
    1666                 $terms = _get_term_children( $child_of, $terms, $_tax ); 
    1667             } 
    1668         } 
    1669     } 
    1670  
    1671     // Update term counts to include children. 
    1672     if ( $args['pad_counts'] && 'all' == $_fields ) { 
    1673         foreach ( $taxonomies as $_tax ) { 
    1674             _pad_term_counts( $terms, $_tax ); 
    1675         } 
    1676     } 
    1677  
    1678     // Make sure we show empty categories that have children. 
    1679     if ( $hierarchical && $args['hide_empty'] && is_array( $terms ) ) { 
    1680         foreach ( $terms as $k => $term ) { 
    1681             if ( ! $term->count ) { 
    1682                 $children = get_term_children( $term->term_id, $term->taxonomy ); 
    1683                 if ( is_array( $children ) ) { 
    1684                     foreach ( $children as $child_id ) { 
    1685                         $child = get_term( $child_id, $term->taxonomy ); 
    1686                         if ( $child->count ) { 
    1687                             continue 2; 
    1688                         } 
    1689                     } 
    1690                 } 
    1691  
    1692                 // It really is empty. 
    1693                 unset($terms[$k]); 
    1694             } 
    1695         } 
    1696     } 
    1697  
    1698     $_terms = array(); 
    1699     if ( 'id=>parent' == $_fields ) { 
    1700         foreach ( $terms as $term ) { 
    1701             $_terms[ $term->term_id ] = $term->parent; 
    1702         } 
    1703     } elseif ( 'ids' == $_fields ) { 
    1704         foreach ( $terms as $term ) { 
    1705             $_terms[] = $term->term_id; 
    1706         } 
    1707     } elseif ( 'names' == $_fields ) { 
    1708         foreach ( $terms as $term ) { 
    1709             $_terms[] = $term->name; 
    1710         } 
    1711     } elseif ( 'id=>name' == $_fields ) { 
    1712         foreach ( $terms as $term ) { 
    1713             $_terms[ $term->term_id ] = $term->name; 
    1714         } 
    1715     } elseif ( 'id=>slug' == $_fields ) { 
    1716         foreach ( $terms as $term ) { 
    1717             $_terms[ $term->term_id ] = $term->slug; 
    1718         } 
    1719     } 
    1720  
    1721     if ( ! empty( $_terms ) ) { 
    1722         $terms = $_terms; 
    1723     } 
    1724  
    1725     // Hierarchical queries are not limited, so 'offset' and 'number' must be handled now. 
    1726     if ( $hierarchical && $number && is_array( $terms ) ) { 
    1727         if ( $offset >= count( $terms ) ) { 
    1728             $terms = array(); 
    1729         } else { 
    1730             $terms = array_slice( $terms, $offset, $number, true ); 
    1731         } 
    1732     } 
    1733  
    1734     wp_cache_add( $cache_key, $terms, 'terms', DAY_IN_SECONDS ); 
    1735  
    1736     if ( 'all' === $_fields ) { 
    1737         $terms = array_map( 'get_term', $terms ); 
    1738     } 
    1739  
    1740     /** This filter is documented in wp-includes/taxonomy.php */ 
    17411222    return apply_filters( 'get_terms', $terms, $taxonomies, $args ); 
    17421223} 
  • trunk/src/wp-settings.php

    r37536 r37572  
    169169require( ABSPATH . WPINC . '/taxonomy.php' ); 
    170170require( ABSPATH . WPINC . '/class-wp-term.php' ); 
     171require( ABSPATH . WPINC . '/class-wp-term-query.php' ); 
    171172require( ABSPATH . WPINC . '/class-wp-tax-query.php' ); 
    172173require( ABSPATH . WPINC . '/update.php' ); 
Note: See TracChangeset for help on using the changeset viewer.