WP_Query
The WordPress Query class.
Contents
- Description
- More Information
- Usage
- Methods and Properties
- Properties
- Author Parameters
- Category Parameters
- Tag Parameters
- Taxonomy Parameters
- Search Parameters
- Post & Page Parameters
- Password Parameters
- Post Type Parameters
- Status Parameters
- Pagination Parameters
- Order & Orderby Parameters
- Date Parameters
- Custom Field (post meta) Parameters
- Permission Parameters
- Mime Type Parameters
- Caching Parameters
- Return Fields Parameter
- Methods
- User Contributed Notes
Description Description
Source Source
File: wp-includes/class-wp-query.php
class WP_Query {
/**
* Query vars set by the user
*
* @since 1.5.0
* @var array
*/
public $query;
/**
* Query vars, after parsing
*
* @since 1.5.0
* @var array
*/
public $query_vars = array();
/**
* Taxonomy query, as passed to get_tax_sql()
*
* @since 3.1.0
* @var object WP_Tax_Query
*/
public $tax_query;
/**
* Metadata query container
*
* @since 3.2.0
* @var object WP_Meta_Query
*/
public $meta_query = false;
/**
* Date query container
*
* @since 3.7.0
* @var object WP_Date_Query
*/
public $date_query = false;
/**
* Holds the data for a single object that is queried.
*
* Holds the contents of a post, page, category, attachment.
*
* @since 1.5.0
* @var object|array
*/
public $queried_object;
/**
* The ID of the queried object.
*
* @since 1.5.0
* @var int
*/
public $queried_object_id;
/**
* Get post database query.
*
* @since 2.0.1
* @var string
*/
public $request;
/**
* List of posts.
*
* @since 1.5.0
* @var array
*/
public $posts;
/**
* The amount of posts for the current query.
*
* @since 1.5.0
* @var int
*/
public $post_count = 0;
/**
* Index of the current item in the loop.
*
* @since 1.5.0
* @var int
*/
public $current_post = -1;
/**
* Whether the loop has started and the caller is in the loop.
*
* @since 2.0.0
* @var bool
*/
public $in_the_loop = false;
/**
* The current post.
*
* @since 1.5.0
* @var WP_Post
*/
public $post;
/**
* The list of comments for current post.
*
* @since 2.2.0
* @var array
*/
public $comments;
/**
* The amount of comments for the posts.
*
* @since 2.2.0
* @var int
*/
public $comment_count = 0;
/**
* The index of the comment in the comment loop.
*
* @since 2.2.0
* @var int
*/
public $current_comment = -1;
/**
* Current comment ID.
*
* @since 2.2.0
* @var int
*/
public $comment;
/**
* The amount of found posts for the current query.
*
* If limit clause was not used, equals $post_count.
*
* @since 2.1.0
* @var int
*/
public $found_posts = 0;
/**
* The amount of pages.
*
* @since 2.1.0
* @var int
*/
public $max_num_pages = 0;
/**
* The amount of comment pages.
*
* @since 2.7.0
* @var int
*/
public $max_num_comment_pages = 0;
/**
* Signifies whether the current query is for a single post.
*
* @since 1.5.0
* @var bool
*/
public $is_single = false;
/**
* Signifies whether the current query is for a preview.
*
* @since 2.0.0
* @var bool
*/
public $is_preview = false;
/**
* Signifies whether the current query is for a page.
*
* @since 1.5.0
* @var bool
*/
public $is_page = false;
/**
* Signifies whether the current query is for an archive.
*
* @since 1.5.0
* @var bool
*/
public $is_archive = false;
/**
* Signifies whether the current query is for a date archive.
*
* @since 1.5.0
* @var bool
*/
public $is_date = false;
/**
* Signifies whether the current query is for a year archive.
*
* @since 1.5.0
* @var bool
*/
public $is_year = false;
/**
* Signifies whether the current query is for a month archive.
*
* @since 1.5.0
* @var bool
*/
public $is_month = false;
/**
* Signifies whether the current query is for a day archive.
*
* @since 1.5.0
* @var bool
*/
public $is_day = false;
/**
* Signifies whether the current query is for a specific time.
*
* @since 1.5.0
* @var bool
*/
public $is_time = false;
/**
* Signifies whether the current query is for an author archive.
*
* @since 1.5.0
* @var bool
*/
public $is_author = false;
/**
* Signifies whether the current query is for a category archive.
*
* @since 1.5.0
* @var bool
*/
public $is_category = false;
/**
* Signifies whether the current query is for a tag archive.
*
* @since 2.3.0
* @var bool
*/
public $is_tag = false;
/**
* Signifies whether the current query is for a taxonomy archive.
*
* @since 2.5.0
* @var bool
*/
public $is_tax = false;
/**
* Signifies whether the current query is for a search.
*
* @since 1.5.0
* @var bool
*/
public $is_search = false;
/**
* Signifies whether the current query is for a feed.
*
* @since 1.5.0
* @var bool
*/
public $is_feed = false;
/**
* Signifies whether the current query is for a comment feed.
*
* @since 2.2.0
* @var bool
*/
public $is_comment_feed = false;
/**
* Signifies whether the current query is for trackback endpoint call.
*
* @since 1.5.0
* @var bool
*/
public $is_trackback = false;
/**
* Signifies whether the current query is for the site homepage.
*
* @since 1.5.0
* @var bool
*/
public $is_home = false;
/**
* Signifies whether the current query couldn't find anything.
*
* @since 1.5.0
* @var bool
*/
public $is_404 = false;
/**
* Signifies whether the current query is for an embed.
*
* @since 4.4.0
* @var bool
*/
public $is_embed = false;
/**
* Signifies whether the current query is for a paged result and not for the first page.
*
* @since 1.5.0
* @var bool
*/
public $is_paged = false;
/**
* Signifies whether the current query is for an administrative interface page.
*
* @since 1.5.0
* @var bool
*/
public $is_admin = false;
/**
* Signifies whether the current query is for an attachment page.
*
* @since 2.0.0
* @var bool
*/
public $is_attachment = false;
/**
* Signifies whether the current query is for an existing single post of any post type
* (post, attachment, page, custom post types).
*
* @since 2.1.0
* @var bool
*/
public $is_singular = false;
/**
* Signifies whether the current query is for the robots.txt file.
*
* @since 2.1.0
* @var bool
*/
public $is_robots = false;
/**
* Signifies whether the current query is for the page_for_posts page.
*
* Basically, the homepage if the option isn't set for the static homepage.
*
* @since 2.1.0
* @var bool
*/
public $is_posts_page = false;
/**
* Signifies whether the current query is for a post type archive.
*
* @since 3.1.0
* @var bool
*/
public $is_post_type_archive = false;
/**
* Stores the ->query_vars state like md5(serialize( $this->query_vars ) ) so we know
* whether we have to re-parse because something has changed
*
* @since 3.1.0
* @var bool|string
*/
private $query_vars_hash = false;
/**
* Whether query vars have changed since the initial parse_query() call. Used to catch modifications to query vars made
* via pre_get_posts hooks.
*
* @since 3.1.1
*/
private $query_vars_changed = true;
/**
* Set if post thumbnails are cached
*
* @since 3.2.0
* @var bool
*/
public $thumbnails_cached = false;
/**
* Cached list of search stopwords.
*
* @since 3.7.0
* @var array
*/
private $stopwords;
private $compat_fields = array( 'query_vars_hash', 'query_vars_changed' );
private $compat_methods = array( 'init_query_flags', 'parse_tax_query' );
/**
* Resets query flags to false.
*
* The query flags are what page info WordPress was able to figure out.
*
* @since 2.0.0
*/
private function init_query_flags() {
$this->is_single = false;
$this->is_preview = false;
$this->is_page = false;
$this->is_archive = false;
$this->is_date = false;
$this->is_year = false;
$this->is_month = false;
$this->is_day = false;
$this->is_time = false;
$this->is_author = false;
$this->is_category = false;
$this->is_tag = false;
$this->is_tax = false;
$this->is_search = false;
$this->is_feed = false;
$this->is_comment_feed = false;
$this->is_trackback = false;
$this->is_home = false;
$this->is_404 = false;
$this->is_paged = false;
$this->is_admin = false;
$this->is_attachment = false;
$this->is_singular = false;
$this->is_robots = false;
$this->is_posts_page = false;
$this->is_post_type_archive = false;
}
/**
* Initiates object properties and sets default values.
*
* @since 1.5.0
*/
public function init() {
unset( $this->posts );
unset( $this->query );
$this->query_vars = array();
unset( $this->queried_object );
unset( $this->queried_object_id );
$this->post_count = 0;
$this->current_post = -1;
$this->in_the_loop = false;
unset( $this->request );
unset( $this->post );
unset( $this->comments );
unset( $this->comment );
$this->comment_count = 0;
$this->current_comment = -1;
$this->found_posts = 0;
$this->max_num_pages = 0;
$this->max_num_comment_pages = 0;
$this->init_query_flags();
}
/**
* Reparse the query vars.
*
* @since 1.5.0
*/
public function parse_query_vars() {
$this->parse_query();
}
/**
* Fills in the query variables, which do not exist within the parameter.
*
* @since 2.1.0
* @since 4.4.0 Removed the `comments_popup` public query variable.
*
* @param array $array Defined query variables.
* @return array Complete query variables with undefined ones filled in empty.
*/
public function fill_query_vars( $array ) {
$keys = array(
'error',
'm',
'p',
'post_parent',
'subpost',
'subpost_id',
'attachment',
'attachment_id',
'name',
'static',
'pagename',
'page_id',
'second',
'minute',
'hour',
'day',
'monthnum',
'year',
'w',
'category_name',
'tag',
'cat',
'tag_id',
'author',
'author_name',
'feed',
'tb',
'paged',
'meta_key',
'meta_value',
'preview',
's',
'sentence',
'title',
'fields',
'menu_order',
'embed',
);
foreach ( $keys as $key ) {
if ( ! isset( $array[ $key ] ) ) {
$array[ $key ] = '';
}
}
$array_keys = array(
'category__in',
'category__not_in',
'category__and',
'post__in',
'post__not_in',
'post_name__in',
'tag__in',
'tag__not_in',
'tag__and',
'tag_slug__in',
'tag_slug__and',
'post_parent__in',
'post_parent__not_in',
'author__in',
'author__not_in',
);
foreach ( $array_keys as $key ) {
if ( ! isset( $array[ $key ] ) ) {
$array[ $key ] = array();
}
}
return $array;
}
/**
* Parse a query string and set query type booleans.
*
* @since 1.5.0
* @since 4.2.0 Introduced the ability to order by specific clauses of a `$meta_query`, by passing the clause's
* array key to `$orderby`.
* @since 4.4.0 Introduced `$post_name__in` and `$title` parameters. `$s` was updated to support excluded
* search terms, by prepending a hyphen.
* @since 4.5.0 Removed the `$comments_popup` parameter.
* Introduced the `$comment_status` and `$ping_status` parameters.
* Introduced `RAND(x)` syntax for `$orderby`, which allows an integer seed value to random sorts.
* @since 4.6.0 Added 'post_name__in' support for `$orderby`. Introduced the `$lazy_load_term_meta` argument.
* @since 4.9.0 Introduced the `$comment_count` parameter.
* @since 5.1.0 Introduced the `$meta_compare_key` parameter.
*
* @param string|array $query {
* Optional. Array or string of Query parameters.
*
* @type int $attachment_id Attachment post ID. Used for 'attachment' post_type.
* @type int|string $author Author ID, or comma-separated list of IDs.
* @type string $author_name User 'user_nicename'.
* @type array $author__in An array of author IDs to query from.
* @type array $author__not_in An array of author IDs not to query from.
* @type bool $cache_results Whether to cache post information. Default true.
* @type int|string $cat Category ID or comma-separated list of IDs (this or any children).
* @type array $category__and An array of category IDs (AND in).
* @type array $category__in An array of category IDs (OR in, no children).
* @type array $category__not_in An array of category IDs (NOT in).
* @type string $category_name Use category slug (not name, this or any children).
* @type array|int $comment_count Filter results by comment count. Provide an integer to match
* comment count exactly. Provide an array with integer 'value'
* and 'compare' operator ('=', '!=', '>', '>=', '<', '<=' ) to
* compare against comment_count in a specific way.
* @type string $comment_status Comment status.
* @type int $comments_per_page The number of comments to return per page.
* Default 'comments_per_page' option.
* @type array $date_query An associative array of WP_Date_Query arguments.
* See WP_Date_Query::__construct().
* @type int $day Day of the month. Default empty. Accepts numbers 1-31.
* @type bool $exact Whether to search by exact keyword. Default false.
* @type string|array $fields Which fields to return. Single field or all fields (string),
* or array of fields. 'id=>parent' uses 'id' and 'post_parent'.
* Default all fields. Accepts 'ids', 'id=>parent'.
* @type int $hour Hour of the day. Default empty. Accepts numbers 0-23.
* @type int|bool $ignore_sticky_posts Whether to ignore sticky posts or not. Setting this to false
* excludes stickies from 'post__in'. Accepts 1|true, 0|false.
* Default 0|false.
* @type int $m Combination YearMonth. Accepts any four-digit year and month
* numbers 1-12. Default empty.
* @type string $meta_compare Comparison operator to test the 'meta_value'.
* @type string $meta_compare_key Comparison operator to test the 'meta_key'.
* @type string $meta_key Custom field key.
* @type array $meta_query An associative array of WP_Meta_Query arguments. See WP_Meta_Query.
* @type string $meta_value Custom field value.
* @type int $meta_value_num Custom field value number.
* @type int $menu_order The menu order of the posts.
* @type int $monthnum The two-digit month. Default empty. Accepts numbers 1-12.
* @type string $name Post slug.
* @type bool $nopaging Show all posts (true) or paginate (false). Default false.
* @type bool $no_found_rows Whether to skip counting the total rows found. Enabling can improve
* performance. Default false.
* @type int $offset The number of posts to offset before retrieval.
* @type string $order Designates ascending or descending order of posts. Default 'DESC'.
* Accepts 'ASC', 'DESC'.
* @type string|array $orderby Sort retrieved posts by parameter. One or more options may be
* passed. To use 'meta_value', or 'meta_value_num',
* 'meta_key=keyname' must be also be defined. To sort by a
* specific `$meta_query` clause, use that clause's array key.
* Accepts 'none', 'name', 'author', 'date', 'title',
* 'modified', 'menu_order', 'parent', 'ID', 'rand',
* 'relevance', 'RAND(x)' (where 'x' is an integer seed value),
* 'comment_count', 'meta_value', 'meta_value_num', 'post__in',
* 'post_name__in', 'post_parent__in', and the array keys
* of `$meta_query`. Default is 'date', except when a search
* is being performed, when the default is 'relevance'.
*
* @type int $p Post ID.
* @type int $page Show the number of posts that would show up on page X of a
* static front page.
* @type int $paged The number of the current page.
* @type int $page_id Page ID.
* @type string $pagename Page slug.
* @type string $perm Show posts if user has the appropriate capability.
* @type string $ping_status Ping status.
* @type array $post__in An array of post IDs to retrieve, sticky posts will be included
* @type string $post_mime_type The mime type of the post. Used for 'attachment' post_type.
* @type array $post__not_in An array of post IDs not to retrieve. Note: a string of comma-
* separated IDs will NOT work.
* @type int $post_parent Page ID to retrieve child pages for. Use 0 to only retrieve
* top-level pages.
* @type array $post_parent__in An array containing parent page IDs to query child pages from.
* @type array $post_parent__not_in An array containing parent page IDs not to query child pages from.
* @type string|array $post_type A post type slug (string) or array of post type slugs.
* Default 'any' if using 'tax_query'.
* @type string|array $post_status A post status (string) or array of post statuses.
* @type int $posts_per_page The number of posts to query for. Use -1 to request all posts.
* @type int $posts_per_archive_page The number of posts to query for by archive page. Overrides
* 'posts_per_page' when is_archive(), or is_search() are true.
* @type array $post_name__in An array of post slugs that results must match.
* @type string $s Search keyword(s). Prepending a term with a hyphen will
* exclude posts matching that term. Eg, 'pillow -sofa' will
* return posts containing 'pillow' but not 'sofa'. The
* character used for exclusion can be modified using the
* the 'wp_query_search_exclusion_prefix' filter.
* @type int $second Second of the minute. Default empty. Accepts numbers 0-60.
* @type bool $sentence Whether to search by phrase. Default false.
* @type bool $suppress_filters Whether to suppress filters. Default false.
* @type string $tag Tag slug. Comma-separated (either), Plus-separated (all).
* @type array $tag__and An array of tag ids (AND in).
* @type array $tag__in An array of tag ids (OR in).
* @type array $tag__not_in An array of tag ids (NOT in).
* @type int $tag_id Tag id or comma-separated list of IDs.
* @type array $tag_slug__and An array of tag slugs (AND in).
* @type array $tag_slug__in An array of tag slugs (OR in). unless 'ignore_sticky_posts' is
* true. Note: a string of comma-separated IDs will NOT work.
* @type array $tax_query An associative array of WP_Tax_Query arguments.
* See WP_Tax_Query->queries.
* @type string $title Post title.
* @type bool $update_post_meta_cache Whether to update the post meta cache. Default true.
* @type bool $update_post_term_cache Whether to update the post term cache. Default true.
* @type bool $lazy_load_term_meta Whether to lazy-load term meta. Setting to false will
* disable cache priming for term meta, so that each
* get_term_meta() call will hit the database.
* Defaults to the value of `$update_post_term_cache`.
* @type int $w The week number of the year. Default empty. Accepts numbers 0-53.
* @type int $year The four-digit year. Default empty. Accepts any four-digit year.
* }
*/
public function parse_query( $query = '' ) {
if ( ! empty( $query ) ) {
$this->init();
$this->query = $this->query_vars = wp_parse_args( $query );
} elseif ( ! isset( $this->query ) ) {
$this->query = $this->query_vars;
}
$this->query_vars = $this->fill_query_vars( $this->query_vars );
$qv = &$this->query_vars;
$this->query_vars_changed = true;
if ( ! empty( $qv['robots'] ) ) {
$this->is_robots = true;
}
if ( ! is_scalar( $qv['p'] ) || $qv['p'] < 0 ) {
$qv['p'] = 0;
$qv['error'] = '404';
} else {
$qv['p'] = intval( $qv['p'] );
}
$qv['page_id'] = absint( $qv['page_id'] );
$qv['year'] = absint( $qv['year'] );
$qv['monthnum'] = absint( $qv['monthnum'] );
$qv['day'] = absint( $qv['day'] );
$qv['w'] = absint( $qv['w'] );
$qv['m'] = is_scalar( $qv['m'] ) ? preg_replace( '|[^0-9]|', '', $qv['m'] ) : '';
$qv['paged'] = absint( $qv['paged'] );
$qv['cat'] = preg_replace( '|[^0-9,-]|', '', $qv['cat'] ); // comma separated list of positive or negative integers
$qv['author'] = preg_replace( '|[^0-9,-]|', '', $qv['author'] ); // comma separated list of positive or negative integers
$qv['pagename'] = trim( $qv['pagename'] );
$qv['name'] = trim( $qv['name'] );
$qv['title'] = trim( $qv['title'] );
if ( '' !== $qv['hour'] ) {
$qv['hour'] = absint( $qv['hour'] );
}
if ( '' !== $qv['minute'] ) {
$qv['minute'] = absint( $qv['minute'] );
}
if ( '' !== $qv['second'] ) {
$qv['second'] = absint( $qv['second'] );
}
if ( '' !== $qv['menu_order'] ) {
$qv['menu_order'] = absint( $qv['menu_order'] );
}
// Fairly insane upper bound for search string lengths.
if ( ! is_scalar( $qv['s'] ) || ( ! empty( $qv['s'] ) && strlen( $qv['s'] ) > 1600 ) ) {
$qv['s'] = '';
}
// Compat. Map subpost to attachment.
if ( '' != $qv['subpost'] ) {
$qv['attachment'] = $qv['subpost'];
}
if ( '' != $qv['subpost_id'] ) {
$qv['attachment_id'] = $qv['subpost_id'];
}
$qv['attachment_id'] = absint( $qv['attachment_id'] );
if ( ( '' != $qv['attachment'] ) || ! empty( $qv['attachment_id'] ) ) {
$this->is_single = true;
$this->is_attachment = true;
} elseif ( '' != $qv['name'] ) {
$this->is_single = true;
} elseif ( $qv['p'] ) {
$this->is_single = true;
} elseif ( ( '' !== $qv['hour'] ) && ( '' !== $qv['minute'] ) && ( '' !== $qv['second'] ) && ( '' != $qv['year'] ) && ( '' != $qv['monthnum'] ) && ( '' != $qv['day'] ) ) {
// If year, month, day, hour, minute, and second are set, a single
// post is being queried.
$this->is_single = true;
} elseif ( '' != $qv['static'] || '' != $qv['pagename'] || ! empty( $qv['page_id'] ) ) {
$this->is_page = true;
$this->is_single = false;
} else {
// Look for archive queries. Dates, categories, authors, search, post type archives.
if ( isset( $this->query['s'] ) ) {
$this->is_search = true;
}
if ( '' !== $qv['second'] ) {
$this->is_time = true;
$this->is_date = true;
}
if ( '' !== $qv['minute'] ) {
$this->is_time = true;
$this->is_date = true;
}
if ( '' !== $qv['hour'] ) {
$this->is_time = true;
$this->is_date = true;
}
if ( $qv['day'] ) {
if ( ! $this->is_date ) {
$date = sprintf( '%04d-%02d-%02d', $qv['year'], $qv['monthnum'], $qv['day'] );
if ( $qv['monthnum'] && $qv['year'] && ! wp_checkdate( $qv['monthnum'], $qv['day'], $qv['year'], $date ) ) {
$qv['error'] = '404';
} else {
$this->is_day = true;
$this->is_date = true;
}
}
}
if ( $qv['monthnum'] ) {
if ( ! $this->is_date ) {
if ( 12 < $qv['monthnum'] ) {
$qv['error'] = '404';
} else {
$this->is_month = true;
$this->is_date = true;
}
}
}
if ( $qv['year'] ) {
if ( ! $this->is_date ) {
$this->is_year = true;
$this->is_date = true;
}
}
if ( $qv['m'] ) {
$this->is_date = true;
if ( strlen( $qv['m'] ) > 9 ) {
$this->is_time = true;
} elseif ( strlen( $qv['m'] ) > 7 ) {
$this->is_day = true;
} elseif ( strlen( $qv['m'] ) > 5 ) {
$this->is_month = true;
} else {
$this->is_year = true;
}
}
if ( '' != $qv['w'] ) {
$this->is_date = true;
}
$this->query_vars_hash = false;
$this->parse_tax_query( $qv );
foreach ( $this->tax_query->queries as $tax_query ) {
if ( ! is_array( $tax_query ) ) {
continue;
}
if ( isset( $tax_query['operator'] ) && 'NOT IN' != $tax_query['operator'] ) {
switch ( $tax_query['taxonomy'] ) {
case 'category':
$this->is_category = true;
break;
case 'post_tag':
$this->is_tag = true;
break;
default:
$this->is_tax = true;
}
}
}
unset( $tax_query );
if ( empty( $qv['author'] ) || ( $qv['author'] == '0' ) ) {
$this->is_author = false;
} else {
$this->is_author = true;
}
if ( '' != $qv['author_name'] ) {
$this->is_author = true;
}
if ( ! empty( $qv['post_type'] ) && ! is_array( $qv['post_type'] ) ) {
$post_type_obj = get_post_type_object( $qv['post_type'] );
if ( ! empty( $post_type_obj->has_archive ) ) {
$this->is_post_type_archive = true;
}
}
if ( $this->is_post_type_archive || $this->is_date || $this->is_author || $this->is_category || $this->is_tag || $this->is_tax ) {
$this->is_archive = true;
}
}
if ( '' != $qv['feed'] ) {
$this->is_feed = true;
}
if ( '' != $qv['embed'] ) {
$this->is_embed = true;
}
if ( '' != $qv['tb'] ) {
$this->is_trackback = true;
}
if ( '' != $qv['paged'] && ( intval( $qv['paged'] ) > 1 ) ) {
$this->is_paged = true;
}
// if we're previewing inside the write screen
if ( '' != $qv['preview'] ) {
$this->is_preview = true;
}
if ( is_admin() ) {
$this->is_admin = true;
}
if ( false !== strpos( $qv['feed'], 'comments-' ) ) {
$qv['feed'] = str_replace( 'comments-', '', $qv['feed'] );
$qv['withcomments'] = 1;
}
$this->is_singular = $this->is_single || $this->is_page || $this->is_attachment;
if ( $this->is_feed && ( ! empty( $qv['withcomments'] ) || ( empty( $qv['withoutcomments'] ) && $this->is_singular ) ) ) {
$this->is_comment_feed = true;
}
if ( ! ( $this->is_singular || $this->is_archive || $this->is_search || $this->is_feed || ( defined( 'REST_REQUEST' ) && REST_REQUEST ) || $this->is_trackback || $this->is_404 || $this->is_admin || $this->is_robots ) ) {
$this->is_home = true;
}
// Correct is_* for page_on_front and page_for_posts
if ( $this->is_home && 'page' == get_option( 'show_on_front' ) && get_option( 'page_on_front' ) ) {
$_query = wp_parse_args( $this->query );
// pagename can be set and empty depending on matched rewrite rules. Ignore an empty pagename.
if ( isset( $_query['pagename'] ) && '' == $_query['pagename'] ) {
unset( $_query['pagename'] );
}
unset( $_query['embed'] );
if ( empty( $_query ) || ! array_diff( array_keys( $_query ), array( 'preview', 'page', 'paged', 'cpage' ) ) ) {
$this->is_page = true;
$this->is_home = false;
$qv['page_id'] = get_option( 'page_on_front' );
// Correct <!--nextpage--> for page_on_front
if ( ! empty( $qv['paged'] ) ) {
$qv['page'] = $qv['paged'];
unset( $qv['paged'] );
}
}
}
if ( '' != $qv['pagename'] ) {
$this->queried_object = get_page_by_path( $qv['pagename'] );
if ( $this->queried_object && 'attachment' == $this->queried_object->post_type ) {
if ( preg_match( '/^[^%]*%(?:postname)%/', get_option( 'permalink_structure' ) ) ) {
// See if we also have a post with the same slug
$post = get_page_by_path( $qv['pagename'], OBJECT, 'post' );
if ( $post ) {
$this->queried_object = $post;
$this->is_page = false;
$this->is_single = true;
}
}
}
if ( ! empty( $this->queried_object ) ) {
$this->queried_object_id = (int) $this->queried_object->ID;
} else {
unset( $this->queried_object );
}
if ( 'page' == get_option( 'show_on_front' ) && isset( $this->queried_object_id ) && $this->queried_object_id == get_option( 'page_for_posts' ) ) {
$this->is_page = false;
$this->is_home = true;
$this->is_posts_page = true;
}
}
if ( $qv['page_id'] ) {
if ( 'page' == get_option( 'show_on_front' ) && $qv['page_id'] == get_option( 'page_for_posts' ) ) {
$this->is_page = false;
$this->is_home = true;
$this->is_posts_page = true;
}
}
if ( ! empty( $qv['post_type'] ) ) {
if ( is_array( $qv['post_type'] ) ) {
$qv['post_type'] = array_map( 'sanitize_key', $qv['post_type'] );
} else {
$qv['post_type'] = sanitize_key( $qv['post_type'] );
}
}
if ( ! empty( $qv['post_status'] ) ) {
if ( is_array( $qv['post_status'] ) ) {
$qv['post_status'] = array_map( 'sanitize_key', $qv['post_status'] );
} else {
$qv['post_status'] = preg_replace( '|[^a-z0-9_,-]|', '', $qv['post_status'] );
}
}
if ( $this->is_posts_page && ( ! isset( $qv['withcomments'] ) || ! $qv['withcomments'] ) ) {
$this->is_comment_feed = false;
}
$this->is_singular = $this->is_single || $this->is_page || $this->is_attachment;
// Done correcting is_* for page_on_front and page_for_posts
if ( '404' == $qv['error'] ) {
$this->set_404();
}
$this->is_embed = $this->is_embed && ( $this->is_singular || $this->is_404 );
$this->query_vars_hash = md5( serialize( $this->query_vars ) );
$this->query_vars_changed = false;
/**
* Fires after the main query vars have been parsed.
*
* @since 1.5.0
*
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
do_action_ref_array( 'parse_query', array( &$this ) );
}
/**
* Parses various taxonomy related query vars.
*
* For BC, this method is not marked as protected. See [28987].
*
* @since 3.1.0
*
* @param array $q The query variables. Passed by reference.
*/
public function parse_tax_query( &$q ) {
if ( ! empty( $q['tax_query'] ) && is_array( $q['tax_query'] ) ) {
$tax_query = $q['tax_query'];
} else {
$tax_query = array();
}
if ( ! empty( $q['taxonomy'] ) && ! empty( $q['term'] ) ) {
$tax_query[] = array(
'taxonomy' => $q['taxonomy'],
'terms' => array( $q['term'] ),
'field' => 'slug',
);
}
foreach ( get_taxonomies( array(), 'objects' ) as $taxonomy => $t ) {
if ( 'post_tag' == $taxonomy ) {
continue; // Handled further down in the $q['tag'] block
}
if ( $t->query_var && ! empty( $q[ $t->query_var ] ) ) {
$tax_query_defaults = array(
'taxonomy' => $taxonomy,
'field' => 'slug',
);
if ( isset( $t->rewrite['hierarchical'] ) && $t->rewrite['hierarchical'] ) {
$q[ $t->query_var ] = wp_basename( $q[ $t->query_var ] );
}
$term = $q[ $t->query_var ];
if ( is_array( $term ) ) {
$term = implode( ',', $term );
}
if ( strpos( $term, '+' ) !== false ) {
$terms = preg_split( '/[+]+/', $term );
foreach ( $terms as $term ) {
$tax_query[] = array_merge(
$tax_query_defaults,
array(
'terms' => array( $term ),
)
);
}
} else {
$tax_query[] = array_merge(
$tax_query_defaults,
array(
'terms' => preg_split( '/[,]+/', $term ),
)
);
}
}
}
// If querystring 'cat' is an array, implode it.
if ( is_array( $q['cat'] ) ) {
$q['cat'] = implode( ',', $q['cat'] );
}
// Category stuff
if ( ! empty( $q['cat'] ) && ! $this->is_singular ) {
$cat_in = $cat_not_in = array();
$cat_array = preg_split( '/[,\s]+/', urldecode( $q['cat'] ) );
$cat_array = array_map( 'intval', $cat_array );
$q['cat'] = implode( ',', $cat_array );
foreach ( $cat_array as $cat ) {
if ( $cat > 0 ) {
$cat_in[] = $cat;
} elseif ( $cat < 0 ) {
$cat_not_in[] = abs( $cat );
}
}
if ( ! empty( $cat_in ) ) {
$tax_query[] = array(
'taxonomy' => 'category',
'terms' => $cat_in,
'field' => 'term_id',
'include_children' => true,
);
}
if ( ! empty( $cat_not_in ) ) {
$tax_query[] = array(
'taxonomy' => 'category',
'terms' => $cat_not_in,
'field' => 'term_id',
'operator' => 'NOT IN',
'include_children' => true,
);
}
unset( $cat_array, $cat_in, $cat_not_in );
}
if ( ! empty( $q['category__and'] ) && 1 === count( (array) $q['category__and'] ) ) {
$q['category__and'] = (array) $q['category__and'];
if ( ! isset( $q['category__in'] ) ) {
$q['category__in'] = array();
}
$q['category__in'][] = absint( reset( $q['category__and'] ) );
unset( $q['category__and'] );
}
if ( ! empty( $q['category__in'] ) ) {
$q['category__in'] = array_map( 'absint', array_unique( (array) $q['category__in'] ) );
$tax_query[] = array(
'taxonomy' => 'category',
'terms' => $q['category__in'],
'field' => 'term_id',
'include_children' => false,
);
}
if ( ! empty( $q['category__not_in'] ) ) {
$q['category__not_in'] = array_map( 'absint', array_unique( (array) $q['category__not_in'] ) );
$tax_query[] = array(
'taxonomy' => 'category',
'terms' => $q['category__not_in'],
'operator' => 'NOT IN',
'include_children' => false,
);
}
if ( ! empty( $q['category__and'] ) ) {
$q['category__and'] = array_map( 'absint', array_unique( (array) $q['category__and'] ) );
$tax_query[] = array(
'taxonomy' => 'category',
'terms' => $q['category__and'],
'field' => 'term_id',
'operator' => 'AND',
'include_children' => false,
);
}
// If querystring 'tag' is array, implode it.
if ( is_array( $q['tag'] ) ) {
$q['tag'] = implode( ',', $q['tag'] );
}
// Tag stuff
if ( '' != $q['tag'] && ! $this->is_singular && $this->query_vars_changed ) {
if ( strpos( $q['tag'], ',' ) !== false ) {
$tags = preg_split( '/[,\r\n\t ]+/', $q['tag'] );
foreach ( (array) $tags as $tag ) {
$tag = sanitize_term_field( 'slug', $tag, 0, 'post_tag', 'db' );
$q['tag_slug__in'][] = $tag;
}
} elseif ( preg_match( '/[+\r\n\t ]+/', $q['tag'] ) || ! empty( $q['cat'] ) ) {
$tags = preg_split( '/[+\r\n\t ]+/', $q['tag'] );
foreach ( (array) $tags as $tag ) {
$tag = sanitize_term_field( 'slug', $tag, 0, 'post_tag', 'db' );
$q['tag_slug__and'][] = $tag;
}
} else {
$q['tag'] = sanitize_term_field( 'slug', $q['tag'], 0, 'post_tag', 'db' );
$q['tag_slug__in'][] = $q['tag'];
}
}
if ( ! empty( $q['tag_id'] ) ) {
$q['tag_id'] = absint( $q['tag_id'] );
$tax_query[] = array(
'taxonomy' => 'post_tag',
'terms' => $q['tag_id'],
);
}
if ( ! empty( $q['tag__in'] ) ) {
$q['tag__in'] = array_map( 'absint', array_unique( (array) $q['tag__in'] ) );
$tax_query[] = array(
'taxonomy' => 'post_tag',
'terms' => $q['tag__in'],
);
}
if ( ! empty( $q['tag__not_in'] ) ) {
$q['tag__not_in'] = array_map( 'absint', array_unique( (array) $q['tag__not_in'] ) );
$tax_query[] = array(
'taxonomy' => 'post_tag',
'terms' => $q['tag__not_in'],
'operator' => 'NOT IN',
);
}
if ( ! empty( $q['tag__and'] ) ) {
$q['tag__and'] = array_map( 'absint', array_unique( (array) $q['tag__and'] ) );
$tax_query[] = array(
'taxonomy' => 'post_tag',
'terms' => $q['tag__and'],
'operator' => 'AND',
);
}
if ( ! empty( $q['tag_slug__in'] ) ) {
$q['tag_slug__in'] = array_map( 'sanitize_title_for_query', array_unique( (array) $q['tag_slug__in'] ) );
$tax_query[] = array(
'taxonomy' => 'post_tag',
'terms' => $q['tag_slug__in'],
'field' => 'slug',
);
}
if ( ! empty( $q['tag_slug__and'] ) ) {
$q['tag_slug__and'] = array_map( 'sanitize_title_for_query', array_unique( (array) $q['tag_slug__and'] ) );
$tax_query[] = array(
'taxonomy' => 'post_tag',
'terms' => $q['tag_slug__and'],
'field' => 'slug',
'operator' => 'AND',
);
}
$this->tax_query = new WP_Tax_Query( $tax_query );
/**
* Fires after taxonomy-related query vars have been parsed.
*
* @since 3.7.0
*
* @param WP_Query $this The WP_Query instance.
*/
do_action( 'parse_tax_query', $this );
}
/**
* Generates SQL for the WHERE clause based on passed search terms.
*
* @since 3.7.0
*
* @global wpdb $wpdb WordPress database abstraction object.
*
* @param array $q Query variables.
* @return string WHERE clause.
*/
protected function parse_search( &$q ) {
global $wpdb;
$search = '';
// added slashes screw with quote grouping when done early, so done later
$q['s'] = stripslashes( $q['s'] );
if ( empty( $_GET['s'] ) && $this->is_main_query() ) {
$q['s'] = urldecode( $q['s'] );
}
// there are no line breaks in <input /> fields
$q['s'] = str_replace( array( "\r", "\n" ), '', $q['s'] );
$q['search_terms_count'] = 1;
if ( ! empty( $q['sentence'] ) ) {
$q['search_terms'] = array( $q['s'] );
} else {
if ( preg_match_all( '/".*?("|$)|((?<=[\t ",+])|^)[^\t ",+]+/', $q['s'], $matches ) ) {
$q['search_terms_count'] = count( $matches[0] );
$q['search_terms'] = $this->parse_search_terms( $matches[0] );
// if the search string has only short terms or stopwords, or is 10+ terms long, match it as sentence
if ( empty( $q['search_terms'] ) || count( $q['search_terms'] ) > 9 ) {
$q['search_terms'] = array( $q['s'] );
}
} else {
$q['search_terms'] = array( $q['s'] );
}
}
$n = ! empty( $q['exact'] ) ? '' : '%';
$searchand = '';
$q['search_orderby_title'] = array();
/**
* Filters the prefix that indicates that a search term should be excluded from results.
*
* @since 4.7.0
*
* @param string $exclusion_prefix The prefix. Default '-'. Returning
* an empty value disables exclusions.
*/
$exclusion_prefix = apply_filters( 'wp_query_search_exclusion_prefix', '-' );
foreach ( $q['search_terms'] as $term ) {
// If there is an $exclusion_prefix, terms prefixed with it should be excluded.
$exclude = $exclusion_prefix && ( $exclusion_prefix === substr( $term, 0, 1 ) );
if ( $exclude ) {
$like_op = 'NOT LIKE';
$andor_op = 'AND';
$term = substr( $term, 1 );
} else {
$like_op = 'LIKE';
$andor_op = 'OR';
}
if ( $n && ! $exclude ) {
$like = '%' . $wpdb->esc_like( $term ) . '%';
$q['search_orderby_title'][] = $wpdb->prepare( "{$wpdb->posts}.post_title LIKE %s", $like );
}
$like = $n . $wpdb->esc_like( $term ) . $n;
$search .= $wpdb->prepare( "{$searchand}(({$wpdb->posts}.post_title $like_op %s) $andor_op ({$wpdb->posts}.post_excerpt $like_op %s) $andor_op ({$wpdb->posts}.post_content $like_op %s))", $like, $like, $like );
$searchand = ' AND ';
}
if ( ! empty( $search ) ) {
$search = " AND ({$search}) ";
if ( ! is_user_logged_in() ) {
$search .= " AND ({$wpdb->posts}.post_password = '') ";
}
}
return $search;
}
/**
* Check if the terms are suitable for searching.
*
* Uses an array of stopwords (terms) that are excluded from the separate
* term matching when searching for posts. The list of English stopwords is
* the approximate search engines list, and is translatable.
*
* @since 3.7.0
*
* @param string[] $terms Array of terms to check.
* @return array Terms that are not stopwords.
*/
protected function parse_search_terms( $terms ) {
$strtolower = function_exists( 'mb_strtolower' ) ? 'mb_strtolower' : 'strtolower';
$checked = array();
$stopwords = $this->get_search_stopwords();
foreach ( $terms as $term ) {
// keep before/after spaces when term is for exact match
if ( preg_match( '/^".+"$/', $term ) ) {
$term = trim( $term, "\"'" );
} else {
$term = trim( $term, "\"' " );
}
// Avoid single A-Z and single dashes.
if ( ! $term || ( 1 === strlen( $term ) && preg_match( '/^[a-z\-]$/i', $term ) ) ) {
continue;
}
if ( in_array( call_user_func( $strtolower, $term ), $stopwords, true ) ) {
continue;
}
$checked[] = $term;
}
return $checked;
}
/**
* Retrieve stopwords used when parsing search terms.
*
* @since 3.7.0
*
* @return array Stopwords.
*/
protected function get_search_stopwords() {
if ( isset( $this->stopwords ) ) {
return $this->stopwords;
}
/* translators: This is a comma-separated list of very common words that should be excluded from a search,
* like a, an, and the. These are usually called "stopwords". You should not simply translate these individual
* words into your language. Instead, look for and provide commonly accepted stopwords in your language.
*/
$words = explode(
',',
_x(
'about,an,are,as,at,be,by,com,for,from,how,in,is,it,of,on,or,that,the,this,to,was,what,when,where,who,will,with,www',
'Comma-separated list of search stopwords in your language'
)
);
$stopwords = array();
foreach ( $words as $word ) {
$word = trim( $word, "\r\n\t " );
if ( $word ) {
$stopwords[] = $word;
}
}
/**
* Filters stopwords used when parsing search terms.
*
* @since 3.7.0
*
* @param string[] $stopwords Array of stopwords.
*/
$this->stopwords = apply_filters( 'wp_search_stopwords', $stopwords );
return $this->stopwords;
}
/**
* Generates SQL for the ORDER BY condition based on passed search terms.
*
* @since 3.7.0
*
* @global wpdb $wpdb WordPress database abstraction object.
*
* @param array $q Query variables.
* @return string ORDER BY clause.
*/
protected function parse_search_order( &$q ) {
global $wpdb;
if ( $q['search_terms_count'] > 1 ) {
$num_terms = count( $q['search_orderby_title'] );
// If the search terms contain negative queries, don't bother ordering by sentence matches.
$like = '';
if ( ! preg_match( '/(?:\s|^)\-/', $q['s'] ) ) {
$like = '%' . $wpdb->esc_like( $q['s'] ) . '%';
}
$search_orderby = '';
// sentence match in 'post_title'
if ( $like ) {
$search_orderby .= $wpdb->prepare( "WHEN {$wpdb->posts}.post_title LIKE %s THEN 1 ", $like );
}
// sanity limit, sort as sentence when more than 6 terms
// (few searches are longer than 6 terms and most titles are not)
if ( $num_terms < 7 ) {
// all words in title
$search_orderby .= 'WHEN ' . implode( ' AND ', $q['search_orderby_title'] ) . ' THEN 2 ';
// any word in title, not needed when $num_terms == 1
if ( $num_terms > 1 ) {
$search_orderby .= 'WHEN ' . implode( ' OR ', $q['search_orderby_title'] ) . ' THEN 3 ';
}
}
// Sentence match in 'post_content' and 'post_excerpt'.
if ( $like ) {
$search_orderby .= $wpdb->prepare( "WHEN {$wpdb->posts}.post_excerpt LIKE %s THEN 4 ", $like );
$search_orderby .= $wpdb->prepare( "WHEN {$wpdb->posts}.post_content LIKE %s THEN 5 ", $like );
}
if ( $search_orderby ) {
$search_orderby = '(CASE ' . $search_orderby . 'ELSE 6 END)';
}
} else {
// single word or sentence search
$search_orderby = reset( $q['search_orderby_title'] ) . ' DESC';
}
return $search_orderby;
}
/**
* Converts the given orderby alias (if allowed) to a properly-prefixed value.
*
* @since 4.0.0
*
* @global wpdb $wpdb WordPress database abstraction object.
*
* @param string $orderby Alias for the field to order by.
* @return string|false Table-prefixed value to used in the ORDER clause. False otherwise.
*/
protected function parse_orderby( $orderby ) {
global $wpdb;
// Used to filter values.
$allowed_keys = array(
'post_name',
'post_author',
'post_date',
'post_title',
'post_modified',
'post_parent',
'post_type',
'name',
'author',
'date',
'title',
'modified',
'parent',
'type',
'ID',
'menu_order',
'comment_count',
'rand',
'post__in',
'post_parent__in',
'post_name__in',
);
$primary_meta_key = '';
$primary_meta_query = false;
$meta_clauses = $this->meta_query->get_clauses();
if ( ! empty( $meta_clauses ) ) {
$primary_meta_query = reset( $meta_clauses );
if ( ! empty( $primary_meta_query['key'] ) ) {
$primary_meta_key = $primary_meta_query['key'];
$allowed_keys[] = $primary_meta_key;
}
$allowed_keys[] = 'meta_value';
$allowed_keys[] = 'meta_value_num';
$allowed_keys = array_merge( $allowed_keys, array_keys( $meta_clauses ) );
}
// If RAND() contains a seed value, sanitize and add to allowed keys.
$rand_with_seed = false;
if ( preg_match( '/RAND\(([0-9]+)\)/i', $orderby, $matches ) ) {
$orderby = sprintf( 'RAND(%s)', intval( $matches[1] ) );
$allowed_keys[] = $orderby;
$rand_with_seed = true;
}
if ( ! in_array( $orderby, $allowed_keys, true ) ) {
return false;
}
$orderby_clause = '';
switch ( $orderby ) {
case 'post_name':
case 'post_author':
case 'post_date':
case 'post_title':
case 'post_modified':
case 'post_parent':
case 'post_type':
case 'ID':
case 'menu_order':
case 'comment_count':
$orderby_clause = "{$wpdb->posts}.{$orderby}";
break;
case 'rand':
$orderby_clause = 'RAND()';
break;
case $primary_meta_key:
case 'meta_value':
if ( ! empty( $primary_meta_query['type'] ) ) {
$orderby_clause = "CAST({$primary_meta_query['alias']}.meta_value AS {$primary_meta_query['cast']})";
} else {
$orderby_clause = "{$primary_meta_query['alias']}.meta_value";
}
break;
case 'meta_value_num':
$orderby_clause = "{$primary_meta_query['alias']}.meta_value+0";
break;
case 'post__in':
if ( ! empty( $this->query_vars['post__in'] ) ) {
$orderby_clause = "FIELD({$wpdb->posts}.ID," . implode( ',', array_map( 'absint', $this->query_vars['post__in'] ) ) . ')';
}
break;
case 'post_parent__in':
if ( ! empty( $this->query_vars['post_parent__in'] ) ) {
$orderby_clause = "FIELD( {$wpdb->posts}.post_parent," . implode( ', ', array_map( 'absint', $this->query_vars['post_parent__in'] ) ) . ' )';
}
break;
case 'post_name__in':
if ( ! empty( $this->query_vars['post_name__in'] ) ) {
$post_name__in = array_map( 'sanitize_title_for_query', $this->query_vars['post_name__in'] );
$post_name__in_string = "'" . implode( "','", $post_name__in ) . "'";
$orderby_clause = "FIELD( {$wpdb->posts}.post_name," . $post_name__in_string . ' )';
}
break;
default:
if ( array_key_exists( $orderby, $meta_clauses ) ) {
// $orderby corresponds to a meta_query clause.
$meta_clause = $meta_clauses[ $orderby ];
$orderby_clause = "CAST({$meta_clause['alias']}.meta_value AS {$meta_clause['cast']})";
} elseif ( $rand_with_seed ) {
$orderby_clause = $orderby;
} else {
// Default: order by post field.
$orderby_clause = "{$wpdb->posts}.post_" . sanitize_key( $orderby );
}
break;
}
return $orderby_clause;
}
/**
* Parse an 'order' query variable and cast it to ASC or DESC as necessary.
*
* @since 4.0.0
*
* @param string $order The 'order' query variable.
* @return string The sanitized 'order' query variable.
*/
protected function parse_order( $order ) {
if ( ! is_string( $order ) || empty( $order ) ) {
return 'DESC';
}
if ( 'ASC' === strtoupper( $order ) ) {
return 'ASC';
} else {
return 'DESC';
}
}
/**
* Sets the 404 property and saves whether query is feed.
*
* @since 2.0.0
*/
public function set_404() {
$is_feed = $this->is_feed;
$this->init_query_flags();
$this->is_404 = true;
$this->is_feed = $is_feed;
}
/**
* Retrieve query variable.
*
* @since 1.5.0
* @since 3.9.0 The `$default` argument was introduced.
*
* @param string $query_var Query variable key.
* @param mixed $default Optional. Value to return if the query variable is not set. Default empty.
* @return mixed Contents of the query variable.
*/
public function get( $query_var, $default = '' ) {
if ( isset( $this->query_vars[ $query_var ] ) ) {
return $this->query_vars[ $query_var ];
}
return $default;
}
/**
* Set query variable.
*
* @since 1.5.0
*
* @param string $query_var Query variable key.
* @param mixed $value Query variable value.
*/
public function set( $query_var, $value ) {
$this->query_vars[ $query_var ] = $value;
}
/**
* Retrieves an array of posts based on query variables.
*
* There are a few filters and actions that can be used to modify the post
* database query.
*
* @since 1.5.0
*
* @return WP_Post[]|int[] Array of post objects or post IDs.
*/
public function get_posts() {
global $wpdb;
$this->parse_query();
/**
* Fires after the query variable object is created, but before the actual query is run.
*
* Note: If using conditional tags, use the method versions within the passed instance
* (e.g. $this->is_main_query() instead of is_main_query()). This is because the functions
* like is_main_query() test against the global $wp_query instance, not the passed one.
*
* @since 2.0.0
*
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
do_action_ref_array( 'pre_get_posts', array( &$this ) );
// Shorthand.
$q = &$this->query_vars;
// Fill again in case pre_get_posts unset some vars.
$q = $this->fill_query_vars( $q );
// Parse meta query
$this->meta_query = new WP_Meta_Query();
$this->meta_query->parse_query_vars( $q );
// Set a flag if a pre_get_posts hook changed the query vars.
$hash = md5( serialize( $this->query_vars ) );
if ( $hash != $this->query_vars_hash ) {
$this->query_vars_changed = true;
$this->query_vars_hash = $hash;
}
unset( $hash );
// First let's clear some variables
$distinct = '';
$whichauthor = '';
$whichmimetype = '';
$where = '';
$limits = '';
$join = '';
$search = '';
$groupby = '';
$post_status_join = false;
$page = 1;
if ( isset( $q['caller_get_posts'] ) ) {
_deprecated_argument(
'WP_Query',
'3.1.0',
/* translators: 1: caller_get_posts, 2: ignore_sticky_posts */
sprintf(
__( '%1$s is deprecated. Use %2$s instead.' ),
'<code>caller_get_posts</code>',
'<code>ignore_sticky_posts</code>'
)
);
if ( ! isset( $q['ignore_sticky_posts'] ) ) {
$q['ignore_sticky_posts'] = $q['caller_get_posts'];
}
}
if ( ! isset( $q['ignore_sticky_posts'] ) ) {
$q['ignore_sticky_posts'] = false;
}
if ( ! isset( $q['suppress_filters'] ) ) {
$q['suppress_filters'] = false;
}
if ( ! isset( $q['cache_results'] ) ) {
if ( wp_using_ext_object_cache() ) {
$q['cache_results'] = false;
} else {
$q['cache_results'] = true;
}
}
if ( ! isset( $q['update_post_term_cache'] ) ) {
$q['update_post_term_cache'] = true;
}
if ( ! isset( $q['lazy_load_term_meta'] ) ) {
$q['lazy_load_term_meta'] = $q['update_post_term_cache'];
}
if ( ! isset( $q['update_post_meta_cache'] ) ) {
$q['update_post_meta_cache'] = true;
}
if ( ! isset( $q['post_type'] ) ) {
if ( $this->is_search ) {
$q['post_type'] = 'any';
} else {
$q['post_type'] = '';
}
}
$post_type = $q['post_type'];
if ( empty( $q['posts_per_page'] ) ) {
$q['posts_per_page'] = get_option( 'posts_per_page' );
}
if ( isset( $q['showposts'] ) && $q['showposts'] ) {
$q['showposts'] = (int) $q['showposts'];
$q['posts_per_page'] = $q['showposts'];
}
if ( ( isset( $q['posts_per_archive_page'] ) && $q['posts_per_archive_page'] != 0 ) && ( $this->is_archive || $this->is_search ) ) {
$q['posts_per_page'] = $q['posts_per_archive_page'];
}
if ( ! isset( $q['nopaging'] ) ) {
if ( $q['posts_per_page'] == -1 ) {
$q['nopaging'] = true;
} else {
$q['nopaging'] = false;
}
}
if ( $this->is_feed ) {
// This overrides posts_per_page.
if ( ! empty( $q['posts_per_rss'] ) ) {
$q['posts_per_page'] = $q['posts_per_rss'];
} else {
$q['posts_per_page'] = get_option( 'posts_per_rss' );
}
$q['nopaging'] = false;
}
$q['posts_per_page'] = (int) $q['posts_per_page'];
if ( $q['posts_per_page'] < -1 ) {
$q['posts_per_page'] = abs( $q['posts_per_page'] );
} elseif ( $q['posts_per_page'] == 0 ) {
$q['posts_per_page'] = 1;
}
if ( ! isset( $q['comments_per_page'] ) || $q['comments_per_page'] == 0 ) {
$q['comments_per_page'] = get_option( 'comments_per_page' );
}
if ( $this->is_home && ( empty( $this->query ) || $q['preview'] == 'true' ) && ( 'page' == get_option( 'show_on_front' ) ) && get_option( 'page_on_front' ) ) {
$this->is_page = true;
$this->is_home = false;
$q['page_id'] = get_option( 'page_on_front' );
}
if ( isset( $q['page'] ) ) {
$q['page'] = trim( $q['page'], '/' );
$q['page'] = absint( $q['page'] );
}
// If true, forcibly turns off SQL_CALC_FOUND_ROWS even when limits are present.
if ( isset( $q['no_found_rows'] ) ) {
$q['no_found_rows'] = (bool) $q['no_found_rows'];
} else {
$q['no_found_rows'] = false;
}
switch ( $q['fields'] ) {
case 'ids':
$fields = "{$wpdb->posts}.ID";
break;
case 'id=>parent':
$fields = "{$wpdb->posts}.ID, {$wpdb->posts}.post_parent";
break;
default:
$fields = "{$wpdb->posts}.*";
}
if ( '' !== $q['menu_order'] ) {
$where .= " AND {$wpdb->posts}.menu_order = " . $q['menu_order'];
}
// The "m" parameter is meant for months but accepts datetimes of varying specificity
if ( $q['m'] ) {
$where .= " AND YEAR({$wpdb->posts}.post_date)=" . substr( $q['m'], 0, 4 );
if ( strlen( $q['m'] ) > 5 ) {
$where .= " AND MONTH({$wpdb->posts}.post_date)=" . substr( $q['m'], 4, 2 );
}
if ( strlen( $q['m'] ) > 7 ) {
$where .= " AND DAYOFMONTH({$wpdb->posts}.post_date)=" . substr( $q['m'], 6, 2 );
}
if ( strlen( $q['m'] ) > 9 ) {
$where .= " AND HOUR({$wpdb->posts}.post_date)=" . substr( $q['m'], 8, 2 );
}
if ( strlen( $q['m'] ) > 11 ) {
$where .= " AND MINUTE({$wpdb->posts}.post_date)=" . substr( $q['m'], 10, 2 );
}
if ( strlen( $q['m'] ) > 13 ) {
$where .= " AND SECOND({$wpdb->posts}.post_date)=" . substr( $q['m'], 12, 2 );
}
}
// Handle the other individual date parameters
$date_parameters = array();
if ( '' !== $q['hour'] ) {
$date_parameters['hour'] = $q['hour'];
}
if ( '' !== $q['minute'] ) {
$date_parameters['minute'] = $q['minute'];
}
if ( '' !== $q['second'] ) {
$date_parameters['second'] = $q['second'];
}
if ( $q['year'] ) {
$date_parameters['year'] = $q['year'];
}
if ( $q['monthnum'] ) {
$date_parameters['monthnum'] = $q['monthnum'];
}
if ( $q['w'] ) {
$date_parameters['week'] = $q['w'];
}
if ( $q['day'] ) {
$date_parameters['day'] = $q['day'];
}
if ( $date_parameters ) {
$date_query = new WP_Date_Query( array( $date_parameters ) );
$where .= $date_query->get_sql();
}
unset( $date_parameters, $date_query );
// Handle complex date queries
if ( ! empty( $q['date_query'] ) ) {
$this->date_query = new WP_Date_Query( $q['date_query'] );
$where .= $this->date_query->get_sql();
}
// If we've got a post_type AND it's not "any" post_type.
if ( ! empty( $q['post_type'] ) && 'any' != $q['post_type'] ) {
foreach ( (array) $q['post_type'] as $_post_type ) {
$ptype_obj = get_post_type_object( $_post_type );
if ( ! $ptype_obj || ! $ptype_obj->query_var || empty( $q[ $ptype_obj->query_var ] ) ) {
continue;
}
if ( ! $ptype_obj->hierarchical ) {
// Non-hierarchical post types can directly use 'name'.
$q['name'] = $q[ $ptype_obj->query_var ];
} else {
// Hierarchical post types will operate through 'pagename'.
$q['pagename'] = $q[ $ptype_obj->query_var ];
$q['name'] = '';
}
// Only one request for a slug is possible, this is why name & pagename are overwritten above.
break;
} //end foreach
unset( $ptype_obj );
}
if ( '' !== $q['title'] ) {
$where .= $wpdb->prepare( " AND {$wpdb->posts}.post_title = %s", stripslashes( $q['title'] ) );
}
// Parameters related to 'post_name'.
if ( '' != $q['name'] ) {
$q['name'] = sanitize_title_for_query( $q['name'] );
$where .= " AND {$wpdb->posts}.post_name = '" . $q['name'] . "'";
} elseif ( '' != $q['pagename'] ) {
if ( isset( $this->queried_object_id ) ) {
$reqpage = $this->queried_object_id;
} else {
if ( 'page' != $q['post_type'] ) {
foreach ( (array) $q['post_type'] as $_post_type ) {
$ptype_obj = get_post_type_object( $_post_type );
if ( ! $ptype_obj || ! $ptype_obj->hierarchical ) {
continue;
}
$reqpage = get_page_by_path( $q['pagename'], OBJECT, $_post_type );
if ( $reqpage ) {
break;
}
}
unset( $ptype_obj );
} else {
$reqpage = get_page_by_path( $q['pagename'] );
}
if ( ! empty( $reqpage ) ) {
$reqpage = $reqpage->ID;
} else {
$reqpage = 0;
}
}
$page_for_posts = get_option( 'page_for_posts' );
if ( ( 'page' != get_option( 'show_on_front' ) ) || empty( $page_for_posts ) || ( $reqpage != $page_for_posts ) ) {
$q['pagename'] = sanitize_title_for_query( wp_basename( $q['pagename'] ) );
$q['name'] = $q['pagename'];
$where .= " AND ({$wpdb->posts}.ID = '$reqpage')";
$reqpage_obj = get_post( $reqpage );
if ( is_object( $reqpage_obj ) && 'attachment' == $reqpage_obj->post_type ) {
$this->is_attachment = true;
$post_type = $q['post_type'] = 'attachment';
$this->is_page = true;
$q['attachment_id'] = $reqpage;
}
}
} elseif ( '' != $q['attachment'] ) {
$q['attachment'] = sanitize_title_for_query( wp_basename( $q['attachment'] ) );
$q['name'] = $q['attachment'];
$where .= " AND {$wpdb->posts}.post_name = '" . $q['attachment'] . "'";
} elseif ( is_array( $q['post_name__in'] ) && ! empty( $q['post_name__in'] ) ) {
$q['post_name__in'] = array_map( 'sanitize_title_for_query', $q['post_name__in'] );
$post_name__in = "'" . implode( "','", $q['post_name__in'] ) . "'";
$where .= " AND {$wpdb->posts}.post_name IN ($post_name__in)";
}
// If an attachment is requested by number, let it supersede any post number.
if ( $q['attachment_id'] ) {
$q['p'] = absint( $q['attachment_id'] );
}
// If a post number is specified, load that post
if ( $q['p'] ) {
$where .= " AND {$wpdb->posts}.ID = " . $q['p'];
} elseif ( $q['post__in'] ) {
$post__in = implode( ',', array_map( 'absint', $q['post__in'] ) );
$where .= " AND {$wpdb->posts}.ID IN ($post__in)";
} elseif ( $q['post__not_in'] ) {
$post__not_in = implode( ',', array_map( 'absint', $q['post__not_in'] ) );
$where .= " AND {$wpdb->posts}.ID NOT IN ($post__not_in)";
}
if ( is_numeric( $q['post_parent'] ) ) {
$where .= $wpdb->prepare( " AND {$wpdb->posts}.post_parent = %d ", $q['post_parent'] );
} elseif ( $q['post_parent__in'] ) {
$post_parent__in = implode( ',', array_map( 'absint', $q['post_parent__in'] ) );
$where .= " AND {$wpdb->posts}.post_parent IN ($post_parent__in)";
} elseif ( $q['post_parent__not_in'] ) {
$post_parent__not_in = implode( ',', array_map( 'absint', $q['post_parent__not_in'] ) );
$where .= " AND {$wpdb->posts}.post_parent NOT IN ($post_parent__not_in)";
}
if ( $q['page_id'] ) {
if ( ( 'page' != get_option( 'show_on_front' ) ) || ( $q['page_id'] != get_option( 'page_for_posts' ) ) ) {
$q['p'] = $q['page_id'];
$where = " AND {$wpdb->posts}.ID = " . $q['page_id'];
}
}
// If a search pattern is specified, load the posts that match.
if ( strlen( $q['s'] ) ) {
$search = $this->parse_search( $q );
}
if ( ! $q['suppress_filters'] ) {
/**
* Filters the search SQL that is used in the WHERE clause of WP_Query.
*
* @since 3.0.0
*
* @param string $search Search SQL for WHERE clause.
* @param WP_Query $this The current WP_Query object.
*/
$search = apply_filters_ref_array( 'posts_search', array( $search, &$this ) );
}
// Taxonomies
if ( ! $this->is_singular ) {
$this->parse_tax_query( $q );
$clauses = $this->tax_query->get_sql( $wpdb->posts, 'ID' );
$join .= $clauses['join'];
$where .= $clauses['where'];
}
if ( $this->is_tax ) {
if ( empty( $post_type ) ) {
// Do a fully inclusive search for currently registered post types of queried taxonomies
$post_type = array();
$taxonomies = array_keys( $this->tax_query->queried_terms );
foreach ( get_post_types( array( 'exclude_from_search' => false ) ) as $pt ) {
$object_taxonomies = $pt === 'attachment' ? get_taxonomies_for_attachments() : get_object_taxonomies( $pt );
if ( array_intersect( $taxonomies, $object_taxonomies ) ) {
$post_type[] = $pt;
}
}
if ( ! $post_type ) {
$post_type = 'any';
} elseif ( count( $post_type ) == 1 ) {
$post_type = $post_type[0];
}
$post_status_join = true;
} elseif ( in_array( 'attachment', (array) $post_type ) ) {
$post_status_join = true;
}
}
/*
* Ensure that 'taxonomy', 'term', 'term_id', 'cat', and
* 'category_name' vars are set for backward compatibility.
*/
if ( ! empty( $this->tax_query->queried_terms ) ) {
/*
* Set 'taxonomy', 'term', and 'term_id' to the
* first taxonomy other than 'post_tag' or 'category'.
*/
if ( ! isset( $q['taxonomy'] ) ) {
foreach ( $this->tax_query->queried_terms as $queried_taxonomy => $queried_items ) {
if ( empty( $queried_items['terms'][0] ) ) {
continue;
}
if ( ! in_array( $queried_taxonomy, array( 'category', 'post_tag' ) ) ) {
$q['taxonomy'] = $queried_taxonomy;
if ( 'slug' === $queried_items['field'] ) {
$q['term'] = $queried_items['terms'][0];
} else {
$q['term_id'] = $queried_items['terms'][0];
}
// Take the first one we find.
break;
}
}
}
// 'cat', 'category_name', 'tag_id'
foreach ( $this->tax_query->queried_terms as $queried_taxonomy => $queried_items ) {
if ( empty( $queried_items['terms'][0] ) ) {
continue;
}
if ( 'category' === $queried_taxonomy ) {
$the_cat = get_term_by( $queried_items['field'], $queried_items['terms'][0], 'category' );
if ( $the_cat ) {
$this->set( 'cat', $the_cat->term_id );
$this->set( 'category_name', $the_cat->slug );
}
unset( $the_cat );
}
if ( 'post_tag' === $queried_taxonomy ) {
$the_tag = get_term_by( $queried_items['field'], $queried_items['terms'][0], 'post_tag' );
if ( $the_tag ) {
$this->set( 'tag_id', $the_tag->term_id );
}
unset( $the_tag );
}
}
}
if ( ! empty( $this->tax_query->queries ) || ! empty( $this->meta_query->queries ) ) {
$groupby = "{$wpdb->posts}.ID";
}
// Author/user stuff
if ( ! empty( $q['author'] ) && $q['author'] != '0' ) {
$q['author'] = addslashes_gpc( '' . urldecode( $q['author'] ) );
$authors = array_unique( array_map( 'intval', preg_split( '/[,\s]+/', $q['author'] ) ) );
foreach ( $authors as $author ) {
$key = $author > 0 ? 'author__in' : 'author__not_in';
$q[ $key ][] = abs( $author );
}
$q['author'] = implode( ',', $authors );
}
if ( ! empty( $q['author__not_in'] ) ) {
$author__not_in = implode( ',', array_map( 'absint', array_unique( (array) $q['author__not_in'] ) ) );
$where .= " AND {$wpdb->posts}.post_author NOT IN ($author__not_in) ";
} elseif ( ! empty( $q['author__in'] ) ) {
$author__in = implode( ',', array_map( 'absint', array_unique( (array) $q['author__in'] ) ) );
$where .= " AND {$wpdb->posts}.post_author IN ($author__in) ";
}
// Author stuff for nice URLs
if ( '' != $q['author_name'] ) {
if ( strpos( $q['author_name'], '/' ) !== false ) {
$q['author_name'] = explode( '/', $q['author_name'] );
if ( $q['author_name'][ count( $q['author_name'] ) - 1 ] ) {
$q['author_name'] = $q['author_name'][ count( $q['author_name'] ) - 1 ]; // no trailing slash
} else {
$q['author_name'] = $q['author_name'][ count( $q['author_name'] ) - 2 ]; // there was a trailing slash
}
}
$q['author_name'] = sanitize_title_for_query( $q['author_name'] );
$q['author'] = get_user_by( 'slug', $q['author_name'] );
if ( $q['author'] ) {
$q['author'] = $q['author']->ID;
}
$whichauthor .= " AND ({$wpdb->posts}.post_author = " . absint( $q['author'] ) . ')';
}
// Matching by comment count.
if ( isset( $q['comment_count'] ) ) {
// Numeric comment count is converted to array format.
if ( is_numeric( $q['comment_count'] ) ) {
$q['comment_count'] = array(
'value' => intval( $q['comment_count'] ),
);
}
if ( isset( $q['comment_count']['value'] ) ) {
$q['comment_count'] = array_merge(
array(
'compare' => '=',
),
$q['comment_count']
);
// Fallback for invalid compare operators is '='.
$compare_operators = array( '=', '!=', '>', '>=', '<', '<=' );
if ( ! in_array( $q['comment_count']['compare'], $compare_operators, true ) ) {
$q['comment_count']['compare'] = '=';
}
$where .= $wpdb->prepare( " AND {$wpdb->posts}.comment_count {$q['comment_count']['compare']} %d", $q['comment_count']['value'] );
}
}
// MIME-Type stuff for attachment browsing
if ( isset( $q['post_mime_type'] ) && '' != $q['post_mime_type'] ) {
$whichmimetype = wp_post_mime_type_where( $q['post_mime_type'], $wpdb->posts );
}
$where .= $search . $whichauthor . $whichmimetype;
if ( ! empty( $this->meta_query->queries ) ) {
$clauses = $this->meta_query->get_sql( 'post', $wpdb->posts, 'ID', $this );
$join .= $clauses['join'];
$where .= $clauses['where'];
}
$rand = ( isset( $q['orderby'] ) && 'rand' === $q['orderby'] );
if ( ! isset( $q['order'] ) ) {
$q['order'] = $rand ? '' : 'DESC';
} else {
$q['order'] = $rand ? '' : $this->parse_order( $q['order'] );
}
// These values of orderby should ignore the 'order' parameter.
$force_asc = array( 'post__in', 'post_name__in', 'post_parent__in' );
if ( isset( $q['orderby'] ) && in_array( $q['orderby'], $force_asc, true ) ) {
$q['order'] = '';
}
// Order by.
if ( empty( $q['orderby'] ) ) {
/*
* Boolean false or empty array blanks out ORDER BY,
* while leaving the value unset or otherwise empty sets the default.
*/
if ( isset( $q['orderby'] ) && ( is_array( $q['orderby'] ) || false === $q['orderby'] ) ) {
$orderby = '';
} else {
$orderby = "{$wpdb->posts}.post_date " . $q['order'];
}
} elseif ( 'none' == $q['orderby'] ) {
$orderby = '';
} else {
$orderby_array = array();
if ( is_array( $q['orderby'] ) ) {
foreach ( $q['orderby'] as $_orderby => $order ) {
$orderby = addslashes_gpc( urldecode( $_orderby ) );
$parsed = $this->parse_orderby( $orderby );
if ( ! $parsed ) {
continue;
}
$orderby_array[] = $parsed . ' ' . $this->parse_order( $order );
}
$orderby = implode( ', ', $orderby_array );
} else {
$q['orderby'] = urldecode( $q['orderby'] );
$q['orderby'] = addslashes_gpc( $q['orderby'] );
foreach ( explode( ' ', $q['orderby'] ) as $i => $orderby ) {
$parsed = $this->parse_orderby( $orderby );
// Only allow certain values for safety.
if ( ! $parsed ) {
continue;
}
$orderby_array[] = $parsed;
}
$orderby = implode( ' ' . $q['order'] . ', ', $orderby_array );
if ( empty( $orderby ) ) {
$orderby = "{$wpdb->posts}.post_date " . $q['order'];
} elseif ( ! empty( $q['order'] ) ) {
$orderby .= " {$q['order']}";
}
}
}
// Order search results by relevance only when another "orderby" is not specified in the query.
if ( ! empty( $q['s'] ) ) {
$search_orderby = '';
if ( ! empty( $q['search_orderby_title'] ) && ( empty( $q['orderby'] ) && ! $this->is_feed ) || ( isset( $q['orderby'] ) && 'relevance' === $q['orderby'] ) ) {
$search_orderby = $this->parse_search_order( $q );
}
if ( ! $q['suppress_filters'] ) {
/**
* Filters the ORDER BY used when ordering search results.
*
* @since 3.7.0
*
* @param string $search_orderby The ORDER BY clause.
* @param WP_Query $this The current WP_Query instance.
*/
$search_orderby = apply_filters( 'posts_search_orderby', $search_orderby, $this );
}
if ( $search_orderby ) {
$orderby = $orderby ? $search_orderby . ', ' . $orderby : $search_orderby;
}
}
if ( is_array( $post_type ) && count( $post_type ) > 1 ) {
$post_type_cap = 'multiple_post_type';
} else {
if ( is_array( $post_type ) ) {
$post_type = reset( $post_type );
}
$post_type_object = get_post_type_object( $post_type );
if ( empty( $post_type_object ) ) {
$post_type_cap = $post_type;
}
}
if ( isset( $q['post_password'] ) ) {
$where .= $wpdb->prepare( " AND {$wpdb->posts}.post_password = %s", $q['post_password'] );
if ( empty( $q['perm'] ) ) {
$q['perm'] = 'readable';
}
} elseif ( isset( $q['has_password'] ) ) {
$where .= sprintf( " AND {$wpdb->posts}.post_password %s ''", $q['has_password'] ? '!=' : '=' );
}
if ( ! empty( $q['comment_status'] ) ) {
$where .= $wpdb->prepare( " AND {$wpdb->posts}.comment_status = %s ", $q['comment_status'] );
}
if ( ! empty( $q['ping_status'] ) ) {
$where .= $wpdb->prepare( " AND {$wpdb->posts}.ping_status = %s ", $q['ping_status'] );
}
if ( 'any' == $post_type ) {
$in_search_post_types = get_post_types( array( 'exclude_from_search' => false ) );
if ( empty( $in_search_post_types ) ) {
$where .= ' AND 1=0 ';
} else {
$where .= " AND {$wpdb->posts}.post_type IN ('" . join( "', '", array_map( 'esc_sql', $in_search_post_types ) ) . "')";
}
} elseif ( ! empty( $post_type ) && is_array( $post_type ) ) {
$where .= " AND {$wpdb->posts}.post_type IN ('" . join( "', '", esc_sql( $post_type ) ) . "')";
} elseif ( ! empty( $post_type ) ) {
$where .= $wpdb->prepare( " AND {$wpdb->posts}.post_type = %s", $post_type );
$post_type_object = get_post_type_object( $post_type );
} elseif ( $this->is_attachment ) {
$where .= " AND {$wpdb->posts}.post_type = 'attachment'";
$post_type_object = get_post_type_object( 'attachment' );
} elseif ( $this->is_page ) {
$where .= " AND {$wpdb->posts}.post_type = 'page'";
$post_type_object = get_post_type_object( 'page' );
} else {
$where .= " AND {$wpdb->posts}.post_type = 'post'";
$post_type_object = get_post_type_object( 'post' );
}
$edit_cap = 'edit_post';
$read_cap = 'read_post';
if ( ! empty( $post_type_object ) ) {
$edit_others_cap = $post_type_object->cap->edit_others_posts;
$read_private_cap = $post_type_object->cap->read_private_posts;
} else {
$edit_others_cap = 'edit_others_' . $post_type_cap . 's';
$read_private_cap = 'read_private_' . $post_type_cap . 's';
}
$user_id = get_current_user_id();
$q_status = array();
if ( ! empty( $q['post_status'] ) ) {
$statuswheres = array();
$q_status = $q['post_status'];
if ( ! is_array( $q_status ) ) {
$q_status = explode( ',', $q_status );
}
$r_status = array();
$p_status = array();
$e_status = array();
if ( in_array( 'any', $q_status ) ) {
foreach ( get_post_stati( array( 'exclude_from_search' => true ) ) as $status ) {
if ( ! in_array( $status, $q_status ) ) {
$e_status[] = "{$wpdb->posts}.post_status <> '$status'";
}
}
} else {
foreach ( get_post_stati() as $status ) {
if ( in_array( $status, $q_status ) ) {
if ( 'private' == $status ) {
$p_status[] = "{$wpdb->posts}.post_status = '$status'";
} else {
$r_status[] = "{$wpdb->posts}.post_status = '$status'";
}
}
}
}
if ( empty( $q['perm'] ) || 'readable' != $q['perm'] ) {
$r_status = array_merge( $r_status, $p_status );
unset( $p_status );
}
if ( ! empty( $e_status ) ) {
$statuswheres[] = '(' . join( ' AND ', $e_status ) . ')';
}
if ( ! empty( $r_status ) ) {
if ( ! empty( $q['perm'] ) && 'editable' == $q['perm'] && ! current_user_can( $edit_others_cap ) ) {
$statuswheres[] = "({$wpdb->posts}.post_author = $user_id " . 'AND (' . join( ' OR ', $r_status ) . '))';
} else {
$statuswheres[] = '(' . join( ' OR ', $r_status ) . ')';
}
}
if ( ! empty( $p_status ) ) {
if ( ! empty( $q['perm'] ) && 'readable' == $q['perm'] && ! current_user_can( $read_private_cap ) ) {
$statuswheres[] = "({$wpdb->posts}.post_author = $user_id " . 'AND (' . join( ' OR ', $p_status ) . '))';
} else {
$statuswheres[] = '(' . join( ' OR ', $p_status ) . ')';
}
}
if ( $post_status_join ) {
$join .= " LEFT JOIN {$wpdb->posts} AS p2 ON ({$wpdb->posts}.post_parent = p2.ID) ";
foreach ( $statuswheres as $index => $statuswhere ) {
$statuswheres[ $index ] = "($statuswhere OR ({$wpdb->posts}.post_status = 'inherit' AND " . str_replace( $wpdb->posts, 'p2', $statuswhere ) . '))';
}
}
$where_status = implode( ' OR ', $statuswheres );
if ( ! empty( $where_status ) ) {
$where .= " AND ($where_status)";
}
} elseif ( ! $this->is_singular ) {
$where .= " AND ({$wpdb->posts}.post_status = 'publish'";
// Add public states.
$public_states = get_post_stati( array( 'public' => true ) );
foreach ( (array) $public_states as $state ) {
if ( 'publish' == $state ) { // Publish is hard-coded above.
continue;
}
$where .= " OR {$wpdb->posts}.post_status = '$state'";
}
if ( $this->is_admin ) {
// Add protected states that should show in the admin all list.
$admin_all_states = get_post_stati(
array(
'protected' => true,
'show_in_admin_all_list' => true,
)
);
foreach ( (array) $admin_all_states as $state ) {
$where .= " OR {$wpdb->posts}.post_status = '$state'";
}
}
if ( is_user_logged_in() ) {
// Add private states that are limited to viewing by the author of a post or someone who has caps to read private states.
$private_states = get_post_stati( array( 'private' => true ) );
foreach ( (array) $private_states as $state ) {
$where .= current_user_can( $read_private_cap ) ? " OR {$wpdb->posts}.post_status = '$state'" : " OR {$wpdb->posts}.post_author = $user_id AND {$wpdb->posts}.post_status = '$state'";
}
}
$where .= ')';
}
/*
* Apply filters on where and join prior to paging so that any
* manipulations to them are reflected in the paging by day queries.
*/
if ( ! $q['suppress_filters'] ) {
/**
* Filters the WHERE clause of the query.
*
* @since 1.5.0
*
* @param string $where The WHERE clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$where = apply_filters_ref_array( 'posts_where', array( $where, &$this ) );
/**
* Filters the JOIN clause of the query.
*
* @since 1.5.0
*
* @param string $join The JOIN clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$join = apply_filters_ref_array( 'posts_join', array( $join, &$this ) );
}
// Paging
if ( empty( $q['nopaging'] ) && ! $this->is_singular ) {
$page = absint( $q['paged'] );
if ( ! $page ) {
$page = 1;
}
// If 'offset' is provided, it takes precedence over 'paged'.
if ( isset( $q['offset'] ) && is_numeric( $q['offset'] ) ) {
$q['offset'] = absint( $q['offset'] );
$pgstrt = $q['offset'] . ', ';
} else {
$pgstrt = absint( ( $page - 1 ) * $q['posts_per_page'] ) . ', ';
}
$limits = 'LIMIT ' . $pgstrt . $q['posts_per_page'];
}
// Comments feeds
if ( $this->is_comment_feed && ! $this->is_singular ) {
if ( $this->is_archive || $this->is_search ) {
$cjoin = "JOIN {$wpdb->posts} ON ({$wpdb->comments}.comment_post_ID = {$wpdb->posts}.ID) $join ";
$cwhere = "WHERE comment_approved = '1' $where";
$cgroupby = "{$wpdb->comments}.comment_id";
} else { // Other non singular e.g. front
$cjoin = "JOIN {$wpdb->posts} ON ( {$wpdb->comments}.comment_post_ID = {$wpdb->posts}.ID )";
$cwhere = "WHERE ( post_status = 'publish' OR ( post_status = 'inherit' AND post_type = 'attachment' ) ) AND comment_approved = '1'";
$cgroupby = '';
}
if ( ! $q['suppress_filters'] ) {
/**
* Filters the JOIN clause of the comments feed query before sending.
*
* @since 2.2.0
*
* @param string $cjoin The JOIN clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$cjoin = apply_filters_ref_array( 'comment_feed_join', array( $cjoin, &$this ) );
/**
* Filters the WHERE clause of the comments feed query before sending.
*
* @since 2.2.0
*
* @param string $cwhere The WHERE clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$cwhere = apply_filters_ref_array( 'comment_feed_where', array( $cwhere, &$this ) );
/**
* Filters the GROUP BY clause of the comments feed query before sending.
*
* @since 2.2.0
*
* @param string $cgroupby The GROUP BY clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$cgroupby = apply_filters_ref_array( 'comment_feed_groupby', array( $cgroupby, &$this ) );
/**
* Filters the ORDER BY clause of the comments feed query before sending.
*
* @since 2.8.0
*
* @param string $corderby The ORDER BY clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$corderby = apply_filters_ref_array( 'comment_feed_orderby', array( 'comment_date_gmt DESC', &$this ) );
/**
* Filters the LIMIT clause of the comments feed query before sending.
*
* @since 2.8.0
*
* @param string $climits The JOIN clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$climits = apply_filters_ref_array( 'comment_feed_limits', array( 'LIMIT ' . get_option( 'posts_per_rss' ), &$this ) );
}
$cgroupby = ( ! empty( $cgroupby ) ) ? 'GROUP BY ' . $cgroupby : '';
$corderby = ( ! empty( $corderby ) ) ? 'ORDER BY ' . $corderby : '';
$comments = (array) $wpdb->get_results( "SELECT $distinct {$wpdb->comments}.* FROM {$wpdb->comments} $cjoin $cwhere $cgroupby $corderby $climits" );
// Convert to WP_Comment
$this->comments = array_map( 'get_comment', $comments );
$this->comment_count = count( $this->comments );
$post_ids = array();
foreach ( $this->comments as $comment ) {
$post_ids[] = (int) $comment->comment_post_ID;
}
$post_ids = join( ',', $post_ids );
$join = '';
if ( $post_ids ) {
$where = "AND {$wpdb->posts}.ID IN ($post_ids) ";
} else {
$where = 'AND 0';
}
}
$pieces = array( 'where', 'groupby', 'join', 'orderby', 'distinct', 'fields', 'limits' );
/*
* Apply post-paging filters on where and join. Only plugins that
* manipulate paging queries should use these hooks.
*/
if ( ! $q['suppress_filters'] ) {
/**
* Filters the WHERE clause of the query.
*
* Specifically for manipulating paging queries.
*
* @since 1.5.0
*
* @param string $where The WHERE clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$where = apply_filters_ref_array( 'posts_where_paged', array( $where, &$this ) );
/**
* Filters the GROUP BY clause of the query.
*
* @since 2.0.0
*
* @param string $groupby The GROUP BY clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$groupby = apply_filters_ref_array( 'posts_groupby', array( $groupby, &$this ) );
/**
* Filters the JOIN clause of the query.
*
* Specifically for manipulating paging queries.
*
* @since 1.5.0
*
* @param string $join The JOIN clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$join = apply_filters_ref_array( 'posts_join_paged', array( $join, &$this ) );
/**
* Filters the ORDER BY clause of the query.
*
* @since 1.5.1
*
* @param string $orderby The ORDER BY clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$orderby = apply_filters_ref_array( 'posts_orderby', array( $orderby, &$this ) );
/**
* Filters the DISTINCT clause of the query.
*
* @since 2.1.0
*
* @param string $distinct The DISTINCT clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$distinct = apply_filters_ref_array( 'posts_distinct', array( $distinct, &$this ) );
/**
* Filters the LIMIT clause of the query.
*
* @since 2.1.0
*
* @param string $limits The LIMIT clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$limits = apply_filters_ref_array( 'post_limits', array( $limits, &$this ) );
/**
* Filters the SELECT clause of the query.
*
* @since 2.1.0
*
* @param string $fields The SELECT clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$fields = apply_filters_ref_array( 'posts_fields', array( $fields, &$this ) );
/**
* Filters all query clauses at once, for convenience.
*
* Covers the WHERE, GROUP BY, JOIN, ORDER BY, DISTINCT,
* fields (SELECT), and LIMITS clauses.
*
* @since 3.1.0
*
* @param string[] $clauses Associative array of the clauses for the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$clauses = (array) apply_filters_ref_array( 'posts_clauses', array( compact( $pieces ), &$this ) );
$where = isset( $clauses['where'] ) ? $clauses['where'] : '';
$groupby = isset( $clauses['groupby'] ) ? $clauses['groupby'] : '';
$join = isset( $clauses['join'] ) ? $clauses['join'] : '';
$orderby = isset( $clauses['orderby'] ) ? $clauses['orderby'] : '';
$distinct = isset( $clauses['distinct'] ) ? $clauses['distinct'] : '';
$fields = isset( $clauses['fields'] ) ? $clauses['fields'] : '';
$limits = isset( $clauses['limits'] ) ? $clauses['limits'] : '';
}
/**
* Fires to announce the query's current selection parameters.
*
* For use by caching plugins.
*
* @since 2.3.0
*
* @param string $selection The assembled selection query.
*/
do_action( 'posts_selection', $where . $groupby . $orderby . $limits . $join );
/*
* Filters again for the benefit of caching plugins.
* Regular plugins should use the hooks above.
*/
if ( ! $q['suppress_filters'] ) {
/**
* Filters the WHERE clause of the query.
*
* For use by caching plugins.
*
* @since 2.5.0
*
* @param string $where The WHERE clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$where = apply_filters_ref_array( 'posts_where_request', array( $where, &$this ) );
/**
* Filters the GROUP BY clause of the query.
*
* For use by caching plugins.
*
* @since 2.5.0
*
* @param string $groupby The GROUP BY clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$groupby = apply_filters_ref_array( 'posts_groupby_request', array( $groupby, &$this ) );
/**
* Filters the JOIN clause of the query.
*
* For use by caching plugins.
*
* @since 2.5.0
*
* @param string $join The JOIN clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$join = apply_filters_ref_array( 'posts_join_request', array( $join, &$this ) );
/**
* Filters the ORDER BY clause of the query.
*
* For use by caching plugins.
*
* @since 2.5.0
*
* @param string $orderby The ORDER BY clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$orderby = apply_filters_ref_array( 'posts_orderby_request', array( $orderby, &$this ) );
/**
* Filters the DISTINCT clause of the query.
*
* For use by caching plugins.
*
* @since 2.5.0
*
* @param string $distinct The DISTINCT clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$distinct = apply_filters_ref_array( 'posts_distinct_request', array( $distinct, &$this ) );
/**
* Filters the SELECT clause of the query.
*
* For use by caching plugins.
*
* @since 2.5.0
*
* @param string $fields The SELECT clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$fields = apply_filters_ref_array( 'posts_fields_request', array( $fields, &$this ) );
/**
* Filters the LIMIT clause of the query.
*
* For use by caching plugins.
*
* @since 2.5.0
*
* @param string $limits The LIMIT clause of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$limits = apply_filters_ref_array( 'post_limits_request', array( $limits, &$this ) );
/**
* Filters all query clauses at once, for convenience.
*
* For use by caching plugins.
*
* Covers the WHERE, GROUP BY, JOIN, ORDER BY, DISTINCT,
* fields (SELECT), and LIMITS clauses.
*
* @since 3.1.0
*
* @param string[] $pieces Associative array of the pieces of the query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$clauses = (array) apply_filters_ref_array( 'posts_clauses_request', array( compact( $pieces ), &$this ) );
$where = isset( $clauses['where'] ) ? $clauses['where'] : '';
$groupby = isset( $clauses['groupby'] ) ? $clauses['groupby'] : '';
$join = isset( $clauses['join'] ) ? $clauses['join'] : '';
$orderby = isset( $clauses['orderby'] ) ? $clauses['orderby'] : '';
$distinct = isset( $clauses['distinct'] ) ? $clauses['distinct'] : '';
$fields = isset( $clauses['fields'] ) ? $clauses['fields'] : '';
$limits = isset( $clauses['limits'] ) ? $clauses['limits'] : '';
}
if ( ! empty( $groupby ) ) {
$groupby = 'GROUP BY ' . $groupby;
}
if ( ! empty( $orderby ) ) {
$orderby = 'ORDER BY ' . $orderby;
}
$found_rows = '';
if ( ! $q['no_found_rows'] && ! empty( $limits ) ) {
$found_rows = 'SQL_CALC_FOUND_ROWS';
}
$this->request = $old_request = "SELECT $found_rows $distinct $fields FROM {$wpdb->posts} $join WHERE 1=1 $where $groupby $orderby $limits";
if ( ! $q['suppress_filters'] ) {
/**
* Filters the completed SQL query before sending.
*
* @since 2.0.0
*
* @param string $request The complete SQL query.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$this->request = apply_filters_ref_array( 'posts_request', array( $this->request, &$this ) );
}
/**
* Filters the posts array before the query takes place.
*
* Return a non-null value to bypass WordPress's default post queries.
*
* Filtering functions that require pagination information are encouraged to set
* the `found_posts` and `max_num_pages` properties of the WP_Query object,
* passed to the filter by reference. If WP_Query does not perform a database
* query, it will not have enough information to generate these values itself.
*
* @since 4.6.0
*
* @param array|null $posts Return an array of post data to short-circuit WP's query,
* or null to allow WP to run its normal queries.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$this->posts = apply_filters_ref_array( 'posts_pre_query', array( null, &$this ) );
if ( 'ids' == $q['fields'] ) {
if ( null === $this->posts ) {
$this->posts = $wpdb->get_col( $this->request );
}
$this->posts = array_map( 'intval', $this->posts );
$this->post_count = count( $this->posts );
$this->set_found_posts( $q, $limits );
return $this->posts;
}
if ( 'id=>parent' == $q['fields'] ) {
if ( null === $this->posts ) {
$this->posts = $wpdb->get_results( $this->request );
}
$this->post_count = count( $this->posts );
$this->set_found_posts( $q, $limits );
$r = array();
foreach ( $this->posts as $key => $post ) {
$this->posts[ $key ]->ID = (int) $post->ID;
$this->posts[ $key ]->post_parent = (int) $post->post_parent;
$r[ (int) $post->ID ] = (int) $post->post_parent;
}
return $r;
}
if ( null === $this->posts ) {
$split_the_query = ( $old_request == $this->request && "{$wpdb->posts}.*" == $fields && ! empty( $limits ) && $q['posts_per_page'] < 500 );
/**
* Filters whether to split the query.
*
* Splitting the query will cause it to fetch just the IDs of the found posts
* (and then individually fetch each post by ID), rather than fetching every
* complete row at once. One massive result vs. many small results.
*
* @since 3.4.0
*
* @param bool $split_the_query Whether or not to split the query.
* @param WP_Query $this The WP_Query instance.
*/
$split_the_query = apply_filters( 'split_the_query', $split_the_query, $this );
if ( $split_the_query ) {
// First get the IDs and then fill in the objects
$this->request = "SELECT $found_rows $distinct {$wpdb->posts}.ID FROM {$wpdb->posts} $join WHERE 1=1 $where $groupby $orderby $limits";
/**
* Filters the Post IDs SQL request before sending.
*
* @since 3.4.0
*
* @param string $request The post ID request.
* @param WP_Query $this The WP_Query instance.
*/
$this->request = apply_filters( 'posts_request_ids', $this->request, $this );
$ids = $wpdb->get_col( $this->request );
if ( $ids ) {
$this->posts = $ids;
$this->set_found_posts( $q, $limits );
_prime_post_caches( $ids, $q['update_post_term_cache'], $q['update_post_meta_cache'] );
} else {
$this->posts = array();
}
} else {
$this->posts = $wpdb->get_results( $this->request );
$this->set_found_posts( $q, $limits );
}
}
// Convert to WP_Post objects.
if ( $this->posts ) {
$this->posts = array_map( 'get_post', $this->posts );
}
if ( ! $q['suppress_filters'] ) {
/**
* Filters the raw post results array, prior to status checks.
*
* @since 2.3.0
*
* @param WP_Post[] $posts Array of post objects.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$this->posts = apply_filters_ref_array( 'posts_results', array( $this->posts, &$this ) );
}
if ( ! empty( $this->posts ) && $this->is_comment_feed && $this->is_singular ) {
/** This filter is documented in wp-includes/query.php */
$cjoin = apply_filters_ref_array( 'comment_feed_join', array( '', &$this ) );
/** This filter is documented in wp-includes/query.php */
$cwhere = apply_filters_ref_array( 'comment_feed_where', array( "WHERE comment_post_ID = '{$this->posts[0]->ID}' AND comment_approved = '1'", &$this ) );
/** This filter is documented in wp-includes/query.php */
$cgroupby = apply_filters_ref_array( 'comment_feed_groupby', array( '', &$this ) );
$cgroupby = ( ! empty( $cgroupby ) ) ? 'GROUP BY ' . $cgroupby : '';
/** This filter is documented in wp-includes/query.php */
$corderby = apply_filters_ref_array( 'comment_feed_orderby', array( 'comment_date_gmt DESC', &$this ) );
$corderby = ( ! empty( $corderby ) ) ? 'ORDER BY ' . $corderby : '';
/** This filter is documented in wp-includes/query.php */
$climits = apply_filters_ref_array( 'comment_feed_limits', array( 'LIMIT ' . get_option( 'posts_per_rss' ), &$this ) );
$comments_request = "SELECT {$wpdb->comments}.* FROM {$wpdb->comments} $cjoin $cwhere $cgroupby $corderby $climits";
$comments = $wpdb->get_results( $comments_request );
// Convert to WP_Comment
$this->comments = array_map( 'get_comment', $comments );
$this->comment_count = count( $this->comments );
}
// Check post status to determine if post should be displayed.
if ( ! empty( $this->posts ) && ( $this->is_single || $this->is_page ) ) {
$status = get_post_status( $this->posts[0] );
if ( 'attachment' === $this->posts[0]->post_type && 0 === (int) $this->posts[0]->post_parent ) {
$this->is_page = false;
$this->is_single = true;
$this->is_attachment = true;
}
$post_status_obj = get_post_status_object( $status );
// If the post_status was specifically requested, let it pass through.
if ( ! $post_status_obj->public && ! in_array( $status, $q_status ) ) {
if ( ! is_user_logged_in() ) {
// User must be logged in to view unpublished posts.
$this->posts = array();
} else {
if ( $post_status_obj->protected ) {
// User must have edit permissions on the draft to preview.
if ( ! current_user_can( $edit_cap, $this->posts[0]->ID ) ) {
$this->posts = array();
} else {
$this->is_preview = true;
if ( 'future' != $status ) {
$this->posts[0]->post_date = current_time( 'mysql' );
}
}
} elseif ( $post_status_obj->private ) {
if ( ! current_user_can( $read_cap, $this->posts[0]->ID ) ) {
$this->posts = array();
}
} else {
$this->posts = array();
}
}
}
if ( $this->is_preview && $this->posts && current_user_can( $edit_cap, $this->posts[0]->ID ) ) {
/**
* Filters the single post for preview mode.
*
* @since 2.7.0
*
* @param WP_Post $post_preview The Post object.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$this->posts[0] = get_post( apply_filters_ref_array( 'the_preview', array( $this->posts[0], &$this ) ) );
}
}
// Put sticky posts at the top of the posts array
$sticky_posts = get_option( 'sticky_posts' );
if ( $this->is_home && $page <= 1 && is_array( $sticky_posts ) && ! empty( $sticky_posts ) && ! $q['ignore_sticky_posts'] ) {
$num_posts = count( $this->posts );
$sticky_offset = 0;
// Loop over posts and relocate stickies to the front.
for ( $i = 0; $i < $num_posts; $i++ ) {
if ( in_array( $this->posts[ $i ]->ID, $sticky_posts ) ) {
$sticky_post = $this->posts[ $i ];
// Remove sticky from current position
array_splice( $this->posts, $i, 1 );
// Move to front, after other stickies
array_splice( $this->posts, $sticky_offset, 0, array( $sticky_post ) );
// Increment the sticky offset. The next sticky will be placed at this offset.
$sticky_offset++;
// Remove post from sticky posts array
$offset = array_search( $sticky_post->ID, $sticky_posts );
unset( $sticky_posts[ $offset ] );
}
}
// If any posts have been excluded specifically, Ignore those that are sticky.
if ( ! empty( $sticky_posts ) && ! empty( $q['post__not_in'] ) ) {
$sticky_posts = array_diff( $sticky_posts, $q['post__not_in'] );
}
// Fetch sticky posts that weren't in the query results
if ( ! empty( $sticky_posts ) ) {
$stickies = get_posts(
array(
'post__in' => $sticky_posts,
'post_type' => $post_type,
'post_status' => 'publish',
'nopaging' => true,
)
);
foreach ( $stickies as $sticky_post ) {
array_splice( $this->posts, $sticky_offset, 0, array( $sticky_post ) );
$sticky_offset++;
}
}
}
// If comments have been fetched as part of the query, make sure comment meta lazy-loading is set up.
if ( ! empty( $this->comments ) ) {
wp_queue_comments_for_comment_meta_lazyload( $this->comments );
}
if ( ! $q['suppress_filters'] ) {
/**
* Filters the array of retrieved posts after they've been fetched and
* internally processed.
*
* @since 1.5.0
*
* @param WP_Post[] $posts Array of post objects.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$this->posts = apply_filters_ref_array( 'the_posts', array( $this->posts, &$this ) );
}
// Ensure that any posts added/modified via one of the filters above are
// of the type WP_Post and are filtered.
if ( $this->posts ) {
$this->post_count = count( $this->posts );
$this->posts = array_map( 'get_post', $this->posts );
if ( $q['cache_results'] ) {
update_post_caches( $this->posts, $post_type, $q['update_post_term_cache'], $q['update_post_meta_cache'] );
}
$this->post = reset( $this->posts );
} else {
$this->post_count = 0;
$this->posts = array();
}
if ( $q['lazy_load_term_meta'] ) {
wp_queue_posts_for_term_meta_lazyload( $this->posts );
}
return $this->posts;
}
/**
* Set up the amount of found posts and the number of pages (if limit clause was used)
* for the current query.
*
* @since 3.5.0
*
* @param array $q Query variables.
* @param string $limits LIMIT clauses of the query.
*/
private function set_found_posts( $q, $limits ) {
global $wpdb;
// Bail if posts is an empty array. Continue if posts is an empty string,
// null, or false to accommodate caching plugins that fill posts later.
if ( $q['no_found_rows'] || ( is_array( $this->posts ) && ! $this->posts ) ) {
return;
}
if ( ! empty( $limits ) ) {
/**
* Filters the query to run for retrieving the found posts.
*
* @since 2.1.0
*
* @param string $found_posts The query to run to find the found posts.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$this->found_posts = $wpdb->get_var( apply_filters_ref_array( 'found_posts_query', array( 'SELECT FOUND_ROWS()', &$this ) ) );
} else {
if ( is_array( $this->posts ) ) {
$this->found_posts = count( $this->posts );
} else {
if ( null === $this->posts ) {
$this->found_posts = 0;
} else {
$this->found_posts = 1;
}
}
}
/**
* Filters the number of found posts for the query.
*
* @since 2.1.0
*
* @param int $found_posts The number of posts found.
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
$this->found_posts = apply_filters_ref_array( 'found_posts', array( $this->found_posts, &$this ) );
if ( ! empty( $limits ) ) {
$this->max_num_pages = ceil( $this->found_posts / $q['posts_per_page'] );
}
}
/**
* Set up the next post and iterate current post index.
*
* @since 1.5.0
*
* @return WP_Post Next post.
*/
public function next_post() {
$this->current_post++;
$this->post = $this->posts[ $this->current_post ];
return $this->post;
}
/**
* Sets up the current post.
*
* Retrieves the next post, sets up the post, sets the 'in the loop'
* property to true.
*
* @since 1.5.0
*
* @global WP_Post $post
*/
public function the_post() {
global $post;
$this->in_the_loop = true;
if ( $this->current_post == -1 ) { // loop has just started
/**
* Fires once the loop is started.
*
* @since 2.0.0
*
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
do_action_ref_array( 'loop_start', array( &$this ) );
}
$post = $this->next_post();
$this->setup_postdata( $post );
}
/**
* Determines whether there are more posts available in the loop.
*
* Calls the {@see 'loop_end'} action when the loop is complete.
*
* @since 1.5.0
*
* @return bool True if posts are available, false if end of loop.
*/
public function have_posts() {
if ( $this->current_post + 1 < $this->post_count ) {
return true;
} elseif ( $this->current_post + 1 == $this->post_count && $this->post_count > 0 ) {
/**
* Fires once the loop has ended.
*
* @since 2.0.0
*
* @param WP_Query $this The WP_Query instance (passed by reference).
*/
do_action_ref_array( 'loop_end', array( &$this ) );
// Do some cleaning up after the loop
$this->rewind_posts();
} elseif ( 0 === $this->post_count ) {
/**
* Fires if no results are found in a post query.
*
* @since 4.9.0
*
* @param WP_Query $this The WP_Query instance.
*/
do_action( 'loop_no_results', $this );
}
$this->in_the_loop = false;
return false;
}
/**
* Rewind the posts and reset post index.
*
* @since 1.5.0
*/
public function rewind_posts() {
$this->current_post = -1;
if ( $this->post_count > 0 ) {
$this->post = $this->posts[0];
}
}
/**
* Iterate current comment index and return WP_Comment object.
*
* @since 2.2.0
*
* @return WP_Comment Comment object.
*/
public function next_comment() {
$this->current_comment++;
$this->comment = $this->comments[ $this->current_comment ];
return $this->comment;
}
/**
* Sets up the current comment.
*
* @since 2.2.0
* @global WP_Comment $comment Current comment.
*/
public function the_comment() {
global $comment;
$comment = $this->next_comment();
if ( $this->current_comment == 0 ) {
/**
* Fires once the comment loop is started.
*
* @since 2.2.0
*/
do_action( 'comment_loop_start' );
}
}
/**
* Whether there are more comments available.
*
* Automatically rewinds comments when finished.
*
* @since 2.2.0
*
* @return bool True, if more comments. False, if no more posts.
*/
public function have_comments() {
if ( $this->current_comment + 1 < $this->comment_count ) {
return true;
} elseif ( $this->current_comment + 1 == $this->comment_count ) {
$this->rewind_comments();
}
return false;
}
/**
* Rewind the comments, resets the comment index and comment to first.
*
* @since 2.2.0
*/
public function rewind_comments() {
$this->current_comment = -1;
if ( $this->comment_count > 0 ) {
$this->comment = $this->comments[0];
}
}
/**
* Sets up the WordPress query by parsing query string.
*
* @since 1.5.0
*
* @param string|array $query URL query string or array of query arguments.
* @return WP_Post[]|int[] Array of post objects or post IDs.
*/
public function query( $query ) {
$this->init();
$this->query = $this->query_vars = wp_parse_args( $query );
return $this->get_posts();
}
/**
* Retrieve queried object.
*
* If queried object is not set, then the queried object will be set from
* the category, tag, taxonomy, posts page, single post, page, or author
* query variable. After it is set up, it will be returned.
*
* @since 1.5.0
*
* @return object
*/
public function get_queried_object() {
if ( isset( $this->queried_object ) ) {
return $this->queried_object;
}
$this->queried_object = null;
$this->queried_object_id = null;
if ( $this->is_category || $this->is_tag || $this->is_tax ) {
if ( $this->is_category ) {
if ( $this->get( 'cat' ) ) {
$term = get_term( $this->get( 'cat' ), 'category' );
} elseif ( $this->get( 'category_name' ) ) {
$term = get_term_by( 'slug', $this->get( 'category_name' ), 'category' );
}
} elseif ( $this->is_tag ) {
if ( $this->get( 'tag_id' ) ) {
$term = get_term( $this->get( 'tag_id' ), 'post_tag' );
} elseif ( $this->get( 'tag' ) ) {
$term = get_term_by( 'slug', $this->get( 'tag' ), 'post_tag' );
}
} else {
// For other tax queries, grab the first term from the first clause.
if ( ! empty( $this->tax_query->queried_terms ) ) {
$queried_taxonomies = array_keys( $this->tax_query->queried_terms );
$matched_taxonomy = reset( $queried_taxonomies );
$query = $this->tax_query->queried_terms[ $matched_taxonomy ];
if ( ! empty( $query['terms'] ) ) {
if ( 'term_id' == $query['field'] ) {
$term = get_term( reset( $query['terms'] ), $matched_taxonomy );
} else {
$term = get_term_by( $query['field'], reset( $query['terms'] ), $matched_taxonomy );
}
}
}
}
if ( ! empty( $term ) && ! is_wp_error( $term ) ) {
$this->queried_object = $term;
$this->queried_object_id = (int) $term->term_id;
if ( $this->is_category && 'category' === $this->queried_object->taxonomy ) {
_make_cat_compat( $this->queried_object );
}
}
} elseif ( $this->is_post_type_archive ) {
$post_type = $this->get( 'post_type' );
if ( is_array( $post_type ) ) {
$post_type = reset( $post_type );
}
$this->queried_object = get_post_type_object( $post_type );
} elseif ( $this->is_posts_page ) {
$page_for_posts = get_option( 'page_for_posts' );
$this->queried_object = get_post( $page_for_posts );
$this->queried_object_id = (int) $this->queried_object->ID;
} elseif ( $this->is_singular && ! empty( $this->post ) ) {
$this->queried_object = $this->post;
$this->queried_object_id = (int) $this->post->ID;
} elseif ( $this->is_author ) {
$this->queried_object_id = (int) $this->get( 'author' );
$this->queried_object = get_userdata( $this->queried_object_id );
}
return $this->queried_object;
}
/**
* Retrieve ID of the current queried object.
*
* @since 1.5.0
*
* @return int
*/
public function get_queried_object_id() {
$this->get_queried_object();
if ( isset( $this->queried_object_id ) ) {
return $this->queried_object_id;
}
return 0;
}
/**
* Constructor.
*
* Sets up the WordPress query, if parameter is not empty.
*
* @since 1.5.0
*
* @param string|array $query URL query string or array of vars.
*/
public function __construct( $query = '' ) {
if ( ! empty( $query ) ) {
$this->query( $query );
}
}
/**
* Make private properties readable for backward compatibility.
*
* @since 4.0.0
*
* @param string $name Property to get.
* @return mixed Property.
*/
public function __get( $name ) {
if ( in_array( $name, $this->compat_fields ) ) {
return $this->$name;
}
}
/**
* Make private properties checkable for backward compatibility.
*
* @since 4.0.0
*
* @param string $name Property to check if set.
* @return bool Whether the property is set.
*/
public function __isset( $name ) {
if ( in_array( $name, $this->compat_fields ) ) {
return isset( $this->$name );
}
}
/**
* Make private/protected methods readable for backward compatibility.
*
* @since 4.0.0
*
* @param string $name Method to call.
* @param array $arguments Arguments to pass when calling.
* @return mixed|false Return value of the callback, false otherwise.
*/
public function __call( $name, $arguments ) {
if ( in_array( $name, $this->compat_methods ) ) {
return call_user_func_array( array( $this, $name ), $arguments );
}
return false;
}
/**
* Is the query for an existing archive page?
*
* Month, Year, Category, Author, Post Type archive...
*
* @since 3.1.0
*
* @return bool
*/
public function is_archive() {
return (bool) $this->is_archive;
}
/**
* Is the query for an existing post type archive page?
*
* @since 3.1.0
*
* @param mixed $post_types Optional. Post type or array of posts types to check against.
* @return bool
*/
public function is_post_type_archive( $post_types = '' ) {
if ( empty( $post_types ) || ! $this->is_post_type_archive ) {
return (bool) $this->is_post_type_archive;
}
$post_type = $this->get( 'post_type' );
if ( is_array( $post_type ) ) {
$post_type = reset( $post_type );
}
$post_type_object = get_post_type_object( $post_type );
return in_array( $post_type_object->name, (array) $post_types );
}
/**
* Is the query for an existing attachment page?
*
* @since 3.1.0
*
* @param mixed $attachment Attachment ID, title, slug, or array of such.
* @return bool
*/
public function is_attachment( $attachment = '' ) {
if ( ! $this->is_attachment ) {
return false;
}
if ( empty( $attachment ) ) {
return true;
}
$attachment = array_map( 'strval', (array) $attachment );
$post_obj = $this->get_queried_object();
if ( in_array( (string) $post_obj->ID, $attachment ) ) {
return true;
} elseif ( in_array( $post_obj->post_title, $attachment ) ) {
return true;
} elseif ( in_array( $post_obj->post_name, $attachment ) ) {
return true;
}
return false;
}
/**
* Is the query for an existing author archive page?
*
* If the $author parameter is specified, this function will additionally
* check if the query is for one of the authors specified.
*
* @since 3.1.0
*
* @param mixed $author Optional. User ID, nickname, nicename, or array of User IDs, nicknames, and nicenames
* @return bool
*/
public function is_author( $author = '' ) {
if ( ! $this->is_author ) {
return false;
}
if ( empty( $author ) ) {
return true;
}
$author_obj = $this->get_queried_object();
$author = array_map( 'strval', (array) $author );
if ( in_array( (string) $author_obj->ID, $author ) ) {
return true;
} elseif ( in_array( $author_obj->nickname, $author ) ) {
return true;
} elseif ( in_array( $author_obj->user_nicename, $author ) ) {
return true;
}
return false;
}
/**
* Is the query for an existing category archive page?
*
* If the $category parameter is specified, this function will additionally
* check if the query is for one of the categories specified.
*
* @since 3.1.0
*
* @param mixed $category Optional. Category ID, name, slug, or array of Category IDs, names, and slugs.
* @return bool
*/
public function is_category( $category = '' ) {
if ( ! $this->is_category ) {
return false;
}
if ( empty( $category ) ) {
return true;
}
$cat_obj = $this->get_queried_object();
$category = array_map( 'strval', (array) $category );
if ( in_array( (string) $cat_obj->term_id, $category ) ) {
return true;
} elseif ( in_array( $cat_obj->name, $category ) ) {
return true;
} elseif ( in_array( $cat_obj->slug, $category ) ) {
return true;
}
return false;
}
/**
* Is the query for an existing tag archive page?
*
* If the $tag parameter is specified, this function will additionally
* check if the query is for one of the tags specified.
*
* @since 3.1.0
*
* @param mixed $tag Optional. Tag ID, name, slug, or array of Tag IDs, names, and slugs.
* @return bool
*/
public function is_tag( $tag = '' ) {
if ( ! $this->is_tag ) {
return false;
}
if ( empty( $tag ) ) {
return true;
}
$tag_obj = $this->get_queried_object();
$tag = array_map( 'strval', (array) $tag );
if ( in_array( (string) $tag_obj->term_id, $tag ) ) {
return true;
} elseif ( in_array( $tag_obj->name, $tag ) ) {
return true;
} elseif ( in_array( $tag_obj->slug, $tag ) ) {
return true;
}
return false;
}
/**
* Is the query for an existing custom taxonomy archive page?
*
* If the $taxonomy parameter is specified, this function will additionally
* check if the query is for that specific $taxonomy.
*
* If the $term parameter is specified in addition to the $taxonomy parameter,
* this function will additionally check if the query is for one of the terms
* specified.
*
* @since 3.1.0
*
* @global array $wp_taxonomies
*
* @param mixed $taxonomy Optional. Taxonomy slug or slugs.
* @param mixed $term Optional. Term ID, name, slug or array of Term IDs, names, and slugs.
* @return bool True for custom taxonomy archive pages, false for built-in taxonomies (category and tag archives).
*/
public function is_tax( $taxonomy = '', $term = '' ) {
global $wp_taxonomies;
if ( ! $this->is_tax ) {
return false;
}
if ( empty( $taxonomy ) ) {
return true;
}
$queried_object = $this->get_queried_object();
$tax_array = array_intersect( array_keys( $wp_taxonomies ), (array) $taxonomy );
$term_array = (array) $term;
// Check that the taxonomy matches.
if ( ! ( isset( $queried_object->taxonomy ) && count( $tax_array ) && in_array( $queried_object->taxonomy, $tax_array ) ) ) {
return false;
}
// Only a Taxonomy provided.
if ( empty( $term ) ) {
return true;
}
return isset( $queried_object->term_id ) &&
count(
array_intersect(
array( $queried_object->term_id, $queried_object->name, $queried_object->slug ),
$term_array
)
);
}
/**
* Whether the current URL is within the comments popup window.
*
* @since 3.1.0
* @deprecated 4.5.0
*
* @return bool
*/
public function is_comments_popup() {
_deprecated_function( __FUNCTION__, '4.5.0' );
return false;
}
/**
* Is the query for an existing date archive?
*
* @since 3.1.0
*
* @return bool
*/
public function is_date() {
return (bool) $this->is_date;
}
/**
* Is the query for an existing day archive?
*
* @since 3.1.0
*
* @return bool
*/
public function is_day() {
return (bool) $this->is_day;
}
/**
* Is the query for a feed?
*
* @since 3.1.0
*
* @param string|array $feeds Optional feed types to check.
* @return bool
*/
public function is_feed( $feeds = '' ) {
if ( empty( $feeds ) || ! $this->is_feed ) {
return (bool) $this->is_feed;
}
$qv = $this->get( 'feed' );
if ( 'feed' == $qv ) {
$qv = get_default_feed();
}
return in_array( $qv, (array) $feeds );
}
/**
* Is the query for a comments feed?
*
* @since 3.1.0
*
* @return bool
*/
public function is_comment_feed() {
return (bool) $this->is_comment_feed;
}
/**
* Is the query for the front page of the site?
*
* This is for what is displayed at your site's main URL.
*
* Depends on the site's "Front page displays" Reading Settings 'show_on_front' and 'page_on_front'.
*
* If you set a static page for the front page of your site, this function will return
* true when viewing that page.
*
* Otherwise the same as @see WP_Query::is_home()
*
* @since 3.1.0
*
* @return bool True, if front of site.
*/
public function is_front_page() {
// most likely case
if ( 'posts' == get_option( 'show_on_front' ) && $this->is_home() ) {
return true;
} elseif ( 'page' == get_option( 'show_on_front' ) && get_option( 'page_on_front' ) && $this->is_page( get_option( 'page_on_front' ) ) ) {
return true;
} else {
return false;
}
}
/**
* Is the query for the blog homepage?
*
* This is the page which shows the time based blog content of your site.
*
* Depends on the site's "Front page displays" Reading Settings 'show_on_front' and 'page_for_posts'.
*
* If you set a static page for the front page of your site, this function will return
* true only on the page you set as the "Posts page".
*
* @see WP_Query::is_front_page()
*
* @since 3.1.0
*
* @return bool True if blog view homepage.
*/
public function is_home() {
return (bool) $this->is_home;
}
/**
* Is the query for an existing month archive?
*
* @since 3.1.0
*
* @return bool
*/
public function is_month() {
return (bool) $this->is_month;
}
/**
* Is the query for an existing single page?
*
* If the $page parameter is specified, this function will additionally
* check if the query is for one of the pages specified.
*
* @see WP_Query::is_single()
* @see WP_Query::is_singular()
*
* @since 3.1.0
*
* @param int|string|array $page Optional. Page ID, title, slug, path, or array of such. Default empty.
* @return bool Whether the query is for an existing single page.
*/
public function is_page( $page = '' ) {
if ( ! $this->is_page ) {
return false;
}
if ( empty( $page ) ) {
return true;
}
$page_obj = $this->get_queried_object();
$page = array_map( 'strval', (array) $page );
if ( in_array( (string) $page_obj->ID, $page ) ) {
return true;
} elseif ( in_array( $page_obj->post_title, $page ) ) {
return true;
} elseif ( in_array( $page_obj->post_name, $page ) ) {
return true;
} else {
foreach ( $page as $pagepath ) {
if ( ! strpos( $pagepath, '/' ) ) {
continue;
}
$pagepath_obj = get_page_by_path( $pagepath );
if ( $pagepath_obj && ( $pagepath_obj->ID == $page_obj->ID ) ) {
return true;
}
}
}
return false;
}
/**
* Is the query for paged result and not for the first page?
*
* @since 3.1.0
*
* @return bool
*/
public function is_paged() {
return (bool) $this->is_paged;
}
/**
* Is the query for a post or page preview?
*
* @since 3.1.0
*
* @return bool
*/
public function is_preview() {
return (bool) $this->is_preview;
}
/**
* Is the query for the robots file?
*
* @since 3.1.0
*
* @return bool
*/
public function is_robots() {
return (bool) $this->is_robots;
}
/**
* Is the query for a search?
*
* @since 3.1.0
*
* @return bool
*/
public function is_search() {
return (bool) $this->is_search;
}
/**
* Is the query for an existing single post?
*
* Works for any post type excluding pages.
*
* If the $post parameter is specified, this function will additionally
* check if the query is for one of the Posts specified.
*
* @see WP_Query::is_page()
* @see WP_Query::is_singular()
*
* @since 3.1.0
*
* @param int|string|array $post Optional. Post ID, title, slug, path, or array of such. Default empty.
* @return bool Whether the query is for an existing single post.
*/
public function is_single( $post = '' ) {
if ( ! $this->is_single ) {
return false;
}
if ( empty( $post ) ) {
return true;
}
$post_obj = $this->get_queried_object();
$post = array_map( 'strval', (array) $post );
if ( in_array( (string) $post_obj->ID, $post ) ) {
return true;
} elseif ( in_array( $post_obj->post_title, $post ) ) {
return true;
} elseif ( in_array( $post_obj->post_name, $post ) ) {
return true;
} else {
foreach ( $post as $postpath ) {
if ( ! strpos( $postpath, '/' ) ) {
continue;
}
$postpath_obj = get_page_by_path( $postpath, OBJECT, $post_obj->post_type );
if ( $postpath_obj && ( $postpath_obj->ID == $post_obj->ID ) ) {
return true;
}
}
}
return false;
}
/**
* Is the query for an existing single post of any post type (post, attachment, page,
* custom post types)?
*
* If the $post_types parameter is specified, this function will additionally
* check if the query is for one of the Posts Types specified.
*
* @see WP_Query::is_page()
* @see WP_Query::is_single()
*
* @since 3.1.0
*
* @param string|array $post_types Optional. Post type or array of post types. Default empty.
* @return bool Whether the query is for an existing single post of any of the given post types.
*/
public function is_singular( $post_types = '' ) {
if ( empty( $post_types ) || ! $this->is_singular ) {
return (bool) $this->is_singular;
}
$post_obj = $this->get_queried_object();
return in_array( $post_obj->post_type, (array) $post_types );
}
/**
* Is the query for a specific time?
*
* @since 3.1.0
*
* @return bool
*/
public function is_time() {
return (bool) $this->is_time;
}
/**
* Is the query for a trackback endpoint call?
*
* @since 3.1.0
*
* @return bool
*/
public function is_trackback() {
return (bool) $this->is_trackback;
}
/**
* Is the query for an existing year archive?
*
* @since 3.1.0
*
* @return bool
*/
public function is_year() {
return (bool) $this->is_year;
}
/**
* Is the query a 404 (returns no results)?
*
* @since 3.1.0
*
* @return bool
*/
public function is_404() {
return (bool) $this->is_404;
}
/**
* Is the query for an embedded post?
*
* @since 4.4.0
*
* @return bool
*/
public function is_embed() {
return (bool) $this->is_embed;
}
/**
* Is the query the main query?
*
* @since 3.3.0
*
* @global WP_Query $wp_query Global WP_Query instance.
*
* @return bool
*/
public function is_main_query() {
global $wp_the_query;
return $wp_the_query === $this;
}
/**
* Set up global post data.
*
* @since 4.1.0
* @since 4.4.0 Added the ability to pass a post ID to `$post`.
*
* @global int $id
* @global WP_User $authordata
* @global string|int|bool $currentday
* @global string|int|bool $currentmonth
* @global int $page
* @global array $pages
* @global int $multipage
* @global int $more
* @global int $numpages
*
* @param WP_Post|object|int $post WP_Post instance or Post ID/object.
* @return true True when finished.
*/
public function setup_postdata( $post ) {
global $id, $authordata, $currentday, $currentmonth, $page, $pages, $multipage, $more, $numpages;
if ( ! ( $post instanceof WP_Post ) ) {
$post = get_post( $post );
}
if ( ! $post ) {
return;
}
$id = (int) $post->ID;
$authordata = get_userdata( $post->post_author );
$currentday = mysql2date( 'd.m.y', $post->post_date, false );
$currentmonth = mysql2date( 'm', $post->post_date, false );
$numpages = 1;
$multipage = 0;
$page = $this->get( 'page' );
if ( ! $page ) {
$page = 1;
}
/*
* Force full post content when viewing the permalink for the $post,
* or when on an RSS feed. Otherwise respect the 'more' tag.
*/
if ( $post->ID === get_queried_object_id() && ( $this->is_page() || $this->is_single() ) ) {
$more = 1;
} elseif ( $this->is_feed() ) {
$more = 1;
} else {
$more = 0;
}
$content = $post->post_content;
if ( false !== strpos( $content, '<!--nextpage-->' ) ) {
$content = str_replace( "\n<!--nextpage-->\n", '<!--nextpage-->', $content );
$content = str_replace( "\n<!--nextpage-->", '<!--nextpage-->', $content );
$content = str_replace( "<!--nextpage-->\n", '<!--nextpage-->', $content );
// Remove the nextpage block delimiters, to avoid invalid block structures in the split content.
$content = str_replace( '<!-- wp:nextpage -->', '', $content );
$content = str_replace( '<!-- /wp:nextpage -->', '', $content );
// Ignore nextpage at the beginning of the content.
if ( 0 === strpos( $content, '<!--nextpage-->' ) ) {
$content = substr( $content, 15 );
}
$pages = explode( '<!--nextpage-->', $content );
} else {
$pages = array( $post->post_content );
}
/**
* Filters the "pages" derived from splitting the post content.
*
* "Pages" are determined by splitting the post content based on the presence
* of `<!-- nextpage -->` tags.
*
* @since 4.4.0
*
* @param string[] $pages Array of "pages" from the post content split by `<!-- nextpage -->` tags.
* @param WP_Post $post Current post object.
*/
$pages = apply_filters( 'content_pagination', $pages, $post );
$numpages = count( $pages );
if ( $numpages > 1 ) {
if ( $page > 1 ) {
$more = 1;
}
$multipage = 1;
} else {
$multipage = 0;
}
/**
* Fires once the post data has been setup.
*
* @since 2.8.0
* @since 4.1.0 Introduced `$this` parameter.
*
* @param WP_Post $post The Post object (passed by reference).
* @param WP_Query $this The current Query object (passed by reference).
*/
do_action_ref_array( 'the_post', array( &$post, &$this ) );
return true;
}
/**
* After looping through a nested query, this function
* restores the $post global to the current post in this query.
*
* @since 3.7.0
*
* @global WP_Post $post
*/
public function reset_postdata() {
if ( ! empty( $this->post ) ) {
$GLOBALS['post'] = $this->post;
$this->setup_postdata( $this->post );
}
}
/**
* Lazyload term meta for posts in the loop.
*
* @since 4.4.0
* @deprecated 4.5.0 See wp_queue_posts_for_term_meta_lazyload().
*
* @param mixed $check
* @param int $term_id
* @return mixed
*/
public function lazyload_term_meta( $check, $term_id ) {
_deprecated_function( __METHOD__, '4.5.0' );
return $check;
}
/**
* Lazyload comment meta for comments in the loop.
*
* @since 4.4.0
* @deprecated 4.5.0 See wp_queue_comments_for_comment_meta_lazyload().
*
* @param mixed $check
* @param int $comment_id
* @return mixed
*/
public function lazyload_comment_meta( $check, $comment_id ) {
_deprecated_function( __METHOD__, '4.5.0' );
return $check;
}
}
Expand full source code Collapse full source code View on Trac
Changelog Changelog
| Version | Description |
|---|---|
| 4.5.0 | Removed the $comments_popup property. |
| 1.5.0 | Introduced. |
More Information More Information
Most of the time you can find the information you want without actually dealing with the class internals and global variables. There are a whole bunch of functions that you can call from anywhere that will enable you to get the information you need.
There are two main scenarios you might want to use WP_Query in. The first is to find out what type of request WordPress is currently dealing with. The $is_* properties are designed to hold this information: use the conditional tags to interact here. This is the more common scenario to plugin writers (the second normally applies to theme writers).
The second is during The Loop. WP_Query provides numerous functions for common tasks within The Loop. To begin with, have_posts(), which calls $wp_query->have_posts(), is called to see if there are any posts to show. If there are, a while loop is begun, using have_posts() as the condition. This will iterate around as long as there are posts to show. In each iteration, the_post(), which calls $wp_query->the_post() is called, setting up internal variables within $wp_query and the global $post variable (which the template tags rely on), as above. These are the functions you should use when writing a theme file that needs a loop.
Note: If you use the_post() with your query, you need to run wp_reset_postdata() afterwards to have template tags use the main query’s current post again.
Note: Ticket #18408 For querying posts in the admin, consider using get_posts() as wp_reset_postdata() might not behave as expected.
Usage Usage
Standard Loop Standard Loop
<?php
// The Query
$the_query = new WP_Query( $args );
// The Loop
if ( $the_query->have_posts() ) {
echo '<ul>';
while ( $the_query->have_posts() ) {
$the_query->the_post();
echo '<li>' . get_the_title() . '</li>';
}
echo '</ul>';
} else {
// no posts found
}
/* Restore original Post Data */
wp_reset_postdata();
Standard Loop (Alternate) Standard Loop (Alternate)
<?php // the query $the_query = new WP_Query( $args ); ?> <?php if ( $the_query->have_posts() ) : ?> <!-- pagination here --> <!-- the loop --> <?php while ( $the_query->have_posts() ) : $the_query->the_post(); ?> <h2><?php the_title(); ?></h2> <?php endwhile; ?> <!-- end of the loop --> <!-- pagination here --> <?php wp_reset_postdata(); ?> <?php else : ?> <p><?php _e( 'Sorry, no posts matched your criteria.' ); ?></p> <?php endif; ?>
Multiple Loops Multiple Loops
If you have multiple queries, you need to perform multiple loops. Like so…
<?php
// The Query
$query1 = new WP_Query( $args );
// The Loop
while ( $query1->have_posts() ) {
$query1->the_post();
echo '<li>' . get_the_title() . '</li>';
}
/* Restore original Post Data
* NB: Because we are using new WP_Query we aren't stomping on the
* original $wp_query and it does not need to be reset with
* wp_reset_query(). We just need to set the post data back up with
* wp_reset_postdata().
*/
wp_reset_postdata();
/* The 2nd Query (without global var) */
$query2 = new WP_Query( $args2 );
// The 2nd Loop
while ( $query2->have_posts() ) {
$query2->the_post();
echo '<li>' . get_the_title( $query2->post->ID ) . '</li>';
}
// Restore original Post Data
wp_reset_postdata();
?>
Methods and Properties Methods and Properties
This is the formal documentation of WP_Query. You shouldn’t alter the properties directly, but instead use the methods to interact with them.
Properties Properties
$query
Holds the query string that was passed to the$wp_queryobject by WP class.$query_vars
An associative array containing the dissected$query: an array of the query variables and their respective values.$queried_object
Applicable if the request is a category, author, permalink or Page. Holds information on the requested category, author, post or Page.$queried_object_id
If the request is a category, author, permalink or post / page, holds the corresponding ID.$posts
Gets filled with the requested posts from the database.$post_count
The number of posts being displayed.$found_posts
The total number of posts found matching the current query parameters$max_num_pages
The total number of pages. Is the result of $found_posts / $posts_per_page$current_post
(available during The Loop) Index of the post currently being displayed.$post
(available during The Loop) The post currently being displayed.$is_single,$is_page,$is_archive,$is_preview,$is_date,$is_year,$is_month,$is_time,$is_author,$is_category,$is_tag,$is_tax,$is_search,$is_feed,$is_comment_feed,$is_trackback,$is_home,$is_404,$is_comments_popup,$is_admin,$is_attachment,$is_singular,$is_robots,$is_posts_page,$is_paged
Booleans dictating what type of request this is. For example, the first three represent ‘is it a permalink?’, ‘is it a Page?’, ‘is it any type of archive page?’, respectively.
Author Parameters Author Parameters
author(int) – use author id.author_name(string) – use ‘user_nicename‘ – NOT name.author__in(array) – use author id (available since version 3.7).author__not_in(array) – use author id (available since version 3.7).
Display posts by author, using author id:
$query = new WP_Query( array( 'author' => 123 ) );
Display posts by author, using author ‘user_nicename‘:
$query = new WP_Query( array( 'author_name' => 'rami' ) );
Show Posts From Several Authors
$query = new WP_Query( array( 'author' => '2,6,17,38' ) );
Exclude Posts Belonging to an Author
Display all posts except those from an author(singular) by prefixing its id with a ‘-‘ (minus) sign:
$query = new WP_Query( array( 'author' => -12 ) );
Display posts from multiple authors:
$query = new WP_Query( array( 'author__in' => array( 2, 6 ) ) );
You can also exclude multiple author this way:
$query = new WP_Query( array( 'author__not_in' => array( 2, 6 ) ) );
Category Parameters Category Parameters
cat(int) – use category id.category_name(string) – use category slug.category__and(array) – use category id.category__in(array) – use category id.category__not_in(array) – use category id.
Display posts that have one category (and any children of that category), using category id:
$query = new WP_Query( array( 'cat' => 4 ) );
Display posts that have this category (and any children of that category), using category slug:
$query = new WP_Query( array( 'category_name' => 'staff' ) );
Display posts that have this category (not children of that category), using category id:
$query = new WP_Query( array( 'category__in' => 4 ) );
Display posts that have several categories, using category id:
$query = new WP_Query( array( 'cat' => '2,6,17,38' ) );
Display posts that have these categories, using category slug:
$query = new WP_Query( array( 'category_name' => 'staff,news' ) );
Display posts that have “all” of these categories:
$query = new WP_Query( array( 'category_name' => 'staff+news' ) );
Display all posts except those from a category by prefixing its id with a ‘-‘ (minus) sign.
$query = new WP_Query( array( 'cat' => '-12,-34,-56' ) );
Display posts that are in multiple categories. This shows posts that are in both categories 2 and 6:
$query = new WP_Query( array( 'category__and' => array( 2, 6 ) ) );
To display posts from either category 2 OR 6, you could use cat as mentioned above, or by using category__in (note this does not show posts from any children of these categories):
$query = new WP_Query( array( 'category__in' => array( 2, 6 ) ) );
You can also exclude multiple categories this way:
$query = new WP_Query( array( 'category__not_in' => array( 2, 6 ) ) );
Tag Parameters Tag Parameters
Show posts associated with certain tags.
tag(string) – use tag slug.tag_id(int) – use tag id.tag__and(array) – use tag ids.tag__in(array) – use tag ids.tag__not_in(array) – use tag ids.tag_slug__and(array) – use tag slugs.tag_slug__in(array) – use tag slugs.
Display posts that have one tag, using tag slug:
$query = new WP_Query( array( 'tag' => 'cooking' ) );
Display posts that have this tag, using tag id:
$query = new WP_Query( array( 'tag_id' => 13 ) );
Display posts that have “either” of these tags:
$query = new WP_Query( array( 'tag' => 'bread,baking' ) );
Display posts that have “all” of these tags:
$query = new WP_Query( array( 'tag' => 'bread+baking+recipe' ) );
Display posts that are tagged with both tag id 37 and tag id 47:
$query = new WP_Query( array( 'tag__and' => array( 37, 47 ) ) );
To display posts from either tag id 37 or 47, you could use tag as mentioned above, or explicitly specify by using tag__in:
$query = new WP_Query( array( 'tag__in' => array( 37, 47 ) ) );
Display posts that do not have any of the two tag ids 37 and 47:
$query = new WP_Query( array( 'tag__not_in' => array( 37, 47 ) ) );
The tag_slug__in and tag_slug__and behave much the same, except match against the tag’s slug.
Taxonomy Parameters Taxonomy Parameters
{tax}(string) – use taxonomy slug. (Deprecated since version 3.1 in favor of ‘tax_query‘).tax_query(array) – use taxonomy parameters (available since version 3.1).relation(string) – The logical relationship between each inner taxonomy array when there is more than one. Possible values are ‘AND’, ‘OR’. Do not use with a single inner taxonomy array.taxonomy(string) – Taxonomy.field(string) – Select taxonomy term by. Possible values are ‘term_id’, ‘name’, ‘slug’ or ‘term_taxonomy_id’. Default value is ‘term_id’.terms(int/string/array) – Taxonomy term(s).include_children(boolean) – Whether or not to include children for hierarchical taxonomies. Defaults to true.operator(string) – Operator to test. Possible values are ‘IN’, ‘NOT IN’, ‘AND’, ‘EXISTS’ and ‘NOT EXISTS’. Default value is ‘IN’.
Important Note: tax_query takes an array of tax query arguments arrays (it takes an array of arrays).
This construct allows you to query multiple taxonomies by using the relation parameter in the first (outer) array to describe the boolean relationship between the taxonomy arrays.
Simple Taxonomy Query:
Display posts tagged with bob, under people custom taxonomy:
$args = array( 'post_type' => 'post', 'tax_query' => array( array( 'taxonomy' => 'people', 'field' => 'slug', 'terms' => 'bob', ), ), ); $query = new WP_Query( $args );
Multiple Taxonomy Handling:
Display posts from several custom taxonomies:
$args = array( 'post_type' => 'post', 'tax_query' => array( 'relation' => 'AND', array( 'taxonomy' => 'movie_genre', 'field' => 'slug', 'terms' => array( 'action', 'comedy' ), ), array( 'taxonomy' => 'actor', 'field' => 'term_id', 'terms' => array( 103, 115, 206 ), 'operator' => 'NOT IN', ), ), ); $query = new WP_Query( $args );
Display posts that are in the quotes category OR have the quote post format:
$args = array( 'post_type' => 'post', 'tax_query' => array( 'relation' => 'OR', array( 'taxonomy' => 'category', 'field' => 'slug', 'terms' => array( 'quotes' ), ), array( 'taxonomy' => 'post_format', 'field' => 'slug', 'terms' => array( 'post-format-quote' ), ), ), ); $query = new WP_Query( $args );
Nested Taxonomy Handling:
The 'tax_query' clauses can be nested, to create more complex queries. Example: Display posts that are in the quotes category OR both have the quote post format AND are in the wisdom category:
$args = array(
'post_type' => 'post',
'tax_query' => array(
'relation' => 'OR',
array(
'taxonomy' => 'category',
'field' => 'slug',
'terms' => array( 'quotes' ),
),
array(
'relation' => 'AND',
array(
'taxonomy' => 'post_format',
'field' => 'slug',
'terms' => array( 'post-format-quote' ),
),
array(
'taxonomy' => 'category',
'field' => 'slug',
'terms' => array( 'wisdom' ),
),
),
),
);
$query = new WP_Query( $args );
Search Parameters Search Parameters
Show posts based on a keyword search.
s(string) – Search keyword.
Show Posts based on a keyword search
$query = new WP_Query( array( 's' => 'keyword' ) );
Post & Page Parameters Post & Page Parameters
p(int) – use post id.name(string) – use post slug.page_id(int) – use page id.pagename(string) – use page slug.post_parent(int) – use page id to return only child pages. Set to 0 to return only top-level entries.post_parent__in(array) – use post ids. Specify posts whose parent is in an array. (available since version 3.6)post_parent__not_in(array) – use post ids. Specify posts whose parent is not in an array. (available since version 3.6)post__in(array) – use post ids. Specify posts to retrieve. ATTENTION If you use sticky posts, they will be included (prepended!) in the posts you retrieve whether you want it or not. To suppress this behaviour useignore_sticky_posts.post__not_in(array) – use post ids. Specify post NOT to retrieve.post_name__in(array) – use post slugs. Specify posts to retrieve. (Will be available in version 4.4)
Display content based on post and page parameters. Remember that default post_type is only set to display posts but not pages.
NOTE: Ticket #28099: Passing an empty array to post__in will return has_posts() as true (and all posts will be returned). Logic should be used before hand to determine if WP_Query should be used in the event that the array being passed to post__in is empty.
Display post by ID:
$query = new WP_Query( array( 'p' => 7 ) );
Display page by ID:
$query = new WP_Query( array( 'page_id' => 7 ) );
Show post/page by slug
$query = new WP_Query( array( 'name' => 'about-my-life' ) );
Display page by slug:
$query = new WP_Query( array( 'pagename' => 'contact' ) );
Display child page using the slug of the parent and the child page, separated by a slash (e.g. ‘parent_slug/child_slug’):
$query = new WP_Query( array( 'pagename' => 'contact_us/canada' ) );
Display child pages using parent page ID:
$query = new WP_Query( array( 'post_parent' => 93 ) );
Display only top-level pages, exclude all child pages:
$query = new WP_Query( array( 'post_parent' => 0 ) );
Display posts whose parent is in an array:
$query = new WP_Query( array( 'post_parent__in' => array( 2, 5, 12, 14, 20 ) ) );
Display only the specific posts:
$query = new WP_Query( array( 'post_type' => 'page', 'post__in' => array( 2, 5, 12, 14, 20 ) ) );
Display all posts but NOT the specified ones:
$query = new WP_Query( array( 'post_type' => 'post', 'post__not_in' => array( 2, 5, 12, 14, 20 ) ) );
Note: you cannot combine post__in and post__not_in in the same query.
Also note that using a string containing a comma separated list will not work here. If you’re passing a variable, make sure it’s a proper array of integer values:
// This will NOT work $exclude_ids = '1,2,3'; $query = new WP_Query( array( 'post__not_in' => array( $exclude_ids ) ) ); // This WILL work $exclude_ids = array( 1, 2, 3 ); $query = new WP_Query( array( 'post__not_in' => $exclude_ids ) );
Password Parameters Password Parameters
Show content based on post and page parameters. Remember that default post_type is only set to display posts but not pages.
has_password(bool) – true for posts with passwords ; false for posts without passwords ; null for all posts with and without passwords (available since version 3.9).post_password(string) – show posts with a particular password (available since version 3.9)
Display only password protected posts:
$query = new WP_Query( array( 'has_password' => true ) );
Display only posts without passwords:
$query = new WP_Query( array( 'has_password' => false ) );
Display only posts with and without passwords:
$query = new WP_Query( array( 'has_password' => null ) );
Display posts with a particular password:
$query = new WP_Query( array( 'post_password' => 'zxcvbn' ) );
Post Type Parameters Post Type Parameters
post_type(string / array) – use post types. Retrieves posts by post types, default value is ‘post‘. If ‘tax_query‘ is set for a query, the default value becomes ‘any‘;- ‘
post‘ – a post. - ‘
page‘ – a page. - ‘
revision‘ – a revision. - ‘
attachment‘ – an attachment. Whilst the default WP_Querypost_statusis ‘publish’, attachments have a defaultpost_statusof ‘inherit’. This means no attachments will be returned unless you also explicitly setpost_statusto ‘inherit’ or ‘any’. - ‘
nav_menu_item‘ – a navigation menu item - ‘
any‘ – retrieves any type except revisions and types with ‘exclude_from_search’ set to true.
** Custom Post Types (e.g. movies)
- ‘
Display only pages:
$query = new WP_Query( array( 'post_type' => 'page' ) );
Display ‘any‘ post type (retrieves any type except revisions and types with ‘exclude_from_search’ set to TRUE):
$query = new WP_Query( array( 'post_type' => 'any' ) );
Display multiple post types, including custom post types:
$args = array( 'post_type' => array( 'post', 'page', 'movie', 'book' ) ); $query = new WP_Query( $args );
Status Parameters Status Parameters
Show posts associated with certain post status.
post_status(string / array) – use post status. Retrieves posts by post status. Default value is ‘publish‘, but if the user is logged in, ‘private‘ is added. Public custom post statuses are also included by default. And if the query is run in an admin context (administration area or AJAX call), protected statuses are added too. By default protected statuses are ‘future‘, ‘draft‘ and ‘pending‘.- ‘
publish‘ – a published post or page. - ‘
pending‘ – post is pending review. - ‘
draft‘ – a post in draft status. - ‘
auto-draft‘ – a newly created post, with no content. - ‘
future‘ – a post to publish in the future. - ‘
private‘ – not visible to users who are not logged in. - ‘
inherit‘ – a revision. see get_children(). - ‘
trash‘ – post is in trashbin (available since version 2.9). - ‘
any‘ – retrieves any status except those from post statuses with ‘exclude_from_search’ set to true (i.e. trash and auto-draft).
- ‘
Display only posts with the ‘draft‘ status:
$query = new WP_Query( array( 'post_status' => 'draft' ) );
Display multiple post status:
$args = array( 'post_status' => array( 'pending', 'draft', 'future' ) ); $query = new WP_Query( $args );
Display all attachments:
$args = array( 'post_status' => 'any', 'post_type' => 'attachment' ); $query = new WP_Query( $args );
Pagination Parameters Pagination Parameters
nopaging(boolean) – show all posts or use pagination. Default value is ‘false’, use paging.posts_per_page(int) – number of post to show per page (available since version 2.1, replacedshowpostsparameter). Use'posts_per_page'=>-1to show all posts (the'offset'parameter is ignored with a-1value). Set the ‘paged’ parameter if pagination is off after using this parameter. Note: if the query is in a feed, wordpress overwrites this parameter with the stored ‘posts_per_rss’ option. To reimpose the limit, try using the ‘post_limits’ filter, or filter ‘pre_option_posts_per_rss’ and return -1posts_per_archive_page(int) – number of posts to show per page – on archive pages only. Over-ridesposts_per_pageandshowpostson pages where is_archive() or is_search() would be true.offset(int) – number of post to displace or pass over. Warning: Setting the offset parameter overrides/ignores the paged parameter and breaks pagination. The'offset'parameter is ignored when'posts_per_page'=>-1(show all posts) is used.paged(int) – number of page. Show the posts that would normally show up just on page X when using the “Older Entries” link.page(int) – number of page for a static front page. Show the posts that would normally show up just on page X of a Static Front Page.ignore_sticky_posts(boolean) – ignore post stickiness (available since version 3.1, replacedcaller_get_postsparameter).false(default): move sticky posts to the start of the set.true: do not move sticky posts to the start of the set.
Display x posts per page:
$query = new WP_Query( array( 'posts_per_page' => 3 ) );
Display all posts in one page:
$query = new WP_Query( array( 'posts_per_page' => -1 ) );
Display all posts by disabling pagination:
$query = new WP_Query( array( 'nopaging' => true ) );
Display posts from the 4th one:
$query = new WP_Query( array( 'offset' => 3 ) );
Display 5 posts per page which follow the 3 most recent posts:
$query = new WP_Query( array( 'posts_per_page' => 5, 'offset' => 3 ) );
Display posts from page number x:
$query = new WP_Query( array( 'paged' => 6 ) );
Display posts from current page:
$query = new WP_Query( array( 'paged' => get_query_var( 'paged' ) ) );
Display posts from the current page and set the ‘paged’ parameter to 1 when the query variable is not set (first page).
$paged = ( get_query_var('paged') ) ? get_query_var('paged') : 1;
$query = new WP_Query( array( 'paged' => $paged ) );
Pagination Note: Use get_query_var('page'); if you want your query to work in a page template that you’ve set as your static front page. The query variable ‘page’ also holds the pagenumber for a single paginated Post or Page that includes the <!--nextpage--> quicktag in the post content.
Display posts from current page on a static front page:
$paged = ( get_query_var('page') ) ? get_query_var('page') : 1;
$query = new WP_Query( array( 'paged' => $paged ) );
Display just the first sticky post:
$sticky = get_option( 'sticky_posts' ); $query = new WP_Query( array( 'p' => $sticky[0] ) );
Display just the first sticky post, if none return the last post published:
$args = array( 'posts_per_page' => 1, 'post__in' => get_option( 'sticky_posts' ), 'ignore_sticky_posts' => 1, ); $query = new WP_Query( $args );
Display just the first sticky post, if none return nothing:
$sticky = get_option( 'sticky_posts' );
$args = array(
'posts_per_page' => 1,
'post__in' => $sticky,
'ignore_sticky_posts' => 1,
);
$query = new WP_Query( $args );
if ( $sticky[0] ) {
// insert here your stuff...
}
Exclude all sticky posts from the query:
$query = new WP_Query( array( 'post__not_in' => get_option( 'sticky_posts' ) ) );
Exclude sticky posts from a category:
Return ALL posts within the category, but don’t show sticky posts at the top. The ‘sticky posts’ will still show in their natural position (e.g. by date):
$query = new WP_Query( array( 'ignore_sticky_posts' => 1, 'posts_per_page' => 3, 'cat' => 6 );
Exclude sticky posts from a category:
Return posts within the category, but exclude sticky posts completely, and adhere to paging rules:
$paged = get_query_var( 'paged' ) ? get_query_var( 'paged' ) : 1; $sticky = get_option( 'sticky_posts' ); $args = array( 'cat' => 3, 'ignore_sticky_posts' => 1, 'post__not_in' => $sticky, 'paged' => $paged, ); $query = new WP_Query( $args );
Order & Orderby Parameters Order & Orderby Parameters
Sort retrieved posts.
order(string | array) – Designates the ascending or descending order of the ‘orderby‘ parameter. Defaults to ‘DESC’. An array can be used for multiple order/orderby sets.- ‘
ASC‘ – ascending order from lowest to highest values (1, 2, 3; a, b, c). - ‘
DESC‘ – descending order from highest to lowest values (3, 2, 1; c, b, a).
- ‘
orderby(string | array) – Sort retrieved posts by parameter. Defaults to ‘date (post_date)’. One or more options can be passed.- ‘
none‘ – No order (available since version 2.8). - ‘
ID‘ – Order by post id. Note the capitalization. - ‘
author‘ – Order by author. - ‘
title‘ – Order by title. - ‘
name‘ – Order by post name (post slug). - ‘
type‘ – Order by post type (available since version 4.0). - ‘
date‘ – Order by date. - ‘
modified‘ – Order by last modified date. - ‘
parent‘ – Order by post/page parent id. - ‘
rand‘ – Random order. - ‘
comment_count‘ – Order by number of comments (available since version 2.9). - ‘
menu_order‘ – Order by Page Order. Used most often for pages (Order field in the Edit Page Attributes box) and for attachments (the integer fields in the Insert / Upload Media Gallery dialog), but could be used for any post type with distinct ‘menu_order‘ values (they all default to 0). - ‘
meta_value‘ – Note that a ‘meta_key=keyname‘ must also be present in the query. Note also that the sorting will be alphabetical which is fine for strings (i.e. words), but can be unexpected for numbers (e.g. 1, 3, 34, 4, 56, 6, etc, rather than 1, 3, 4, 6, 34, 56 as you might naturally expect). Use ‘meta_value_num‘ instead for numeric values. You may also specify ‘meta_type‘ if you want to cast the meta value as a specific type. Possible values are ‘NUMERIC’, ‘BINARY’, ‘CHAR’, ‘DATE’, ‘DATETIME’, ‘DECIMAL’, ‘SIGNED’, ‘TIME’, ‘UNSIGNED’, same as in ‘$meta_query‘. - ‘
meta_value_num‘ – Order by numeric meta value (available since version 2.8). Also note that a ‘meta_key=keyname‘ must also be present in the query. This value allows for numerical sorting as noted above in ‘meta_value‘. - ‘
post__in‘ – Preserve post ID order given in the post__in array (available since version 3.5).
- ‘
Display posts sorted by post ‘title’ in a descending order:
$args = array( 'orderby' => 'title', 'order' => 'DESC', ); $query = new WP_Query( $args );
Display posts sorted by ‘menu_order’ with a fallback to post ‘title’, in a descending order:
$args = array( 'orderby' => 'menu_order title', 'order' => 'DESC', ); $query = new WP_Query( $args );
Display one random post:
$args = array( 'orderby' => 'rand', 'posts_per_page' => '1', ); $query = new WP_Query( $args );
Display posts ordered by comment count (popularity):
$args = array( 'orderby' => 'comment_count' ); $query = new WP_Query( $args );
Display posts with ‘Product’ type ordered by ‘Price’ custom field:
$args = array( 'post_type' => 'product', 'orderby' => 'meta_value_num', 'meta_key' => 'price', ); $query = new WP_Query( $args );
Display pages ordered by ‘title’ and ‘menu_order’. (title is dominant):
$args = array( 'post_type' => 'page', 'orderby' => 'title menu_order', 'order' => 'ASC', ); $query = new WP_Query( $args );
Display pages ordered by ‘title’ and ‘menu_order’ with different sort orders (ASC/DESC) (available since version 4.0):
$args = array( 'orderby' => array( 'title' => 'DESC', 'menu_order' => 'ASC' ) ); $query = new WP_Query( $args );
Mulitiple orderby/order pairs
$args = array( 'orderby' => array( 'meta_value_num' => 'DESC', 'title' => 'ASC' ), 'meta_key' => 'age' ); $query = new WP_Query( $args );
‘orderby’ with ‘meta_value’ and custom post type
Display posts of type ‘my_custom_post_type’, ordered by ‘age’, and filtered to show only ages 3 and 4 (using meta_query).
$args = array( 'post_type' => 'my_custom_post_type', 'meta_key' => 'age', 'orderby' => 'meta_value_num', 'order' => 'ASC', 'meta_query' => array( array( 'key' => 'age', 'value' => array( 3, 4 ), 'compare' => 'IN', ), ), ); $query = new WP_Query( $args );
Date Parameters Date Parameters
Show posts associated with a certain time and date period.
year(int) – 4 digit year (e.g. 2011).monthnum(int) – Month number (from 1 to 12).w(int) – Week of the year (from 0 to 53). Uses MySQL WEEK command. The mode is dependent on the “start_of_week” option.day(int) – Day of the month (from 1 to 31).hour(int) – Hour (from 0 to 23).minute(int) – Minute (from 0 to 60).second(int) – Second (0 to 60).m(int) – YearMonth (For e.g.:201307).date_query(array) – Date parameters (available since version 3.7).year(int) – 4 digit year (e.g. 2011).month(int) – Month number (from 1 to 12).week(int) – Week of the year (from 0 to 53).day(int) – Day of the month (from 1 to 31).hour(int) – Hour (from 0 to 23).minute(int) – Minute (from 0 to 59).second(int) – Second (0 to 59).after(string/array) – Date to retrieve posts after. Acceptsstrtotime()-compatible string, or array of ‘year’, ‘month’, ‘day’ values:year(string) Accepts any four-digit year. Default is empty.month(string) The month of the year. Accepts numbers 1-12. Default: 12.day(string) The day of the month. Accepts numbers 1-31. Default: last day of month.
before(string/array) – Date to retrieve posts before. Acceptsstrtotime()-compatible string, or array of ‘year’, ‘month’, ‘day’ values:year(string) Accepts any four-digit year. Default is empty.month(string) The month of the year. Accepts numbers 1-12. Default: 1.day(string) The day of the month. Accepts numbers 1-31. Default: 1.
inclusive(boolean) – For after/before, whether exact value should be matched or not’.compare(string) – See WP_Date_Query::get_compare().column(string) – Posts column to query against. Default: ‘post_date’.relation(string) – OR or AND, how the sub-arrays should be compared. Default: AND.
Returns posts dated December 12, 2012:
$query = new WP_Query( 'year=2012&monthnum=12&day=12' );
or:
$args = array( 'date_query' => array( array( 'year' => 2012, 'month' => 12, 'day' => 12, ), ), ); $query = new WP_Query( $args );
Returns posts for today:
$today = getdate(); $query = new WP_Query( 'year=' . $today['year'] . '&monthnum=' . $today['mon'] . '&day=' . $today['mday'] );
or:
$today = getdate(); $args = array( 'date_query' => array( array( 'year' => $today['year'], 'month' => $today['mon'], 'day' => $today['mday'], ), ), ); $query = new WP_Query( $args );
Returns posts for this week:
$week = date( 'W' ); $year = date( 'Y' ); $query = new WP_Query( 'year=' . $year . '&w=' . $week );
or:
$args = array( 'date_query' => array( array( 'year' => date( 'Y' ), 'week' => date( 'W' ), ), ), ); $query = new WP_Query( $args );
Return posts between 9AM to 5PM on weekdays
$args = array( 'date_query' => array( array( 'hour' => 9, 'compare' => '>=', ), array( 'hour' => 17, 'compare' => '<=', ), array( 'dayofweek' => array( 2, 6 ), 'compare' => 'BETWEEN', ), ), 'posts_per_page' => -1, ); $query = new WP_Query( $args );
Return posts from January 1st to February 28th
$args = array( 'date_query' => array( array( 'after' => 'January 1st, 2013', 'before' => array( 'year' => 2013, 'month' => 2, 'day' => 28, ), 'inclusive' => true, ), ), 'posts_per_page' => -1, ); $query = new WP_Query( $args );
Note that if a strtotime()-compatible string with just a date was passed in the before parameter, this will be converted to 00:00:00 on that date. In this case, even if inclusive was set to true, the date would not be included in the query. If you want a before date to be inclusive, include the time as well, such as 'before' => '2013-02-28 23:59:59', or use the array format, which is adjusted automatically if inclusive is set.
Return posts made over a year ago but modified in the past month
$args = array( 'date_query' => array( array( 'column' => 'post_date_gmt', 'before' => '1 year ago', ), array( 'column' => 'post_modified_gmt', 'after' => '1 month ago', ), ), 'posts_per_page' => -1, ); $query = new WP_Query( $args );
The 'date_query' clauses can be nested, in order to construct complex queries.
Custom Field (post meta) Parameters Custom Field (post meta) Parameters
Show posts associated with a certain custom field.
This part of the query is parsed by WP_Meta_Query, so check the docs for it as well in case this list of arguments isn’t up to date.
meta_key(string) – Custom field key.meta_value(string) – Custom field value.meta_value_num(number) – Custom field value.meta_compare(string) – Operator to test the ‘meta_value‘. Possible values are ‘=’, ‘!=’, ‘>’, ‘>=’, ‘<', '<=', 'LIKE', 'NOT LIKE', 'IN', 'NOT IN', 'BETWEEN', 'NOT BETWEEN', 'NOT EXISTS', 'REGEXP', 'NOT REGEXP' or 'RLIKE'. Default value is '='.meta_query(array) – Custom field parameters (available since version 3.1).relation(string) – The logical relationship between each inner meta_query array when there is more than one. Possible values are ‘AND’, ‘OR’. Do not use with a single inner meta_query array.
meta_query also contains one or more arrays with the following keys:
key(string) – Custom field key.value(string|array) – Custom field value. It can be an array only whencompareis'IN','NOT IN','BETWEEN', or'NOT BETWEEN'. You don’t have to specify a value when using the'EXISTS'or'NOT EXISTS'comparisons in WordPress 3.9 and up.
(Note: Due to bug #23268,valueis required forNOT EXISTScomparisons to work correctly prior to 3.9. You must supply some string for thevalueparameter. An empty string or NULL will NOT work. However, any other string will do the trick and will NOT show up in your SQL when usingNOT EXISTS. Need inspiration? How about'bug #23268'.)compare(string) – Operator to test. Possible values are ‘=’, ‘!=’, ‘>’, ‘>=’, ‘<', '<=', 'LIKE', 'NOT LIKE', 'IN', 'NOT IN', 'BETWEEN', 'NOT BETWEEN', 'EXISTS' and 'NOT EXISTS'. Default value is '='.type(string) – Custom field type. Possible values are ‘NUMERIC’, ‘BINARY’, ‘CHAR’, ‘DATE’, ‘DATETIME’, ‘DECIMAL’, ‘SIGNED’, ‘TIME’, ‘UNSIGNED’. Default value is ‘CHAR’.
The ‘type’ DATE works with the ‘compare’ value BETWEEN only if the date is stored at the format YYYY-MM-DD and tested with this format.
Important Note: meta_query takes an array of meta query arguments arrays (it takes an array of arrays) – you can see this in the examples below.
This construct allows you to query multiple metadatas by using the relation parameter in the first (outer) array to describe the boolean relationship between the meta queries. Accepted arguments are ‘AND’, ‘OR’. The default is ‘AND’.
Simple Custom Field Query:
Display posts where the custom field key is ‘color’, regardless of the custom field value:
$query = new WP_Query( array( 'meta_key' => 'color' ) );
Display posts where the custom field value is ‘blue’, regardless of the custom field key:
$query = new WP_Query( array( 'meta_value' => 'blue' ) );
Display page where the custom field value is ‘blue’, regardless of the custom field key:
$args = array( 'meta_value' => 'blue', 'post_type' => 'page' ); $query = new WP_Query( $args );
Display posts where the custom field key is ‘color’ and the custom field value is ‘blue’:
$args = array( 'meta_key' => 'color', 'meta_value' => 'blue' ); $query = new WP_Query( $args );
Display posts where the custom field key is ‘color’ and the custom field value IS NOT ‘blue’:
$args = array( 'meta_key' => 'color', 'meta_value' => 'blue', 'meta_compare' => '!=' ); $query = new WP_Query( $args );
Display posts where the custom field key is a set date and the custom field value is now. Displays only posts which date has not passed.
$args = array( 'post_type' => 'event', 'meta_key' => 'event_date', 'meta_value' => date( "Ymd" ), // change to how "event date" is stored 'meta_compare' => '>', ); $query = new WP_Query( $args );
Display ‘product'(s) where the custom field key is ‘price’ and the custom field value that is LESS THAN OR EQUAL TO 22.
By using the ‘meta_value’ parameter the value 99 will be considered greater than 100 as the data are stored as ‘strings’, not ‘numbers’. For number comparison use ‘meta_value_num’.
$args = array( 'meta_key' => 'price', 'meta_value' => '22', 'meta_compare' => '<=', 'post_type' => 'product' ); $query = new WP_Query( $args );
Display posts with a custom field value of zero (0), regardless of the custom field key:
$args = array( 'meta_value' => '_wp_zero_value' ); $query = new WP_Query( $args );
Display posts from a single custom field:
$args = array( 'post_type' => 'product', 'meta_query' => array( array( 'key' => 'color', 'value' => 'blue', 'compare' => 'NOT LIKE', ), ), ); $query = new WP_Query( $args );
(Note that meta_query expects nested arrays, even if you only have one query.)
Display posts from several custom field:
$args = array( 'post_type' => 'product', 'meta_query' => array( array( 'key' => 'color', 'value' => 'blue', 'compare' => 'NOT LIKE', ), array( 'key' => 'price', 'value' => array( 20, 100 ), 'type' => 'numeric', 'compare' => 'BETWEEN', ), ), ); $query = new WP_Query( $args );
Display posts that have meta key ‘color’ NOT LIKE value ‘blue’ OR meta key ‘price’ with values BETWEEN 20 and 100:
$args = array( 'post_type' => 'product', 'meta_query' => array( 'relation' => 'OR', array( 'key' => 'color', 'value' => 'blue', 'compare' => 'NOT LIKE', ), array( 'key' => 'price', 'value' => array( 20, 100 ), 'type' => 'numeric', 'compare' => 'BETWEEN', ), ), ); $query = new WP_Query( $args );
The 'meta_query' clauses can be nested in order to construct complex queries. For example, show productss where color=orange OR color=red&size=small translates to the following:
$args = array(
'post_type' => 'product',
'meta_query' => array(
'relation' => 'OR',
array(
'key' => 'color',
'value' => 'orange',
'compare' => '=',
),
array(
'relation' => 'AND',
array(
'key' => 'color',
'value' => 'red',
'compare' => '=',
),
array(
'key' => 'size',
'value' => 'small',
'compare' => '=',
),
),
),
);
$query = new WP_Query( $args );
Permission Parameters Permission Parameters
* perm (string) – User permission.
Show posts if user has the appropriate capability:
Display published and private posts, if the user has the appropriate capability:
$args = array( 'post_status' => array( 'publish', 'private' ), 'perm' => 'readable', ); $query = new WP_Query( $args );
Mime Type Parameters Mime Type Parameters
Used with the attachments post type.
* post_mime_type (string/array) – Allowed mime types.
Get attachments that are gif images:
Get gif images and remember that by default the attachment’s post_status is set to inherit.
$args = array( 'post_type' => 'attachment', 'post_status' => 'inherit', 'post_mime_type' => 'image/gif', ); $query = new WP_Query( $args );
Get attachments that are not images:
To exclude certain mime types you first need to get all mime types using get_allowed_mime_types() and run a difference between arrays of what you want and the allowed mime types with array_diff().
$unsupported_mimes = array( 'image/jpeg', 'image/gif', 'image/png', 'image/bmp', 'image/tiff', 'image/x-icon' );
$all_mimes = get_allowed_mime_types();
$accepted_mimes = array_diff( $all_mimes, $unsupported_mimes );
$args = array(
'post_type' => 'attachment',
'post_status' => 'inherit',
'post_mime_type' => $accepted_mimes,
);
$query = new WP_Query( $query_args );
Caching Parameters Caching Parameters
Stop the data retrieved from being added to the cache.
* cache_results (boolean) – Post information cache.
* update_post_meta_cache (boolean) – Post meta information cache.
* update_post_term_cache (boolean) – Post term information cache.
Show Posts without adding post information to the cache
Display 50 posts, but don’t add post information to the cache:
$args = array( 'posts_per_page' => 50, 'cache_results' => false ); $query = new WP_Query( $args );
Show Posts without adding post meta information to the cache
Display 50 posts, but don’t add post meta information to the cache:
$args = array( 'posts_per_page' => 50, 'update_post_meta_cache' => false ); $query = new WP_Query( $args );
Show Posts without adding post term information to the cache
Display 50 posts, but don’t add post term information to the cache:
$args = array( 'posts_per_page' => 50, 'update_post_term_cache' => false ); $query = new WP_Query( $args );
In general usage you should not need to use these, adding to the cache is the right thing to do, however they may be useful in specific circumstances. An example of such circumstances might be when using a WP_Query to retrieve a list of post titles and URLs to be displayed, but in which no other information about the post will be used and the taxonomy and meta data won’t be needed. By not loading this information, you can save time from the extra unnecessary SQL queries.
Note: If a persistent object cache backend (such as memcached) is used, these flags are set to false by default since there is no need to update the cache every page load when a persistent cache exists.
Return Fields Parameter Return Fields Parameter
Set return values.
fields (string) – Which fields to return. There are several options:
* 'all' – Return all fields (default).
* 'ids' – Return an array of post IDs.
* 'id=>parent' – Return an array of stdClass objects with ID and post_parent properties.
Passing anything else will return all fields (default) – an array of post objects.
Methods Methods
- __call — Make private/protected methods readable for backward compatibility.
- __construct — Constructor.
- __get — Make private properties readable for backward compatibility.
- __isset — Make private properties checkable for backward compatibility.
- __unset — Make private properties settable for backwards compatibility.
- fill_query_vars — Fills in the query variables, which do not exist within the parameter.
- get — Retrieve query variable.
- get_posts — Retrieves an array of posts based on query variables.
- get_queried_object — Retrieve queried object.
- get_queried_object_id — Retrieve ID of the current queried object.
- get_search_stopwords — Retrieve stopwords used when parsing search terms.
- have_comments — Whether there are more comments available.
- have_posts — Determines whether there are more posts available in the loop.
- init — Initiates object properties and sets default values.
- init_query_flags — Resets query flags to false.
- is_404 — Is the query a 404 (returns no results)?
- is_archive — Is the query for an existing archive page?
- is_attachment — Is the query for an existing attachment page?
- is_author — Is the query for an existing author archive page?
- is_category — Is the query for an existing category archive page?
- is_comment_feed — Is the query for a comments feed?
- is_comments_popup — Whether the current URL is within the comments popup window. — deprecated
- is_date — Is the query for an existing date archive?
- is_day — Is the query for an existing day archive?
- is_embed — Is the query for an embedded post?
- is_feed — Is the query for a feed?
- is_front_page — Is the query for the front page of the site?
- is_home — Is the query for the blog homepage?
- is_main_query — Is the query the main query?
- is_month — Is the query for an existing month archive?
- is_page — Is the query for an existing single page?
- is_paged — Is the query for paged result and not for the first page?
- is_post_type_archive — Is the query for an existing post type archive page?
- is_preview — Is the query for a post or page preview?
- is_robots — Is the query for the robots file?
- is_search — Is the query for a search?
- is_single — Is the query for an existing single post?
- is_singular — Is the query for an existing single post of any post type (post, attachment, page, custom post types)?
- is_tag — Is the query for an existing tag archive page?
- is_tax — Is the query for an existing custom taxonomy archive page?
- is_time — Is the query for a specific time?
- is_trackback — Is the query for a trackback endpoint call?
- is_year — Is the query for an existing year archive?
- lazyload_comment_meta — Lazyload comment meta for comments in the loop. — deprecated
- lazyload_term_meta — Lazyload term meta for posts in the loop. — deprecated
- next_comment — Iterate current comment index and return WP_Comment object.
- next_post — Set up the next post and iterate current post index.
- parse_order — Parse an 'order' query variable and cast it to ASC or DESC as necessary.
- parse_orderby — Converts the given orderby alias (if allowed) to a properly-prefixed value.
- parse_query — Parse a query string and set query type booleans.
- parse_query_vars — Reparse the query vars.
- parse_search — Generates SQL for the WHERE clause based on passed search terms.
- parse_search_order — Generates SQL for the ORDER BY condition based on passed search terms.
- parse_search_terms — Check if the terms are suitable for searching.
- parse_tax_query — Parses various taxonomy related query vars.
- query — Sets up the WordPress query by parsing query string.
- reset_postdata — After looping through a nested query, this function restores the $post global to the current post in this query.
- rewind_comments — Rewind the comments, resets the comment index and comment to first.
- rewind_posts — Rewind the posts and reset post index.
- set — Set query variable.
- set_404 — Sets the 404 property and saves whether query is feed.
- set_found_posts — Set up the amount of found posts and the number of pages (if limit clause was used) for the current query.
- setup_postdata — Set up global post data.
- the_comment — Sets up the current comment.
- the_post — Sets up the current post.
User Contributed Notes User Contributed Notes
You must log in before being able to contribute a note or feedback.
Beware of setting the
'post_status'to anything other than'public', as it can easily lead to an information disclosure vulnerability if you are not careful.Normally
WP_Queryapplies logic that will ensure that it only returns posts that the current user should be able to view (e.g.,privateposts are excluded from low-privilege users). However, when you supply a value for'post_status'this capability-checking logic is effectively disabled. This means that if you pass'post_status'as'private', private posts will be returned even if the current user is not even logged in.To ensure that the proper capability checks are applied, you must use the
'perm'arg as well. It has two possible values:'readable'and'editable'. Passing this will ensure that only posts are returned that the user is allowed to read or edit, respectively.In summary, always set
'perm' => 'readable'when passing the'post_status'arg, if you are going to be exposing the query results to the user in any way. And if the posts are going to be modified, pass'perm' => 'editable'.WordPress WP_Query Generator:
https://GenerateWP.com/wp_query/
When using the `fields` parameter passed to WP_Query, the Object Cache parameters will be set to `false` by WP_Query:
The reason being there’s no objects being returned and thus no objects to cache.
If WP_Query determines that the result will be singular (
is_singular()is true), it will ignore thetax_queryparameter. To modifytax_query, use theposts_clausesfilter to add the required SQL statements.Just a note — if you ever have occasion to use a
NOT EXISTSclause, this will generate a sub-select in the SQL, which could be a performance problem in high-traffic environments.For example:
$args = [ 'post_type' => 'post', 'post_status' => 'publish', 'posts_per_page' => 1, 'tax_query' => [ 'relation' => 'OR', [ 'taxonomy' => 'team', 'field' => 'slug', 'terms' => $team_slug, ], [ 'taxonomy' => 'team', 'field' => 'id', 'operator' => 'NOT EXISTS', ], ], 'date_query' => [ [ 'before' => $post_date, 'inclusive' => false, ] ], 'ignore_sticky_posts' => 1, ];Expand full source codeCollapse full source code
This is a “previous post” query that tries to match the same ‘team’ taxonomy term of the current post, or a post with no ‘team’ taxonomy term set. We deployed code similar to this on a high-traffic site, and it immediately ran into problems due to the MySQL load. Fortunately, we were able to implement an alternative quickly.
I would recommend doing load testing in a test environment if you find yourself needing to use
EXISTSorNOT EXISTS.The documentation states that `
tax` parameter is deprecated since 3.1(not working anymore) in favor of `tax_query`, but it does not explain how to use `tax_query` to get all posts that belongs to a taxonomy, regardless of `terms` value.Long story, short. If you want to get all posts from a specific taxonomy, set the `
operator` to `EXISTS`.$args = array( 'post_type' => 'post', 'post_status' => 'publish', 'tax_query' => array( array( 'taxonomy' => 'custom_taxonomy_slug', 'operator' => 'EXISTS' ), ), );Note: make sure to set the
post_typevalue and replace thecustom_taxonomy_slugstring, if you copy/paste this snippet.A great way to learn about
WP_Queryis watching this talk:http://wordpress.tv/2013/03/15/andrew-nacin-wp_query-wordpress-in-depth/