WordPress.org

Make WordPress Core

Ticket #12891: revert-tax.diff

File revert-tax.diff, 18.9 KB (added by ryan, 4 years ago)
  • wp-includes/taxonomy.php

     
    554554        return $do_query ? $wpdb->get_col( $sql ) : $sql; 
    555555} 
    556556 
    557 /* 
    558  * Given a meta query, generates SQL to be appended to a main query 
    559  * 
    560  * @since 3.1.0 
    561  * 
    562  * @param array $tax_query List of taxonomy queries. A single taxonomy query is an associative array: 
    563  * - 'taxonomy' string|array The taxonomy being queried 
    564  * - 'terms' string|array The list of terms 
    565  * - 'field' string (optional) Which term field is being used. 
    566  *              Possible values: 'term_id', 'slug' or 'name' 
    567  *              Default: 'term_id' 
    568  * - 'operator' string (optional) 
    569  *              Possible values: 'IN' and 'NOT IN'. 
    570  *              Default: 'IN' 
    571  * - 'include_children' bool (optional) Whether to include child terms. 
    572  *              Default: true 
    573  * 
    574  * @param string $object_id_column 
    575  * @return string 
    576  */ 
    577 function get_tax_sql( $tax_query, $object_id_column ) { 
    578         global $wpdb; 
    579  
    580         $sql = array(); 
    581         foreach ( $tax_query as $query ) { 
    582                 if ( !isset( $query['include_children'] ) ) 
    583                         $query['include_children'] = true; 
    584  
    585                 $query['do_query'] = false; 
    586  
    587                 $sql_single = get_objects_in_term( $query['terms'], $query['taxonomy'], $query ); 
    588  
    589                 if ( empty( $sql_single ) || is_wp_error( $sql_single ) ) 
    590                         return ' AND 0 = 1'; 
    591  
    592                 $sql[] = $sql_single; 
    593         } 
    594  
    595         if ( 1 == count( $sql ) ) { 
    596                 $ids = $wpdb->get_col( $sql[0] ); 
    597         } else { 
    598                 $r = "SELECT object_id FROM $wpdb->term_relationships WHERE 1=1"; 
    599                 foreach ( $sql as $query ) 
    600                         $r .= " AND object_id IN ($query)"; 
    601  
    602                 $ids = $wpdb->get_col( $r ); 
    603         } 
    604  
    605         if ( !empty( $ids ) ) 
    606                 return " AND $object_id_column IN(" . implode( ', ', $ids ) . ")"; 
    607         else 
    608                 return ' AND 0 = 1'; 
    609 } 
    610  
    611  
    612557/** 
    613558 * Get all Term data from database by Term ID. 
    614559 * 
  • wp-includes/query.php

     
    13451345                                $this->is_date = true; 
    13461346                        } 
    13471347 
    1348                         $this->parse_tax_query( $qv ); 
     1348                        if ( empty($qv['cat']) || ($qv['cat'] == '0') ) { 
     1349                                $this->is_category = false; 
     1350                        } else { 
     1351                                if ( strpos($qv['cat'], '-') !== false ) { 
     1352                                        $this->is_category = false; 
     1353                                } else { 
     1354                                        $this->is_category = true; 
     1355                                } 
     1356                        } 
    13491357 
     1358                        if ( '' != $qv['category_name'] ) { 
     1359                                $this->is_category = true; 
     1360                        } 
     1361 
     1362                        if ( !is_array($qv['category__in']) || empty($qv['category__in']) ) { 
     1363                                $qv['category__in'] = array(); 
     1364                        } else { 
     1365                                $qv['category__in'] = array_map('absint', $qv['category__in']); 
     1366                                $this->is_category = true; 
     1367                        } 
     1368 
     1369                        if ( !is_array($qv['category__not_in']) || empty($qv['category__not_in']) ) { 
     1370                                $qv['category__not_in'] = array(); 
     1371                        } else { 
     1372                                $qv['category__not_in'] = array_map('absint', $qv['category__not_in']); 
     1373                        } 
     1374 
     1375                        if ( !is_array($qv['category__and']) || empty($qv['category__and']) ) { 
     1376                                $qv['category__and'] = array(); 
     1377                        } else { 
     1378                                $qv['category__and'] = array_map('absint', $qv['category__and']); 
     1379                                $this->is_category = true; 
     1380                        } 
     1381 
     1382                        if (  '' != $qv['tag'] ) 
     1383                                $this->is_tag = true; 
     1384 
     1385                        $qv['tag_id'] = absint($qv['tag_id']); 
     1386                        if (  !empty($qv['tag_id']) ) 
     1387                                $this->is_tag = true; 
     1388 
     1389                        if ( !is_array($qv['tag__in']) || empty($qv['tag__in']) ) { 
     1390                                $qv['tag__in'] = array(); 
     1391                        } else { 
     1392                                $qv['tag__in'] = array_map('absint', $qv['tag__in']); 
     1393                                $this->is_tag = true; 
     1394                        } 
     1395 
     1396                        if ( !is_array($qv['tag__not_in']) || empty($qv['tag__not_in']) ) { 
     1397                                $qv['tag__not_in'] = array(); 
     1398                        } else { 
     1399                                $qv['tag__not_in'] = array_map('absint', $qv['tag__not_in']); 
     1400                        } 
     1401 
     1402                        if ( !is_array($qv['tag__and']) || empty($qv['tag__and']) ) { 
     1403                                $qv['tag__and'] = array(); 
     1404                        } else { 
     1405                                $qv['tag__and'] = array_map('absint', $qv['tag__and']); 
     1406                                $this->is_category = true; 
     1407                        } 
     1408 
     1409                        if ( !is_array($qv['tag_slug__in']) || empty($qv['tag_slug__in']) ) { 
     1410                                $qv['tag_slug__in'] = array(); 
     1411                        } else { 
     1412                                $qv['tag_slug__in'] = array_map('sanitize_title', $qv['tag_slug__in']); 
     1413                                $this->is_tag = true; 
     1414                        } 
     1415 
     1416                        if ( !is_array($qv['tag_slug__and']) || empty($qv['tag_slug__and']) ) { 
     1417                                $qv['tag_slug__and'] = array(); 
     1418                        } else { 
     1419                                $qv['tag_slug__and'] = array_map('sanitize_title', $qv['tag_slug__and']); 
     1420                                $this->is_tag = true; 
     1421                        } 
     1422 
     1423                        if ( empty($qv['taxonomy']) || empty($qv['term']) ) { 
     1424                                $this->is_tax = false; 
     1425                                foreach ( $GLOBALS['wp_taxonomies'] as $taxonomy => $t ) { 
     1426                                        if ( $t->query_var && isset($qv[$t->query_var]) && '' != $qv[$t->query_var] ) { 
     1427                                                $qv['taxonomy'] = $taxonomy; 
     1428                                                $qv['term'] = $qv[$t->query_var]; 
     1429                                                $this->is_tax = true; 
     1430                                                break; 
     1431                                        } 
     1432                                } 
     1433                        } else { 
     1434                                $this->is_tax = true; 
     1435                        } 
     1436 
    13501437                        _parse_meta_query( $qv ); 
    13511438 
    13521439                        if ( empty($qv['author']) || ($qv['author'] == '0') ) { 
     
    14601547                        do_action_ref_array('parse_query', array(&$this)); 
    14611548        } 
    14621549 
    1463         /* 
    1464          * Parses various taxonomy related query vars and sets the appropriate query flags 
    1465          * 
    1466          * @access protected 
    1467          * @since 3.1.0 
    1468          * 
    1469          * @param array &$q The query variables 
    1470          * @return array tax query 
    1471          */ 
    1472         function parse_tax_query( &$q ) { 
    1473                 if ( ! empty( $q['tax_query'] ) && is_array( $q['tax_query'] ) ) { 
    1474                         $tax_query = $q['tax_query']; 
    1475                 } else { 
    1476                         $tax_query = array(); 
    1477                 } 
    1478  
    1479                 if ( !empty($q['taxonomy']) && !empty($q['term']) ) { 
    1480                         $tax_query[] = array( 
    1481                                 'taxonomy' => $q['taxonomy'], 
    1482                                 'terms' => array( $q['term'] ), 
    1483                                 'field' => 'slug', 
    1484                                 'operator' => 'IN', 
    1485                         ); 
    1486                 } 
    1487  
    1488                 foreach ( $GLOBALS['wp_taxonomies'] as $taxonomy => $t ) { 
    1489                         if ( $t->query_var && !empty( $q[$t->query_var] ) ) { 
    1490                                 $tax_query_defaults = array( 
    1491                                         'taxonomy' => $taxonomy, 
    1492                                         'field' => 'slug', 
    1493                                         'operator' => 'IN' 
    1494                                 ); 
    1495  
    1496                                 if ( $t->rewrite['hierarchical'] ) { 
    1497                                         $q[$t->query_var] = wp_basename( $q[$t->query_var] ); 
    1498                                 } 
    1499  
    1500                                 $term = str_replace( ' ', '+', $q[$t->query_var] ); 
    1501  
    1502                                 if ( strpos($term, '+') !== false ) { 
    1503                                         $terms = preg_split( '/[+]+/', $term ); 
    1504                                         foreach ( $terms as $term ) { 
    1505                                                 $tax_query[] = array_merge( $tax_query_defaults, array( 
    1506                                                         'terms' => array( $term ) 
    1507                                                 ) ); 
    1508                                         } 
    1509                                 } else { 
    1510                                         $tax_query[] = array_merge( $tax_query_defaults, array( 
    1511                                                 'terms' => preg_split( '/[,]+/', $term ) 
    1512                                         ) ); 
    1513                                 } 
    1514                         } 
    1515                 } 
    1516  
    1517                 // Category stuff 
    1518                 if ( !empty($q['cat']) && '0' != $q['cat'] && !$this->is_singular ) { 
    1519                         $q['cat'] = ''.urldecode($q['cat']).''; 
    1520                         $q['cat'] = addslashes_gpc($q['cat']); 
    1521                         $cat_array = preg_split('/[,\s]+/', $q['cat']); 
    1522                         $q['cat'] = ''; 
    1523                         $req_cats = array(); 
    1524                         foreach ( (array) $cat_array as $cat ) { 
    1525                                 $cat = intval($cat); 
    1526                                 $req_cats[] = $cat; 
    1527                                 $in = ($cat > 0); 
    1528                                 $cat = abs($cat); 
    1529                                 if ( $in ) { 
    1530                                         $q['category__in'][] = $cat; 
    1531                                 } else { 
    1532                                         $q['category__not_in'][] = $cat; 
    1533                                 } 
    1534                         } 
    1535                         $q['cat'] = implode(',', $req_cats); 
    1536                 } 
    1537  
    1538                 if ( !empty($q['category__in']) ) { 
    1539                         $tax_query[] = array( 
    1540                                 'taxonomy' => 'category', 
    1541                                 'terms' => $q['category__in'], 
    1542                                 'operator' => 'IN', 
    1543                                 'field' => 'term_id' 
    1544                         ); 
    1545                 } 
    1546  
    1547                 if ( !empty($q['category__not_in']) ) { 
    1548                         $tax_query[] = array( 
    1549                                 'taxonomy' => 'category', 
    1550                                 'terms' => $q['category__not_in'], 
    1551                                 'operator' => 'NOT IN', 
    1552                                 'field' => 'term_id' 
    1553                         ); 
    1554                 } 
    1555  
    1556                 // Tag stuff 
    1557                 if ( !empty($qv['tag_id']) ) { 
    1558                         $tax_query[] = array( 
    1559                                 'taxonomy' => 'post_tag', 
    1560                                 'terms' => $qv['tag_id'], 
    1561                                 'operator' => 'IN', 
    1562                                 'field' => 'term_id' 
    1563                         ); 
    1564                 } 
    1565  
    1566                 if ( !empty($q['tag__in']) ) { 
    1567                         $tax_query[] = array( 
    1568                                 'taxonomy' => 'post_tag', 
    1569                                 'terms' => $q['tag__in'], 
    1570                                 'operator' => 'IN', 
    1571                                 'field' => 'term_id' 
    1572                         ); 
    1573                 } 
    1574  
    1575                 if ( !empty($q['tag__not_in']) ) { 
    1576                         $tax_query[] = array( 
    1577                                 'taxonomy' => 'post_tag', 
    1578                                 'terms' => $q['tag__not_in'], 
    1579                                 'operator' => 'NOT IN', 
    1580                                 'field' => 'term_id' 
    1581                         ); 
    1582                 } 
    1583  
    1584                 foreach ( $tax_query as $query ) { 
    1585                         if ( 'IN' == $query['operator'] ) { 
    1586                                 switch ( $query['taxonomy'] ) { 
    1587                                         case 'category': 
    1588                                                 $this->is_category = true; 
    1589                                                 break; 
    1590                                         case 'post_tag': 
    1591                                                 $this->is_tag = true; 
    1592                                                 break; 
    1593                                         default: 
    1594                                                 $this->is_tax = true; 
    1595                                 } 
    1596                         } 
    1597                 } 
    1598  
    1599                 return $tax_query; 
    1600         } 
    1601  
    16021550        /** 
    16031551         * Sets the 404 property and saves whether query is feed. 
    16041552         * 
     
    16671615 
    16681616                // First let's clear some variables 
    16691617                $distinct = ''; 
     1618                $whichcat = ''; 
    16701619                $whichauthor = ''; 
    16711620                $whichmimetype = ''; 
    16721621                $where = ''; 
     
    19301879                // Allow plugins to contextually add/remove/modify the search section of the database query 
    19311880                $search = apply_filters_ref_array('posts_search', array( $search, &$this ) ); 
    19321881 
    1933                 // Taxonomies 
    1934                 $q['tax_query'] = $this->parse_tax_query( $q ); 
    1935                 if ( !empty( $q['tax_query'] ) ) { 
    1936                         if ( empty($post_type) ) { 
    1937                                 $post_type = 'any'; 
    1938                                 $post_status_join = true; 
    1939                         } elseif ( in_array('attachment', (array) $post_type) ) { 
    1940                                 $post_status_join = true; 
     1882                // Category stuff 
     1883 
     1884                if ( empty($q['cat']) || ($q['cat'] == '0') || 
     1885                                // Bypass cat checks if fetching specific posts 
     1886                                $this->is_singular ) { 
     1887                        $whichcat = ''; 
     1888                } else { 
     1889                        $q['cat'] = ''.urldecode($q['cat']).''; 
     1890                        $q['cat'] = addslashes_gpc($q['cat']); 
     1891                        $cat_array = preg_split('/[,\s]+/', $q['cat']); 
     1892                        $q['cat'] = ''; 
     1893                        $req_cats = array(); 
     1894                        foreach ( (array) $cat_array as $cat ) { 
     1895                                $cat = intval($cat); 
     1896                                $req_cats[] = $cat; 
     1897                                $in = ($cat > 0); 
     1898                                $cat = abs($cat); 
     1899                                if ( $in ) { 
     1900                                        $q['category__in'][] = $cat; 
     1901                                        $q['category__in'] = array_merge($q['category__in'], get_term_children($cat, 'category')); 
     1902                                } else { 
     1903                                        $q['category__not_in'][] = $cat; 
     1904                                        $q['category__not_in'] = array_merge($q['category__not_in'], get_term_children($cat, 'category')); 
     1905                                } 
    19411906                        } 
     1907                        $q['cat'] = implode(',', $req_cats); 
     1908                } 
    19421909 
    1943                         $where .= get_tax_sql( $q['tax_query'], "$wpdb->posts.ID" ); 
     1910                if ( !empty($q['category__in']) ) { 
     1911                        $join = " INNER JOIN $wpdb->term_relationships ON ($wpdb->posts.ID = $wpdb->term_relationships.object_id) INNER JOIN $wpdb->term_taxonomy ON ($wpdb->term_relationships.term_taxonomy_id = $wpdb->term_taxonomy.term_taxonomy_id) "; 
     1912                        $whichcat .= " AND $wpdb->term_taxonomy.taxonomy = 'category' "; 
     1913                        $include_cats = "'" . implode("', '", $q['category__in']) . "'"; 
     1914                        $whichcat .= " AND $wpdb->term_taxonomy.term_id IN ($include_cats) "; 
     1915                } 
    19441916 
    1945                         // Back-compat 
    1946                         $tax_query_in = wp_list_filter( $q['tax_query'], array( 'operator' => 'IN' ) ); 
    1947                         if ( !empty( $tax_query_in ) ) { 
    1948                                 if ( !isset( $q['taxonomy'] ) ) { 
    1949                                         foreach ( $tax_query_in as $a_tax_query ) { 
    1950                                                 if ( !in_array( $a_tax_query['taxonomy'], array( 'category', 'post_tag' ) ) ) { 
    1951                                                         $q['taxonomy'] = $a_tax_query['taxonomy']; 
    1952                                                         if ( 'slug' == $a_tax_query['field'] ) 
    1953                                                                 $q['term'] = $a_tax_query['terms'][0]; 
    1954                                                         else 
    1955                                                                 $q['term_id'] = $a_tax_query['terms'][0]; 
     1917                if ( !empty($q['category__not_in']) ) { 
     1918                        $cat_string = "'" . implode("', '", $q['category__not_in']) . "'"; 
     1919                        $whichcat .= " AND $wpdb->posts.ID NOT IN ( 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 = 'category' AND tt.term_id IN ($cat_string) )"; 
     1920                } 
    19561921 
    1957                                                         break; 
    1958                                                 } 
     1922                // Category stuff for nice URLs 
     1923                if ( '' != $q['category_name'] && !$this->is_singular ) { 
     1924                        $q['category_name'] = implode('/', array_map('sanitize_title', explode('/', $q['category_name']))); 
     1925                        $reqcat = get_category_by_path($q['category_name']); 
     1926                        $q['category_name'] = str_replace('%2F', '/', urlencode(urldecode($q['category_name']))); 
     1927                        $cat_paths = '/' . trim($q['category_name'], '/'); 
     1928                        $q['category_name'] = sanitize_title(basename($cat_paths)); 
     1929 
     1930                        $cat_paths = '/' . trim(urldecode($q['category_name']), '/'); 
     1931                        $q['category_name'] = sanitize_title(basename($cat_paths)); 
     1932                        $cat_paths = explode('/', $cat_paths); 
     1933                        $cat_path = ''; 
     1934                        foreach ( (array) $cat_paths as $pathdir ) 
     1935                                $cat_path .= ( $pathdir != '' ? '/' : '' ) . sanitize_title($pathdir); 
     1936 
     1937                        //if we don't match the entire hierarchy fallback on just matching the nicename 
     1938                        if ( empty($reqcat) ) 
     1939                                $reqcat = get_category_by_path($q['category_name'], false); 
     1940 
     1941                        if ( !empty($reqcat) ) 
     1942                                $reqcat = $reqcat->term_id; 
     1943                        else 
     1944                                $reqcat = 0; 
     1945 
     1946                        $q['cat'] = $reqcat; 
     1947 
     1948                        $join = " INNER JOIN $wpdb->term_relationships ON ($wpdb->posts.ID = $wpdb->term_relationships.object_id) INNER JOIN $wpdb->term_taxonomy ON ($wpdb->term_relationships.term_taxonomy_id = $wpdb->term_taxonomy.term_taxonomy_id) "; 
     1949                        $whichcat = " AND $wpdb->term_taxonomy.taxonomy = 'category' "; 
     1950                        $in_cats = array($q['cat']); 
     1951                        $in_cats = array_merge($in_cats, get_term_children($q['cat'], 'category')); 
     1952                        $in_cats = "'" . implode("', '", $in_cats) . "'"; 
     1953                        $whichcat .= "AND $wpdb->term_taxonomy.term_id IN ($in_cats)"; 
     1954                        $groupby = "{$wpdb->posts}.ID"; 
     1955                } 
     1956 
     1957                // Tags 
     1958                if ( '' != $q['tag'] ) { 
     1959                        if ( strpos($q['tag'], ',') !== false ) { 
     1960                                $tags = preg_split('/[,\s]+/', $q['tag']); 
     1961                                foreach ( (array) $tags as $tag ) { 
     1962                                        $tag = sanitize_term_field('slug', $tag, 0, 'post_tag', 'db'); 
     1963                                        $q['tag_slug__in'][] = $tag; 
     1964                                } 
     1965                        } else if ( preg_match('/[+\s]+/', $q['tag']) || !empty($q['cat']) ) { 
     1966                                $tags = preg_split('/[+\s]+/', $q['tag']); 
     1967                                foreach ( (array) $tags as $tag ) { 
     1968                                        $tag = sanitize_term_field('slug', $tag, 0, 'post_tag', 'db'); 
     1969                                        $q['tag_slug__and'][] = $tag; 
     1970                                } 
     1971                        } else { 
     1972                                $q['tag'] = sanitize_term_field('slug', $q['tag'], 0, 'post_tag', 'db'); 
     1973                                $q['tag_slug__in'][] = $q['tag']; 
     1974                        } 
     1975                } 
     1976 
     1977                if ( !empty($q['category__in']) || !empty($q['meta_key']) || !empty($q['tag__in']) || !empty($q['tag_slug__in']) ) { 
     1978                        $groupby = "{$wpdb->posts}.ID"; 
     1979                } 
     1980 
     1981                if ( !empty($q['tag__in']) && empty($q['cat']) ) { 
     1982                        $join = " INNER JOIN $wpdb->term_relationships ON ($wpdb->posts.ID = $wpdb->term_relationships.object_id) INNER JOIN $wpdb->term_taxonomy ON ($wpdb->term_relationships.term_taxonomy_id = $wpdb->term_taxonomy.term_taxonomy_id) "; 
     1983                        $whichcat .= " AND $wpdb->term_taxonomy.taxonomy = 'post_tag' "; 
     1984                        $include_tags = "'" . implode("', '", $q['tag__in']) . "'"; 
     1985                        $whichcat .= " AND $wpdb->term_taxonomy.term_id IN ($include_tags) "; 
     1986                        $reqtag = term_exists( $q['tag__in'][0], 'post_tag' ); 
     1987                        if ( !empty($reqtag) ) 
     1988                                $q['tag_id'] = $reqtag['term_id']; 
     1989                } 
     1990 
     1991                if ( !empty($q['tag_slug__in']) && empty($q['cat']) ) { 
     1992                        $join = " INNER JOIN $wpdb->term_relationships ON ($wpdb->posts.ID = $wpdb->term_relationships.object_id) INNER JOIN $wpdb->term_taxonomy ON ($wpdb->term_relationships.term_taxonomy_id = $wpdb->term_taxonomy.term_taxonomy_id) INNER JOIN $wpdb->terms ON ($wpdb->term_taxonomy.term_id = $wpdb->terms.term_id) "; 
     1993                        $whichcat .= " AND $wpdb->term_taxonomy.taxonomy = 'post_tag' "; 
     1994                        $include_tags = "'" . implode("', '", $q['tag_slug__in']) . "'"; 
     1995                        $whichcat .= " AND $wpdb->terms.slug IN ($include_tags) "; 
     1996                        $reqtag = get_term_by( 'slug', $q['tag_slug__in'][0], 'post_tag' ); 
     1997                        if ( !empty($reqtag) ) 
     1998                                $q['tag_id'] = $reqtag->term_id; 
     1999                } 
     2000 
     2001                if ( !empty($q['tag__not_in']) ) { 
     2002                        $tag_string = "'" . implode("', '", $q['tag__not_in']) . "'"; 
     2003                        $whichcat .= " AND $wpdb->posts.ID NOT IN ( 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 = 'post_tag' AND tt.term_id IN ($tag_string) )"; 
     2004                } 
     2005 
     2006                // Tag and slug intersections. 
     2007                $intersections = array('category__and' => 'category', 'tag__and' => 'post_tag', 'tag_slug__and' => 'post_tag', 'tag__in' => 'post_tag', 'tag_slug__in' => 'post_tag'); 
     2008                $tagin = array('tag__in', 'tag_slug__in'); // These are used to make some exceptions below 
     2009                foreach ( $intersections as $item => $taxonomy ) { 
     2010                        if ( empty($q[$item]) ) continue; 
     2011                        if ( in_array($item, $tagin) && empty($q['cat']) ) continue; // We should already have what we need if categories aren't being used 
     2012 
     2013                        if ( $item != 'category__and' ) { 
     2014                                $reqtag = term_exists( $q[$item][0], 'post_tag' ); 
     2015                                if ( !empty($reqtag) ) 
     2016                                        $q['tag_id'] = $reqtag['term_id']; 
     2017                        } 
     2018 
     2019                        if ( in_array( $item, array('tag_slug__and', 'tag_slug__in' ) ) ) 
     2020                                $taxonomy_field = 'slug'; 
     2021                        else 
     2022                                $taxonomy_field = 'term_id'; 
     2023 
     2024                        $q[$item] = array_unique($q[$item]); 
     2025                        $tsql = "SELECT p.ID FROM $wpdb->posts p INNER JOIN $wpdb->term_relationships tr ON (p.ID = tr.object_id) INNER JOIN $wpdb->term_taxonomy tt ON (tr.term_taxonomy_id = tt.term_taxonomy_id) INNER JOIN $wpdb->terms t ON (tt.term_id = t.term_id)"; 
     2026                        $tsql .= " WHERE tt.taxonomy = '$taxonomy' AND t.$taxonomy_field IN ('" . implode("', '", $q[$item]) . "')"; 
     2027                        if ( !in_array($item, $tagin) ) { // This next line is only helpful if we are doing an and relationship 
     2028                                $tsql .= " GROUP BY p.ID HAVING count(p.ID) = " . count($q[$item]); 
     2029                        } 
     2030                        $post_ids = $wpdb->get_col($tsql); 
     2031 
     2032                        if ( count($post_ids) ) 
     2033                                $whichcat .= " AND $wpdb->posts.ID IN (" . implode(', ', $post_ids) . ") "; 
     2034                        else { 
     2035                                $whichcat = " AND 0 = 1"; 
     2036                                break; 
     2037                        } 
     2038                } 
     2039 
     2040                // Taxonomies 
     2041                if ( $this->is_tax ) { 
     2042                        if ( '' != $q['taxonomy'] ) { 
     2043                                $taxonomy = $q['taxonomy']; 
     2044                                $tt[$taxonomy] = $q['term']; 
     2045                        } else { 
     2046                                foreach ( $GLOBALS['wp_taxonomies'] as $taxonomy => $t ) { 
     2047                                        if ( $t->query_var && '' != $q[$t->query_var] ) { 
     2048                                                $tt[$taxonomy] = $q[$t->query_var]; 
     2049                                                break; 
    19592050                                        } 
    19602051                                } 
     2052                        } 
    19612053 
    1962                                 $cat_query = wp_list_filter( $tax_query_in, array( 'taxonomy' => 'category' ) ); 
    1963                                 if ( !empty( $cat_query ) ) { 
    1964                                         $cat_query = reset( $cat_query ); 
    1965                                         $cat = get_term_by( $cat_query['field'], $cat_query['terms'][0], 'category' ); 
    1966                                         if ( $cat ) { 
    1967                                                 $this->set( 'cat', $cat->term_id ); 
    1968                                                 $this->set( 'category_name', $cat->slug ); 
     2054                        $terms = get_terms($taxonomy, array('slug' => $tt[$taxonomy], 'hide_empty' => !is_taxonomy_hierarchical($taxonomy))); 
     2055 
     2056                        if ( is_wp_error($terms) || empty($terms) ) { 
     2057                                $whichcat = " AND 0 "; 
     2058                        } else { 
     2059                                foreach ( $terms as $term ) { 
     2060                                        $term_ids[] = $term->term_id; 
     2061                                        if ( is_taxonomy_hierarchical($taxonomy) ) { 
     2062                                                $children = get_term_children($term->term_id, $taxonomy); 
     2063                                                $term_ids = array_merge($term_ids, $children); 
    19692064                                        } 
    19702065                                } 
     2066                                $post_ids = get_objects_in_term($term_ids, $taxonomy); 
     2067                                if ( !is_wp_error($post_ids) && !empty($post_ids) ) { 
     2068                                        $whichcat .= " AND $wpdb->posts.ID IN (" . implode(', ', $post_ids) . ") "; 
     2069                                        if ( empty($post_type) ) { 
     2070                                                $post_type = 'any'; 
     2071                                                $post_status_join = true; 
     2072                                        } elseif ( in_array('attachment', (array)$post_type) ) { 
     2073                                                $post_status_join = true; 
     2074                                        } 
     2075                                } else { 
     2076                                        $whichcat = " AND 0 "; 
     2077                                } 
    19712078                        } 
    19722079                } 
    19732080 
     
    20242131                        $whichmimetype = wp_post_mime_type_where($q['post_mime_type'], $table_alias); 
    20252132                } 
    20262133 
    2027                 $where .= $search . $whichauthor . $whichmimetype; 
     2134                $where .= $search . $whichcat . $whichauthor . $whichmimetype; 
    20282135 
    20292136                if ( empty($q['order']) || ((strtoupper($q['order']) != 'ASC') && (strtoupper($q['order']) != 'DESC')) ) 
    20302137                        $q['order'] = 'DESC';