2006-03-12 20:44:32 -05:00
< ? php
2008-09-04 15:19:32 -04:00
/**
* WordPress Query API
*
2013-04-25 19:10:36 -04:00
* The query API attempts to get which part of WordPress the user is on . It
* also provides functionality for getting URL query information .
2008-09-04 15:19:32 -04:00
*
2015-04-12 17:29:32 -04:00
* @ link https :// codex . wordpress . org / The_Loop More information on The Loop .
2008-09-04 15:19:32 -04:00
*
* @ package WordPress
* @ subpackage Query
2006-03-12 20:44:32 -05:00
*/
2006-11-19 02:56:05 -05:00
2008-09-04 15:19:32 -04:00
/**
* Retrieve variable in the WP_Query class .
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
2014-02-26 18:58:14 -05:00
* @ param string $var The variable key to retrieve .
* @ param mixed $default Value to return if the query variable is not set . Default '' .
2008-09-04 15:19:32 -04:00
* @ return mixed
*/
2014-02-26 18:58:14 -05:00
function get_query_var ( $var , $default = '' ) {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2014-02-26 18:58:14 -05:00
return $wp_query -> get ( $var , $default );
2006-03-12 20:44:32 -05:00
}
2010-10-29 16:48:54 -04:00
/**
2011-12-13 18:45:31 -05:00
* Retrieve the currently - queried object . Wrapper for $wp_query -> get_queried_object ()
2010-10-29 16:48:54 -04:00
*
* @ since 3.1 . 0
* @ access public
*
2015-05-27 14:15:25 -04:00
* @ global WP_Query $wp_query
*
2010-10-29 16:48:54 -04:00
* @ return object
*/
function get_queried_object () {
global $wp_query ;
return $wp_query -> get_queried_object ();
}
/**
* Retrieve ID of the current queried object . Wrapper for $wp_query -> get_queried_object_id ()
2010-11-17 13:47:34 -05:00
*
2010-10-29 16:48:54 -04:00
* @ since 3.1 . 0
* @ access public
*
2015-05-27 14:15:25 -04:00
* @ global WP_Query $wp_query
*
2010-10-29 16:48:54 -04:00
* @ return int
*/
function get_queried_object_id () {
global $wp_query ;
return $wp_query -> get_queried_object_id ();
}
2008-09-04 15:19:32 -04:00
/**
* Set query variable .
*
* @ since 2.2 . 0
*
2015-05-27 14:15:25 -04:00
* @ global WP_Query $wp_query
*
* @ param string $var Query variable key .
* @ param mixed $value
2008-09-04 15:19:32 -04:00
*/
2015-05-27 14:15:25 -04:00
function set_query_var ( $var , $value ) {
2007-02-24 02:33:29 -05:00
global $wp_query ;
2015-05-27 14:15:25 -04:00
$wp_query -> set ( $var , $value );
2007-02-24 02:33:29 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2010-03-17 00:39:50 -04:00
* Set up The Loop with query parameters .
2008-09-04 15:19:32 -04:00
*
* This will override the current WordPress Loop and shouldn ' t be used more than
* once . This must not be used within the WordPress Loop .
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ param string $query
* @ return array List of posts
*/
2012-09-10 13:00:11 -04:00
function query_posts ( $query ) {
2011-10-18 16:20:59 -04:00
$GLOBALS [ 'wp_query' ] = new WP_Query ();
2006-11-09 01:50:58 -05:00
return $GLOBALS [ 'wp_query' ] -> query ( $query );
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2010-03-17 00:39:50 -04:00
* Destroy the previous query and set up a new query .
2008-09-04 15:19:32 -04:00
*
* This should be used after { @ link query_posts ()} and before another { @ link
* query_posts ()} . This will remove obscure bugs that occur when the previous
2010-03-17 00:39:50 -04:00
* wp_query object is not destroyed properly before another is set up .
2008-09-04 15:19:32 -04:00
*
* @ since 2.3 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
* @ global WP_Query $wp_the_query
2008-09-04 15:19:32 -04:00
*/
2007-08-20 18:55:43 -04:00
function wp_reset_query () {
2011-10-18 16:20:59 -04:00
$GLOBALS [ 'wp_query' ] = $GLOBALS [ 'wp_the_query' ];
2010-05-13 16:39:54 -04:00
wp_reset_postdata ();
}
/**
* After looping through a separate query , this function restores
2013-09-24 11:53:09 -04:00
* the $post global to the current post in the main query .
2010-05-13 16:39:54 -04:00
*
* @ since 3.0 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2010-05-13 16:39:54 -04:00
*/
function wp_reset_postdata () {
2008-01-23 13:20:59 -05:00
global $wp_query ;
2014-01-11 18:57:14 -05:00
if ( isset ( $wp_query ) ) {
$wp_query -> reset_postdata ();
}
2007-08-20 18:55:43 -04:00
}
2006-03-12 20:44:32 -05:00
/*
* Query type checks .
*/
2008-09-04 15:19:32 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing archive page ?
2008-09-04 15:19:32 -04:00
*
2010-10-23 15:20:47 -04:00
* Month , Year , Category , Author , Post Type archive ...
2010-10-14 06:39:47 -04:00
*
2008-09-04 15:19:32 -04:00
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
2010-08-25 14:05:33 -04:00
* @ return bool
2008-09-04 15:19:32 -04:00
*/
2010-10-23 23:27:01 -04:00
function is_archive () {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-10-23 23:27:01 -04:00
return $wp_query -> is_archive ();
2006-03-12 20:44:32 -05:00
}
2010-10-15 15:44:57 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing post type archive page ?
2010-10-15 15:44:57 -04:00
*
* @ since 3.1 . 0
*
2015-05-27 14:15:25 -04:00
* @ global WP_Query $wp_query
*
* @ param string | array $post_types Optional . Post type or array of posts types to check against .
2010-10-15 15:44:57 -04:00
* @ return bool
*/
function is_post_type_archive ( $post_types = '' ) {
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-10-15 15:44:57 -04:00
return $wp_query -> is_post_type_archive ( $post_types );
}
2010-10-19 03:48:22 -04:00
2008-09-04 15:19:32 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing attachment page ?
2008-09-04 15:19:32 -04:00
*
* @ since 2.0 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
2014-11-30 21:17:21 -05:00
* @ param int | string | array | object $attachment Attachment ID , title , slug , or array of such .
2010-08-25 14:05:33 -04:00
* @ return bool
2008-09-04 15:19:32 -04:00
*/
2014-01-22 17:31:12 -05:00
function is_attachment ( $attachment = '' ) {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2014-01-22 17:31:12 -05:00
return $wp_query -> is_attachment ( $attachment );
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing author archive page ?
2008-09-04 15:19:32 -04:00
*
2010-08-25 14:05:33 -04:00
* If the $author parameter is specified , this function will additionally
* check if the query is for one of the authors specified .
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
2010-08-25 14:05:33 -04:00
* @ param mixed $author Optional . User ID , nickname , nicename , or array of User IDs , nicknames , and nicenames
* @ return bool
2008-09-04 15:19:32 -04:00
*/
2010-08-25 14:05:33 -04:00
function is_author ( $author = '' ) {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_author ( $author );
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing category archive page ?
2008-09-04 15:19:32 -04:00
*
2010-08-25 14:05:33 -04:00
* If the $category parameter is specified , this function will additionally
* check if the query is for one of the categories specified .
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
2010-08-25 14:05:33 -04:00
* @ param mixed $category Optional . Category ID , name , slug , or array of Category IDs , names , and slugs .
2008-09-04 15:19:32 -04:00
* @ return bool
*/
2010-08-25 14:05:33 -04:00
function is_category ( $category = '' ) {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_category ( $category );
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing tag archive page ?
2010-08-25 14:05:33 -04:00
*
* If the $tag parameter is specified , this function will additionally
* check if the query is for one of the tags specified .
2008-09-04 15:19:32 -04:00
*
* @ since 2.3 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
2013-09-06 13:27:08 -04:00
* @ param mixed $tag Optional . Tag ID , name , slug , or array of Tag IDs , names , and slugs .
2008-09-04 15:19:32 -04:00
* @ return bool
*/
2013-09-06 13:27:08 -04:00
function is_tag ( $tag = '' ) {
2007-03-31 02:16:12 -04:00
global $wp_query ;
2008-02-13 14:02:08 -05:00
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2013-09-06 13:27:08 -04:00
return $wp_query -> is_tag ( $tag );
2007-03-31 02:16:12 -04:00
}
2008-09-04 15:19:32 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing taxonomy archive page ?
2010-08-25 14:05:33 -04:00
*
* If the $taxonomy parameter is specified , this function will additionally
* check if the query is for that specific $taxonomy .
2010-02-28 00:59:39 -05:00
*
2010-08-25 14:05:33 -04:00
* 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 .
2008-09-04 15:19:32 -04:00
*
* @ since 2.5 . 0
*
2015-05-27 14:15:25 -04:00
* @ global WP_Query $wp_query
*
* @ param string | array $taxonomy Optional . Taxonomy slug or slugs .
* @ param int | string | array $term Optional . Term ID , name , slug or array of Term IDs , names , and slugs .
2008-09-04 15:19:32 -04:00
* @ return bool
*/
2010-02-28 00:59:39 -05:00
function is_tax ( $taxonomy = '' , $term = '' ) {
2010-12-15 07:21:27 -05:00
global $wp_query ;
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2008-08-09 01:36:14 -04:00
2010-08-25 14:05:33 -04:00
return $wp_query -> is_tax ( $taxonomy , $term );
2008-03-23 13:02:11 -04:00
}
2008-09-04 15:19:32 -04:00
/**
* Whether the current URL is within the comments popup window .
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return bool
*/
2010-03-20 22:52:00 -04:00
function is_comments_popup () {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_comments_popup ();
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing date archive ?
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return bool
*/
2010-03-20 22:52:00 -04:00
function is_date () {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_date ();
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing day archive ?
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return bool
*/
2010-03-20 22:52:00 -04:00
function is_day () {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_day ();
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2010-08-25 14:05:33 -04:00
* Is the query for a feed ?
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
2010-11-17 22:19:08 -05:00
* @ param string | array $feeds Optional feed types to check .
2008-09-04 15:19:32 -04:00
* @ return bool
*/
2010-11-17 22:19:08 -05:00
function is_feed ( $feeds = '' ) {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-11-17 22:19:08 -05:00
return $wp_query -> is_feed ( $feeds );
2006-03-12 20:44:32 -05:00
}
2009-12-22 09:04:14 -05:00
/**
2010-08-25 14:05:33 -04:00
* Is the query for a comments feed ?
2009-12-22 09:04:14 -05:00
*
* @ since 3.0 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2009-12-22 09:04:14 -05:00
*
* @ return bool
*/
2010-03-20 22:52:00 -04:00
function is_comment_feed () {
2009-12-22 09:04:14 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_comment_feed ();
2009-12-22 09:04:14 -05:00
}
2008-02-01 19:13:34 -05:00
/**
2010-08-25 14:05:33 -04:00
* 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 ' .
2008-02-01 19:13:34 -05:00
*
2010-08-25 14:05:33 -04:00
* 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 is_home ()
*
2008-09-04 15:19:32 -04:00
* @ since 2.5 . 0
2008-02-01 19:13:34 -05:00
*
2015-05-27 14:15:25 -04:00
* @ global WP_Query $wp_query
*
2008-09-04 15:19:32 -04:00
* @ return bool True , if front of site .
2008-02-01 19:13:34 -05:00
*/
2010-03-20 22:52:00 -04:00
function is_front_page () {
2010-08-25 14:05:33 -04:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_front_page ();
2008-02-05 01:47:27 -05:00
}
2008-02-01 19:13:34 -05:00
/**
2010-08-25 14:05:33 -04:00
* 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 ' .
2010-01-15 17:11:12 -05:00
*
2010-08-25 14:05:33 -04:00
* 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 " .
2008-02-01 19:13:34 -05:00
*
2010-08-25 14:05:33 -04:00
* @ see is_front_page ()
*
2008-09-04 15:19:32 -04:00
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-02-01 19:13:34 -05:00
*
2008-09-04 15:19:32 -04:00
* @ return bool True if blog view homepage .
2008-02-01 19:13:34 -05:00
*/
2010-03-20 22:52:00 -04:00
function is_home () {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_home ();
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing month archive ?
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return bool
*/
2010-03-20 22:52:00 -04:00
function is_month () {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_month ();
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing single page ?
2008-09-04 15:19:32 -04:00
*
2010-08-25 14:05:33 -04:00
* If the $page parameter is specified , this function will additionally
2010-12-09 00:27:37 -05:00
* check if the query is for one of the pages specified .
2008-09-04 15:19:32 -04:00
*
2010-08-25 14:05:33 -04:00
* @ see is_single ()
* @ see is_singular ()
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
2010-12-09 00:27:37 -05:00
* @ param mixed $page Page ID , title , slug , or array of such .
2008-09-04 15:19:32 -04:00
* @ return bool
*/
2010-08-25 14:05:33 -04:00
function is_page ( $page = '' ) {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_page ( $page );
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2010-08-25 14:05:33 -04:00
* Is the query for paged result and not for the first page ?
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return bool
*/
2010-03-20 22:52:00 -04:00
function is_paged () {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_paged ();
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2010-08-25 14:05:33 -04:00
* Is the query for a post or page preview ?
2008-09-04 15:19:32 -04:00
*
* @ since 2.0 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return bool
*/
2006-03-12 20:44:32 -05:00
function is_preview () {
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_preview ();
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2010-08-25 14:05:33 -04:00
* Is the query for the robots file ?
2008-09-04 15:19:32 -04:00
*
* @ since 2.1 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return bool
*/
2006-05-22 18:06:06 -04:00
function is_robots () {
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_robots ();
2006-05-22 18:06:06 -04:00
}
2008-09-04 15:19:32 -04:00
/**
2010-08-25 14:05:33 -04:00
* Is the query for a search ?
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return bool
*/
2010-03-20 22:52:00 -04:00
function is_search () {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_search ();
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing single post ?
2010-08-25 14:05:33 -04:00
*
2010-12-09 00:27:37 -05:00
* Works for any post type , except attachments and pages
*
2010-08-25 14:05:33 -04:00
* If the $post parameter is specified , this function will additionally
* check if the query is for one of the Posts specified .
2008-09-04 15:19:32 -04:00
*
2010-08-25 14:05:33 -04:00
* @ see is_page ()
* @ see is_singular ()
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
2010-12-09 00:27:37 -05:00
* @ param mixed $post Post ID , title , slug , or array of such .
2008-09-04 15:19:32 -04:00
* @ return bool
*/
2010-08-25 14:05:33 -04:00
function is_single ( $post = '' ) {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_single ( $post );
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing single post of any post type ( post , attachment , page , ... ) ?
2008-09-04 15:19:32 -04:00
*
2010-08-25 14:05:33 -04:00
* If the $post_types parameter is specified , this function will additionally
* check if the query is for one of the Posts Types specified .
*
* @ see is_page ()
* @ see is_single ()
*
2008-09-04 15:19:32 -04:00
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
2010-08-25 14:05:33 -04:00
* @ param mixed $post_types Optional . Post Type or array of Post Types
2008-09-04 15:19:32 -04:00
* @ return bool
*/
2010-08-25 14:05:33 -04:00
function is_singular ( $post_types = '' ) {
2006-08-29 23:33:39 -04:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_singular ( $post_types );
2006-08-29 23:33:39 -04:00
}
2008-09-04 15:19:32 -04:00
/**
2010-08-25 14:05:33 -04:00
* Is the query for a specific time ?
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return bool
*/
2010-03-20 22:52:00 -04:00
function is_time () {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_time ();
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2010-08-25 14:05:33 -04:00
* Is the query for a trackback endpoint call ?
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return bool
*/
2010-03-20 22:52:00 -04:00
function is_trackback () {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_trackback ();
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing year archive ?
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return bool
*/
2010-03-20 22:52:00 -04:00
function is_year () {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_year ();
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2010-08-25 14:05:33 -04:00
* Is the query a 404 ( returns no results ) ?
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
2010-08-25 14:05:33 -04:00
* @ return bool
2008-09-04 15:19:32 -04:00
*/
2010-03-20 22:52:00 -04:00
function is_404 () {
2006-03-12 20:44:32 -05:00
global $wp_query ;
2010-12-15 07:21:27 -05:00
if ( ! isset ( $wp_query ) ) {
2010-12-20 11:21:42 -05:00
_doing_it_wrong ( __FUNCTION__ , __ ( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1' );
2010-12-19 16:17:52 -05:00
return false ;
2010-12-15 07:21:27 -05:00
}
2010-08-25 14:05:33 -04:00
return $wp_query -> is_404 ();
2006-03-12 20:44:32 -05:00
}
2011-09-17 16:46:35 -04:00
/**
* Is the query the main query ?
*
* @ since 3.3 . 0
*
2015-05-27 14:15:25 -04:00
* @ global WP_Query $wp_query
*
2011-09-17 16:46:35 -04:00
* @ return bool
*/
function is_main_query () {
2013-09-24 13:10:09 -04:00
if ( 'pre_get_posts' === current_filter () ) {
$message = sprintf ( __ ( 'In <code>%1$s</code>, use the <code>%2$s</code> method, not the <code>%3$s</code> function. See %4$s.' ),
2015-04-12 17:29:32 -04:00
'pre_get_posts' , 'WP_Query::is_main_query()' , 'is_main_query()' , __ ( 'https://codex.wordpress.org/Function_Reference/is_main_query' ) );
2013-09-24 13:10:09 -04:00
_doing_it_wrong ( __FUNCTION__ , $message , '3.7' );
}
2011-09-17 16:46:35 -04:00
global $wp_query ;
return $wp_query -> is_main_query ();
}
2006-03-12 20:44:32 -05:00
/*
2011-12-13 18:45:31 -05:00
* The Loop . Post loop control .
2006-03-12 20:44:32 -05:00
*/
2006-11-19 02:56:05 -05:00
2008-09-04 15:19:32 -04:00
/**
* Whether current WordPress query has results to loop over .
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return bool
*/
2006-03-12 20:44:32 -05:00
function have_posts () {
global $wp_query ;
return $wp_query -> have_posts ();
}
2008-09-04 15:19:32 -04:00
/**
* Whether the caller is in the Loop .
*
* @ since 2.0 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return bool True if caller is within loop , false if loop hasn ' t started or ended .
*/
2006-03-12 20:44:32 -05:00
function in_the_loop () {
global $wp_query ;
return $wp_query -> in_the_loop ;
}
2008-09-04 15:19:32 -04:00
/**
* Rewind the loop posts .
*
* @ since 1.5 . 0
*
2015-05-27 14:15:25 -04:00
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*/
2006-03-12 20:44:32 -05:00
function rewind_posts () {
global $wp_query ;
2015-05-27 14:15:25 -04:00
$wp_query -> rewind_posts ();
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
* Iterate the post index in the loop .
*
* @ since 1.5 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*/
2006-03-12 20:44:32 -05:00
function the_post () {
global $wp_query ;
$wp_query -> the_post ();
}
2007-02-24 02:33:29 -05:00
/*
2007-09-03 19:32:58 -04:00
* Comments loop .
*/
2007-02-24 02:33:29 -05:00
2008-09-04 15:19:32 -04:00
/**
* Whether there are comments to loop over .
*
* @ since 2.2 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return bool
*/
2007-09-03 19:32:58 -04:00
function have_comments () {
global $wp_query ;
return $wp_query -> have_comments ();
}
2007-02-24 02:33:29 -05:00
2008-09-04 15:19:32 -04:00
/**
* Iterate comment index in the comment loop .
*
* @ since 2.2 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Query $wp_query
2008-09-04 15:19:32 -04:00
*
* @ return object
*/
2007-09-03 19:32:58 -04:00
function the_comment () {
global $wp_query ;
return $wp_query -> the_comment ();
}
2007-02-24 02:33:29 -05:00
2006-03-12 20:44:32 -05:00
/*
* WP_Query
*/
2008-09-04 15:19:32 -04:00
/**
* The WordPress Query class .
*
2015-04-12 17:29:32 -04:00
* @ link https :// codex . wordpress . org / Function_Reference / WP_Query Codex page .
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
*/
2010-11-13 13:32:43 -05:00
class WP_Query {
2010-11-13 13:26:15 -05:00
2008-09-04 15:19:32 -04:00
/**
2010-11-13 13:26:15 -05:00
* Query vars set by the user
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
* @ access public
2010-08-28 07:09:18 -04:00
* @ var array
2008-09-04 15:19:32 -04:00
*/
2014-05-19 02:49:16 -04:00
public $query ;
2008-09-04 15:19:32 -04:00
2010-11-13 13:26:15 -05:00
/**
* Query vars , after parsing
*
* @ since 1.5 . 0
* @ access public
* @ var array
*/
2014-05-19 02:49:16 -04:00
public $query_vars = array ();
2010-11-13 13:26:15 -05:00
2010-11-16 21:04:08 -05:00
/**
* Taxonomy query , as passed to get_tax_sql ()
*
* @ since 3.1 . 0
* @ access public
2010-12-09 14:29:21 -05:00
* @ var object WP_Tax_Query
2010-11-16 21:04:08 -05:00
*/
2014-05-19 02:49:16 -04:00
public $tax_query ;
2010-11-16 21:04:08 -05:00
2011-04-25 13:27:35 -04:00
/**
* Metadata query container
*
2011-06-11 00:40:18 -04:00
* @ since 3.2 . 0
2011-04-25 13:27:35 -04:00
* @ access public
* @ var object WP_Meta_Query
*/
2014-05-19 02:49:16 -04:00
public $meta_query = false ;
2011-04-25 13:27:35 -04:00
2013-08-27 12:39:09 -04:00
/**
* Date query container
*
* @ since 3.7 . 0
* @ access public
* @ var object WP_Date_Query
*/
2014-05-19 02:49:16 -04:00
public $date_query = false ;
2013-08-27 12:39:09 -04:00
2008-09-04 15:19:32 -04:00
/**
* Holds the data for a single object that is queried .
*
* Holds the contents of a post , page , category , attachment .
*
* @ since 1.5 . 0
* @ access public
* @ var object | array
*/
2014-05-19 02:49:16 -04:00
public $queried_object ;
2008-09-04 15:19:32 -04:00
/**
* The ID of the queried object .
*
* @ since 1.5 . 0
* @ access public
* @ var int
*/
2014-05-19 02:49:16 -04:00
public $queried_object_id ;
2008-09-04 15:19:32 -04:00
/**
* Get post database query .
*
* @ since 2.0 . 1
* @ access public
* @ var string
*/
2014-05-19 02:49:16 -04:00
public $request ;
2006-03-12 20:44:32 -05:00
2008-09-04 15:19:32 -04:00
/**
* List of posts .
*
* @ since 1.5 . 0
* @ access public
* @ var array
*/
2014-05-19 02:49:16 -04:00
public $posts ;
2008-09-04 15:19:32 -04:00
/**
* The amount of posts for the current query .
*
* @ since 1.5 . 0
* @ access public
* @ var int
*/
2014-05-19 02:49:16 -04:00
public $post_count = 0 ;
2008-09-04 15:19:32 -04:00
/**
* Index of the current item in the loop .
*
* @ since 1.5 . 0
* @ access public
* @ var int
*/
2014-05-19 02:49:16 -04:00
public $current_post = - 1 ;
2008-09-04 15:19:32 -04:00
/**
* Whether the loop has started and the caller is in the loop .
*
* @ since 2.0 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $in_the_loop = false ;
2008-09-04 15:19:32 -04:00
/**
2013-08-23 18:02:08 -04:00
* The current post .
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
* @ access public
2013-08-23 18:02:08 -04:00
* @ var WP_Post
2008-09-04 15:19:32 -04:00
*/
2014-05-19 02:49:16 -04:00
public $post ;
2007-02-27 10:24:54 -05:00
2008-09-04 15:19:32 -04:00
/**
* The list of comments for current post .
*
* @ since 2.2 . 0
* @ access public
* @ var array
*/
2014-05-19 02:49:16 -04:00
public $comments ;
2008-09-04 15:19:32 -04:00
/**
* The amount of comments for the posts .
*
* @ since 2.2 . 0
* @ access public
* @ var int
*/
2014-05-19 02:49:16 -04:00
public $comment_count = 0 ;
2008-09-04 15:19:32 -04:00
/**
* The index of the comment in the comment loop .
*
* @ since 2.2 . 0
* @ access public
* @ var int
*/
2014-05-19 02:49:16 -04:00
public $current_comment = - 1 ;
2008-09-04 15:19:32 -04:00
/**
* Current comment ID .
*
* @ since 2.2 . 0
* @ access public
* @ var int
*/
2014-05-19 02:49:16 -04:00
public $comment ;
2006-03-12 20:44:32 -05:00
2008-09-04 15:19:32 -04:00
/**
2012-09-20 10:55:54 -04:00
* The amount of found posts for the current query .
*
* If limit clause was not used , equals $post_count .
2008-09-04 15:19:32 -04:00
*
* @ since 2.1 . 0
* @ access public
* @ var int
*/
2014-05-19 02:49:16 -04:00
public $found_posts = 0 ;
2008-09-04 15:19:32 -04:00
/**
* The amount of pages .
*
* @ since 2.1 . 0
* @ access public
* @ var int
*/
2014-05-19 02:49:16 -04:00
public $max_num_pages = 0 ;
2006-11-08 16:22:35 -05:00
2008-09-23 17:11:27 -04:00
/**
* The amount of comment pages .
*
* @ since 2.7 . 0
* @ access public
* @ var int
*/
2014-05-19 02:49:16 -04:00
public $max_num_comment_pages = 0 ;
2008-09-23 17:11:27 -04:00
2008-09-04 15:19:32 -04:00
/**
* Set if query is single post .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_single = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query is preview of blog .
*
* @ since 2.0 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_preview = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query returns a page .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_page = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query is an archive list .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_archive = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query is part of a date .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_date = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query contains a year .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_year = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query contains a month .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_month = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query contains a day .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_day = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query contains time .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_time = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query contains an author .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_author = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query contains category .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_category = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query contains tag .
*
* @ since 2.3 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_tag = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query contains taxonomy .
*
* @ since 2.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_tax = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query was part of a search result .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_search = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query is feed display .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_feed = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query is comment feed display .
*
* @ since 2.2 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_comment_feed = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query is trackback .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_trackback = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query is blog homepage .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_home = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query couldn ' t found anything .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_404 = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query is within comments popup window .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_comments_popup = false ;
2008-09-04 15:19:32 -04:00
2010-09-27 19:48:03 -04:00
/**
* Set if query is paged
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_paged = false ;
2010-09-27 19:48:03 -04:00
2008-09-04 15:19:32 -04:00
/**
* Set if query is part of administration page .
*
* @ since 1.5 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_admin = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query is an attachment .
*
* @ since 2.0 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_attachment = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if is single , is a page , or is an attachment .
*
* @ since 2.1 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_singular = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query is for robots .
*
* @ since 2.1 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_robots = false ;
2008-09-04 15:19:32 -04:00
/**
* Set if query contains posts .
*
* Basically , the homepage if the option isn ' t set for the static homepage .
*
* @ since 2.1 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_posts_page = false ;
2006-03-12 20:44:32 -05:00
2010-10-15 15:44:57 -04:00
/**
* Set if query is for a post type archive .
*
* @ since 3.1 . 0
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $is_post_type_archive = false ;
2010-10-15 15:44:57 -04:00
2011-01-09 15:49:11 -05:00
/**
2011-03-01 23:10:21 -05:00
* Stores the -> query_vars state like md5 ( serialize ( $this -> query_vars ) ) so we know
* whether we have to re - parse because something has changed
2011-01-09 15:49:11 -05:00
*
* @ since 3.1 . 0
* @ access private
2015-01-16 17:44:25 -05:00
* @ var bool | string
2011-01-09 15:49:11 -05:00
*/
2014-05-19 02:49:16 -04:00
private $query_vars_hash = false ;
2011-01-09 15:49:11 -05:00
2011-03-24 12:07:24 -04:00
/**
2011-12-13 18:45:31 -05:00
* Whether query vars have changed since the initial parse_query () call . Used to catch modifications to query vars made
2011-03-24 12:07:24 -04:00
* via pre_get_posts hooks .
*
* @ since 3.1 . 1
* @ access private
*/
2014-05-19 02:49:16 -04:00
private $query_vars_changed = true ;
2011-03-24 12:07:24 -04:00
2011-05-11 23:06:03 -04:00
/**
* Set if post thumbnails are cached
*
2011-06-11 00:40:18 -04:00
* @ since 3.2 . 0
2011-05-11 23:06:03 -04:00
* @ access public
* @ var bool
*/
2014-05-19 02:49:16 -04:00
public $thumbnails_cached = false ;
2011-05-11 23:06:03 -04:00
2013-09-27 13:34:09 -04:00
/**
* Cached list of search stopwords .
*
* @ since 3.7 . 0
* @ var array
*/
private $stopwords ;
2015-01-11 17:41:24 -05:00
private $compat_fields = array ( 'query_vars_hash' , 'query_vars_changed' );
private $compat_methods = array ( 'init_query_flags' , 'parse_tax_query' );
2008-09-04 15:19:32 -04:00
/**
* Resets query flags to false .
*
* The query flags are what page info WordPress was able to figure out .
*
* @ since 2.0 . 0
* @ access private
*/
2014-05-19 02:49:16 -04:00
private function init_query_flags () {
2006-03-12 20:44:32 -05:00
$this -> is_single = false ;
2010-09-27 19:48:03 -04:00
$this -> is_preview = false ;
2006-03-12 20:44:32 -05:00
$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 ;
2007-03-31 02:16:12 -04:00
$this -> is_tag = false ;
2008-03-23 13:02:11 -04:00
$this -> is_tax = false ;
2006-03-12 20:44:32 -05:00
$this -> is_search = false ;
$this -> is_feed = false ;
2007-02-24 02:33:29 -05:00
$this -> is_comment_feed = false ;
2006-03-12 20:44:32 -05:00
$this -> is_trackback = false ;
$this -> is_home = false ;
$this -> is_404 = false ;
2010-09-27 19:48:03 -04:00
$this -> is_comments_popup = false ;
2006-03-12 20:44:32 -05:00
$this -> is_paged = false ;
$this -> is_admin = false ;
$this -> is_attachment = false ;
2006-08-29 23:33:39 -04:00
$this -> is_singular = false ;
2006-05-22 18:06:06 -04:00
$this -> is_robots = false ;
2006-07-19 22:05:25 -04:00
$this -> is_posts_page = false ;
2010-10-15 15:44:57 -04:00
$this -> is_post_type_archive = false ;
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
* Initiates object properties and sets default values .
*
* @ since 1.5 . 0
* @ access public
*/
2014-05-19 02:49:16 -04:00
public function init () {
2006-03-12 20:44:32 -05:00
unset ( $this -> posts );
unset ( $this -> query );
2006-10-22 21:34:00 -04:00
$this -> query_vars = array ();
2006-03-12 20:44:32 -05:00
unset ( $this -> queried_object );
unset ( $this -> queried_object_id );
$this -> post_count = 0 ;
$this -> current_post = - 1 ;
$this -> in_the_loop = false ;
2010-09-27 19:48:03 -04:00
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 ;
2006-03-12 20:44:32 -05:00
$this -> init_query_flags ();
}
2008-09-04 15:19:32 -04:00
/**
* Reparse the query vars .
*
* @ since 1.5 . 0
* @ access public
*/
2014-05-19 02:49:16 -04:00
public function parse_query_vars () {
2011-02-15 18:57:13 -05:00
$this -> parse_query ();
2006-03-12 20:44:32 -05:00
}
2007-02-27 10:24:54 -05:00
2008-09-04 15:19:32 -04:00
/**
* Fills in the query variables , which do not exist within the parameter .
*
* @ since 2.1 . 0
* @ access public
*
* @ param array $array Defined query variables .
* @ return array Complete query variables with undefined ones filled in empty .
*/
2014-05-19 02:49:16 -04:00
public function fill_query_vars ( $array ) {
2006-09-21 17:05:38 -04:00
$keys = array (
'error'
, 'm'
, 'p'
2008-05-03 16:08:32 -04:00
, 'post_parent'
2006-09-21 17:05:38 -04:00
, 'subpost'
, 'subpost_id'
, 'attachment'
, 'attachment_id'
, 'name'
, 'static'
, 'pagename'
, 'page_id'
, 'second'
, 'minute'
, 'hour'
, 'day'
, 'monthnum'
, 'year'
, 'w'
, 'category_name'
2007-03-31 02:16:12 -04:00
, 'tag'
2008-08-08 13:05:10 -04:00
, 'cat'
2007-09-02 23:24:23 -04:00
, 'tag_id'
2013-09-04 17:33:09 -04:00
, 'author'
2006-09-21 17:05:38 -04:00
, 'author_name'
, 'feed'
, 'tb'
, 'paged'
, 'comments_popup'
2010-10-05 18:42:47 -04:00
, 'meta_key'
, 'meta_value'
2006-09-21 17:05:38 -04:00
, 'preview'
2010-02-28 02:47:11 -05:00
, 's'
, 'sentence'
2010-10-26 15:01:55 -04:00
, 'fields'
2012-09-04 19:18:14 -04:00
, 'menu_order'
2006-09-21 17:05:38 -04:00
);
2010-05-03 16:19:13 -04:00
foreach ( $keys as $key ) {
2010-10-26 15:01:55 -04:00
if ( ! isset ( $array [ $key ]) )
2006-09-21 17:05:38 -04:00
$array [ $key ] = '' ;
}
2007-02-27 10:24:54 -05:00
2013-02-15 21:08:46 -05:00
$array_keys = array ( 'category__in' , 'category__not_in' , 'category__and' , 'post__in' , 'post__not_in' ,
2013-09-04 17:33:09 -04:00
'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' );
2007-09-03 19:19:20 -04:00
2007-08-15 18:08:51 -04:00
foreach ( $array_keys as $key ) {
2010-10-26 15:01:55 -04:00
if ( ! isset ( $array [ $key ]) )
2007-08-15 18:08:51 -04:00
$array [ $key ] = array ();
}
2006-09-21 17:05:38 -04:00
return $array ;
}
2006-03-12 20:44:32 -05:00
2008-09-04 15:19:32 -04:00
/**
* Parse a query string and set query type booleans .
*
* @ since 1.5 . 0
2015-02-05 14:38:23 -05:00
* @ 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` .
2008-09-04 15:19:32 -04:00
* @ access public
*
2014-06-28 19:03:17 -04:00
* @ 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 int $comments_per_page The number of comments to return per page .
* Default 'comments_per_page' option .
* @ type int | string $comments_popup Whether the query is within the comments popup . Default empty .
* @ 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.
2014-12-20 18:04:23 -05:00
* @ type int | bool $ignore_sticky_posts Whether to ignore sticky posts or not . Setting this to false
2014-08-23 15:36:17 -04:00
* 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 .
2014-06-28 19:03:17 -04:00
* @ type string $meta_compare Comparison operator to test the 'meta_value' .
* @ type string $meta_key Custom field key .
* @ type array $meta_query An associative array of WP_Meta_Query arguments .
* { @ see WP_Meta_Query -> queries }
* @ 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 .
2014-08-19 03:28:15 -04:00
* @ type bool $no_found_rows Whether to skip counting the total rows found . Enabling can improve
* performance . Default false .
2014-06-28 19:03:17 -04:00
* @ 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' .
2015-02-05 14:38:23 -05:00
* @ type string | array $orderby Sort retrieved posts by parameter . One or more options may be
2014-06-28 19:03:17 -04:00
* passed . To use 'meta_value' , or 'meta_value_num' ,
2015-02-05 14:38:23 -05:00
* 'meta_key=keyname' must be also be defined . To sort by a
* specific `$meta_query` clause , use that clause ' s array key .
* Default 'date' . Accepts 'none' , 'name' , 'author' , 'date' ,
* 'title' , 'modified' , 'menu_order' , 'parent' , 'ID' , 'rand' ,
* 'comment_count' , 'meta_value' , 'meta_value_num' , and the
* array keys of `$meta_query` .
2014-06-28 19:03:17 -04:00
* @ 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 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 -
2014-08-23 15:36:17 -04:00
* separated IDs will NOT work .
2014-06-28 19:03:17 -04:00
* @ 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 string $s Search keyword .
* @ type int $second Second of the minute . Default empty . Accepts numbers 0 - 60.
* @ type array $search_terms Array of search terms .
* @ 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 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 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 .
* }
2008-09-04 15:19:32 -04:00
*/
2014-05-19 02:49:16 -04:00
public function parse_query ( $query = '' ) {
2011-02-15 18:57:13 -05:00
if ( ! empty ( $query ) ) {
2006-03-12 20:44:32 -05:00
$this -> init ();
2011-02-15 18:57:13 -05:00
$this -> query = $this -> query_vars = wp_parse_args ( $query );
} elseif ( ! isset ( $this -> query ) ) {
$this -> query = $this -> query_vars ;
2006-03-12 20:44:32 -05:00
}
2007-02-27 10:24:54 -05:00
2007-03-08 23:05:28 -05:00
$this -> query_vars = $this -> fill_query_vars ( $this -> query_vars );
$qv = & $this -> query_vars ;
2011-03-24 12:07:24 -04:00
$this -> query_vars_changed = true ;
2007-02-27 10:24:54 -05:00
2007-09-04 23:11:04 -04:00
if ( ! empty ( $qv [ 'robots' ]) )
2006-05-22 18:06:06 -04:00
$this -> is_robots = true ;
2006-03-12 20:44:32 -05:00
2008-05-08 01:17:27 -04:00
$qv [ 'p' ] = absint ( $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' ]);
2013-08-27 11:20:10 -04:00
$qv [ 'm' ] = preg_replace ( '|[^0-9]|' , '' , $qv [ 'm' ] );
2009-06-19 13:30:39 -04:00
$qv [ 'paged' ] = absint ( $qv [ 'paged' ]);
2008-04-02 09:15:21 -04:00
$qv [ 'cat' ] = preg_replace ( '|[^0-9,-]|' , '' , $qv [ 'cat' ] ); // comma separated list of positive or negative integers
2013-09-04 17:33:09 -04:00
$qv [ 'author' ] = preg_replace ( '|[^0-9,-]|' , '' , $qv [ 'author' ] ); // comma separated list of positive or negative integers
2008-08-18 23:21:12 -04:00
$qv [ 'pagename' ] = trim ( $qv [ 'pagename' ] );
$qv [ 'name' ] = trim ( $qv [ 'name' ] );
2008-05-08 01:17:27 -04:00
if ( '' !== $qv [ 'hour' ] ) $qv [ 'hour' ] = absint ( $qv [ 'hour' ]);
if ( '' !== $qv [ 'minute' ] ) $qv [ 'minute' ] = absint ( $qv [ 'minute' ]);
if ( '' !== $qv [ 'second' ] ) $qv [ 'second' ] = absint ( $qv [ 'second' ]);
2012-09-04 17:09:27 -04:00
if ( '' !== $qv [ 'menu_order' ] ) $qv [ 'menu_order' ] = absint ( $qv [ 'menu_order' ]);
2006-03-12 20:44:32 -05:00
2013-09-27 13:34:09 -04:00
// Fairly insane upper bound for search string lengths.
2014-10-15 23:32:20 -04:00
if ( ! is_scalar ( $qv [ 's' ] ) || ( ! empty ( $qv [ 's' ] ) && strlen ( $qv [ 's' ] ) > 1600 ) ) {
2013-09-27 13:34:09 -04:00
$qv [ 's' ] = '' ;
2014-10-15 23:32:20 -04:00
}
2013-09-27 13:34:09 -04:00
2011-12-13 18:45:31 -05:00
// Compat. Map subpost to attachment.
2006-03-12 20:44:32 -05:00
if ( '' != $qv [ 'subpost' ] )
$qv [ 'attachment' ] = $qv [ 'subpost' ];
if ( '' != $qv [ 'subpost_id' ] )
$qv [ 'attachment_id' ] = $qv [ 'subpost_id' ];
2008-05-08 01:17:27 -04:00
$qv [ 'attachment_id' ] = absint ( $qv [ 'attachment_id' ]);
2007-06-13 22:25:30 -04:00
2007-03-08 23:05:28 -05:00
if ( ( '' != $qv [ 'attachment' ]) || ! empty ( $qv [ 'attachment_id' ]) ) {
2006-03-12 20:44:32 -05:00
$this -> is_single = true ;
$this -> is_attachment = true ;
2007-03-08 23:05:28 -05:00
} elseif ( '' != $qv [ 'name' ] ) {
2006-03-12 20:44:32 -05:00
$this -> is_single = true ;
} elseif ( $qv [ 'p' ] ) {
$this -> is_single = true ;
2007-08-04 12:30:27 -04:00
} elseif ( ( '' !== $qv [ 'hour' ]) && ( '' !== $qv [ 'minute' ]) && ( '' !== $qv [ 'second' ]) && ( '' != $qv [ 'year' ]) && ( '' != $qv [ 'monthnum' ]) && ( '' != $qv [ 'day' ]) ) {
2006-11-19 02:56:05 -05:00
// If year, month, day, hour, minute, and second are set, a single
// post is being queried.
2006-03-12 20:44:32 -05:00
$this -> is_single = true ;
2007-03-08 23:05:28 -05:00
} elseif ( '' != $qv [ 'static' ] || '' != $qv [ 'pagename' ] || ! empty ( $qv [ 'page_id' ]) ) {
2006-03-12 20:44:32 -05:00
$this -> is_page = true ;
$this -> is_single = false ;
} else {
2014-05-29 16:50:15 -04:00
// Look for archive queries. Dates, categories, authors, search, post type archives.
2010-10-02 18:52:15 -04:00
2014-06-04 19:47:15 -04:00
if ( isset ( $this -> query [ 's' ] ) ) {
2010-10-02 18:52:15 -04:00
$this -> is_search = true ;
2014-05-29 16:50:15 -04:00
}
2006-03-12 20:44:32 -05:00
2007-08-04 12:30:27 -04:00
if ( '' !== $qv [ 'second' ] ) {
2006-03-12 20:44:32 -05:00
$this -> is_time = true ;
$this -> is_date = true ;
}
2007-08-04 12:30:27 -04:00
if ( '' !== $qv [ 'minute' ] ) {
2006-03-12 20:44:32 -05:00
$this -> is_time = true ;
$this -> is_date = true ;
}
2007-08-04 12:30:27 -04:00
if ( '' !== $qv [ 'hour' ] ) {
2006-03-12 20:44:32 -05:00
$this -> is_time = true ;
$this -> is_date = true ;
}
2007-03-08 23:05:28 -05:00
if ( $qv [ 'day' ] ) {
2010-05-03 16:19:13 -04:00
if ( ! $this -> is_date ) {
2013-09-06 12:36:09 -04:00
$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 ;
}
2006-03-12 20:44:32 -05:00
}
}
2007-03-08 23:05:28 -05:00
if ( $qv [ 'monthnum' ] ) {
2010-05-03 16:19:13 -04:00
if ( ! $this -> is_date ) {
2013-09-06 12:36:09 -04:00
if ( 12 < $qv [ 'monthnum' ] ) {
$qv [ 'error' ] = '404' ;
} else {
$this -> is_month = true ;
$this -> is_date = true ;
}
2006-03-12 20:44:32 -05:00
}
}
2007-03-08 23:05:28 -05:00
if ( $qv [ 'year' ] ) {
2010-05-03 16:19:13 -04:00
if ( ! $this -> is_date ) {
2006-03-12 20:44:32 -05:00
$this -> is_year = true ;
$this -> is_date = true ;
}
}
2007-03-08 23:05:28 -05:00
if ( $qv [ 'm' ] ) {
2006-03-12 20:44:32 -05:00
$this -> is_date = true ;
2010-05-03 16:19:13 -04:00
if ( strlen ( $qv [ 'm' ]) > 9 ) {
2006-03-12 20:44:32 -05:00
$this -> is_time = true ;
2015-01-08 02:05:25 -05:00
} elseif ( strlen ( $qv [ 'm' ] ) > 7 ) {
2006-03-12 20:44:32 -05:00
$this -> is_day = true ;
2015-01-08 02:05:25 -05:00
} elseif ( strlen ( $qv [ 'm' ] ) > 5 ) {
2006-03-12 20:44:32 -05:00
$this -> is_month = true ;
} else {
$this -> is_year = true ;
}
}
2010-05-03 16:19:13 -04:00
if ( '' != $qv [ 'w' ] ) {
2006-03-12 20:44:32 -05:00
$this -> is_date = true ;
}
2011-03-01 23:10:21 -05:00
$this -> query_vars_hash = false ;
2010-12-12 11:38:51 -05:00
$this -> parse_tax_query ( $qv );
2010-12-13 10:11:02 -05:00
2010-12-12 11:38:51 -05:00
foreach ( $this -> tax_query -> queries as $tax_query ) {
2014-10-14 00:03:19 -04:00
if ( ! is_array ( $tax_query ) ) {
continue ;
}
if ( isset ( $tax_query [ 'operator' ] ) && 'NOT IN' != $tax_query [ 'operator' ] ) {
2010-12-11 10:20:52 -05:00
switch ( $tax_query [ 'taxonomy' ] ) {
case 'category' :
$this -> is_category = true ;
break ;
case 'post_tag' :
$this -> is_tag = true ;
break ;
default :
$this -> is_tax = true ;
}
}
}
2010-12-12 11:38:51 -05:00
unset ( $tax_query );
2010-10-06 06:40:30 -04:00
2007-03-08 23:05:28 -05:00
if ( empty ( $qv [ 'author' ]) || ( $qv [ 'author' ] == '0' ) ) {
2006-03-12 20:44:32 -05:00
$this -> is_author = false ;
} else {
$this -> is_author = true ;
}
2010-10-14 06:39:47 -04:00
if ( '' != $qv [ 'author_name' ] )
2006-03-12 20:44:32 -05:00
$this -> is_author = true ;
2010-10-15 15:44:57 -04:00
if ( ! empty ( $qv [ 'post_type' ] ) && ! is_array ( $qv [ 'post_type' ] ) ) {
$post_type_obj = get_post_type_object ( $qv [ 'post_type' ] );
2010-11-10 11:42:59 -05:00
if ( ! empty ( $post_type_obj -> has_archive ) )
2010-10-15 15:44:57 -04:00
$this -> is_post_type_archive = true ;
}
2010-10-14 06:39:47 -04:00
2010-10-15 15:44:57 -04:00
if ( $this -> is_post_type_archive || $this -> is_date || $this -> is_author || $this -> is_category || $this -> is_tag || $this -> is_tax )
2006-03-12 20:44:32 -05:00
$this -> is_archive = true ;
}
2007-03-08 23:05:28 -05:00
if ( '' != $qv [ 'feed' ] )
2006-03-12 20:44:32 -05:00
$this -> is_feed = true ;
2007-03-08 23:05:28 -05:00
if ( '' != $qv [ 'tb' ] )
2006-03-12 20:44:32 -05:00
$this -> is_trackback = true ;
2009-12-11 11:38:59 -05:00
if ( '' != $qv [ 'paged' ] && ( intval ( $qv [ 'paged' ]) > 1 ) )
2006-03-12 20:44:32 -05:00
$this -> is_paged = true ;
2007-03-08 23:05:28 -05:00
if ( '' != $qv [ 'comments_popup' ] )
2006-03-12 20:44:32 -05:00
$this -> is_comments_popup = true ;
2007-03-08 23:05:28 -05:00
// if we're previewing inside the write screen
2010-05-03 16:19:13 -04:00
if ( '' != $qv [ 'preview' ] )
2006-03-12 20:44:32 -05:00
$this -> is_preview = true ;
2007-12-27 20:04:17 -05:00
if ( is_admin () )
2006-03-12 20:44:32 -05:00
$this -> is_admin = true ;
2007-02-24 02:33:29 -05:00
if ( false !== strpos ( $qv [ 'feed' ], 'comments-' ) ) {
2007-03-08 23:05:28 -05:00
$qv [ 'feed' ] = str_replace ( 'comments-' , '' , $qv [ 'feed' ]);
2007-02-24 02:33:29 -05:00
$qv [ 'withcomments' ] = 1 ;
}
2007-02-28 00:22:29 -05:00
$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 ) ) )
2007-02-24 02:33:29 -05:00
$this -> is_comment_feed = true ;
2009-04-13 12:15:44 -04:00
if ( ! ( $this -> is_singular || $this -> is_archive || $this -> is_search || $this -> is_feed || $this -> is_trackback || $this -> is_404 || $this -> is_admin || $this -> is_comments_popup || $this -> is_robots ) )
2006-03-12 20:44:32 -05:00
$this -> is_home = true ;
2007-02-28 00:22:29 -05:00
// Correct is_* for page_on_front and page_for_posts
2010-05-04 14:08:03 -04:00
if ( $this -> is_home && 'page' == get_option ( 'show_on_front' ) && get_option ( 'page_on_front' ) ) {
2011-02-16 11:25:52 -05:00
$_query = wp_parse_args ( $this -> query );
2010-12-28 17:34:15 -05:00
// pagename can be set and empty depending on matched rewrite rules. Ignore an empty pagename.
if ( isset ( $_query [ 'pagename' ]) && '' == $_query [ 'pagename' ] )
unset ( $_query [ 'pagename' ]);
2010-05-04 14:08:03 -04:00
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' ]);
}
2010-02-28 04:40:42 -05:00
}
2007-02-28 00:22:29 -05:00
}
if ( '' != $qv [ 'pagename' ] ) {
2012-04-16 23:41:07 -04:00
$this -> queried_object = get_page_by_path ( $qv [ 'pagename' ]);
2007-02-28 00:22:29 -05:00
if ( ! empty ( $this -> queried_object ) )
2007-03-22 20:59:21 -04:00
$this -> queried_object_id = ( int ) $this -> queried_object -> ID ;
2007-02-28 00:22:29 -05:00
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 ;
}
}
2007-03-08 23:05:28 -05:00
if ( $qv [ 'page_id' ] ) {
2007-02-28 00:22:29 -05:00
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 ;
}
}
2010-05-03 16:19:13 -04:00
if ( ! empty ( $qv [ 'post_type' ]) ) {
if ( is_array ( $qv [ 'post_type' ]) )
2010-09-20 11:28:58 -04:00
$qv [ 'post_type' ] = array_map ( 'sanitize_key' , $qv [ 'post_type' ]);
2009-11-05 11:08:53 -05:00
else
2010-09-20 11:28:58 -04:00
$qv [ 'post_type' ] = sanitize_key ( $qv [ 'post_type' ]);
2009-11-05 11:08:53 -05:00
}
2007-08-23 12:09:37 -04:00
2011-04-23 06:36:22 -04:00
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' ]);
}
2007-08-23 12:09:37 -04:00
2008-08-29 14:33:04 -04:00
if ( $this -> is_posts_page && ( ! isset ( $qv [ 'withcomments' ]) || ! $qv [ 'withcomments' ] ) )
2007-02-28 00:22:29 -05:00
$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
2010-05-03 16:19:13 -04:00
if ( '404' == $qv [ 'error' ] )
2007-09-04 23:11:04 -04:00
$this -> set_404 ();
2011-03-24 12:07:24 -04:00
$this -> query_vars_hash = md5 ( serialize ( $this -> query_vars ) );
$this -> query_vars_changed = false ;
2014-02-20 12:54:13 -05:00
/**
* 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 ) );
2006-03-12 20:44:32 -05:00
}
2013-11-11 08:32:10 -05:00
/**
2010-12-11 10:20:52 -05:00
* Parses various taxonomy related query vars .
2010-10-09 06:19:15 -04:00
*
2014-09-01 15:51:16 -04:00
* For BC , this method is not marked as protected . See [ 28987 ] .
*
2010-10-09 06:19:15 -04:00
* @ access protected
* @ since 3.1 . 0
*
* @ param array & $q The query variables
*/
2015-01-08 00:54:44 -05:00
public function parse_tax_query ( & $q ) {
2010-10-07 17:47:52 -04:00
if ( ! empty ( $q [ 'tax_query' ] ) && is_array ( $q [ 'tax_query' ] ) ) {
$tax_query = $q [ 'tax_query' ];
} else {
$tax_query = array ();
}
2010-10-06 06:40:30 -04:00
2010-10-19 10:41:30 -04:00
if ( ! empty ( $q [ 'taxonomy' ]) && ! empty ( $q [ 'term' ]) ) {
$tax_query [] = array (
'taxonomy' => $q [ 'taxonomy' ],
2010-10-20 08:07:23 -04:00
'terms' => array ( $q [ 'term' ] ),
'field' => 'slug' ,
2010-10-19 10:41:30 -04:00
);
2010-11-09 11:45:51 -05:00
}
2010-10-17 01:41:22 -04:00
2013-10-02 15:42:09 -04:00
foreach ( get_taxonomies ( array () , 'objects' ) as $taxonomy => $t ) {
2011-03-03 11:11:02 -05:00
if ( 'post_tag' == $taxonomy )
continue ; // Handled further down in the $q['tag'] block
2010-11-09 11:45:51 -05:00
if ( $t -> query_var && ! empty ( $q [ $t -> query_var ] ) ) {
$tax_query_defaults = array (
'taxonomy' => $taxonomy ,
'field' => 'slug' ,
);
2010-10-06 07:04:03 -04:00
2010-11-22 16:56:20 -05:00
if ( isset ( $t -> rewrite [ 'hierarchical' ] ) && $t -> rewrite [ 'hierarchical' ] ) {
2010-11-09 11:45:51 -05:00
$q [ $t -> query_var ] = wp_basename ( $q [ $t -> query_var ] );
}
2010-11-21 11:33:05 -05:00
$term = $q [ $t -> query_var ];
2010-11-09 11:45:51 -05:00
if ( strpos ( $term , '+' ) !== false ) {
$terms = preg_split ( '/[+]+/' , $term );
foreach ( $terms as $term ) {
2010-10-06 06:40:30 -04:00
$tax_query [] = array_merge ( $tax_query_defaults , array (
2010-11-09 11:45:51 -05:00
'terms' => array ( $term )
2010-10-06 06:40:30 -04:00
) );
}
2010-11-09 11:45:51 -05:00
} else {
$tax_query [] = array_merge ( $tax_query_defaults , array (
'terms' => preg_split ( '/[,]+/' , $term )
) );
2010-10-06 06:40:30 -04:00
}
}
}
// Category stuff
2013-11-11 13:36:10 -05:00
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
);
2010-10-06 06:40:30 -04:00
}
2013-11-11 13:36:10 -05:00
unset ( $cat_array , $cat_in , $cat_not_in );
2010-10-06 06:40:30 -04:00
}
2013-09-04 14:17:09 -04:00
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' ] );
}
2013-09-04 17:33:09 -04:00
2013-09-04 14:17:09 -04:00
if ( ! empty ( $q [ 'category__in' ] ) ) {
2013-09-04 17:33:09 -04:00
$q [ 'category__in' ] = array_map ( 'absint' , array_unique ( ( array ) $q [ 'category__in' ] ) );
2010-10-06 06:40:30 -04:00
$tax_query [] = array (
'taxonomy' => 'category' ,
'terms' => $q [ 'category__in' ],
2011-01-09 15:49:11 -05:00
'field' => 'term_id' ,
'include_children' => false
2010-10-06 06:40:30 -04:00
);
}
2013-09-04 14:17:09 -04:00
if ( ! empty ( $q [ 'category__not_in' ]) ) {
$q [ 'category__not_in' ] = array_map ( 'absint' , array_unique ( ( array ) $q [ 'category__not_in' ] ) );
2010-10-06 06:40:30 -04:00
$tax_query [] = array (
'taxonomy' => 'category' ,
'terms' => $q [ 'category__not_in' ],
2011-01-09 15:49:11 -05:00
'operator' => 'NOT IN' ,
2011-02-09 12:35:36 -05:00
'include_children' => false
2011-01-09 11:19:48 -05:00
);
}
2013-09-04 14:17:09 -04:00
if ( ! empty ( $q [ 'category__and' ]) ) {
$q [ 'category__and' ] = array_map ( 'absint' , array_unique ( ( array ) $q [ 'category__and' ] ) );
2011-01-09 11:19:48 -05:00
$tax_query [] = array (
'taxonomy' => 'category' ,
'terms' => $q [ 'category__and' ],
'field' => 'term_id' ,
2011-01-09 15:49:11 -05:00
'operator' => 'AND' ,
'include_children' => false
2010-10-06 06:40:30 -04:00
);
}
// Tag stuff
2011-03-24 12:07:24 -04:00
if ( '' != $q [ 'tag' ] && ! $this -> is_singular && $this -> query_vars_changed ) {
2011-01-12 16:44:47 -05:00
if ( strpos ( $q [ 'tag' ], ',' ) !== false ) {
2012-09-15 16:13:44 -04:00
$tags = preg_split ( '/[,\r\n\t ]+/' , $q [ 'tag' ]);
2011-01-12 16:44:47 -05:00
foreach ( ( array ) $tags as $tag ) {
$tag = sanitize_term_field ( 'slug' , $tag , 0 , 'post_tag' , 'db' );
$q [ 'tag_slug__in' ][] = $tag ;
}
2015-01-08 02:05:25 -05:00
} elseif ( preg_match ( '/[+\r\n\t ]+/' , $q [ 'tag' ] ) || ! empty ( $q [ 'cat' ] ) ) {
2012-09-15 16:13:44 -04:00
$tags = preg_split ( '/[+\r\n\t ]+/' , $q [ 'tag' ]);
2011-01-12 16:44:47 -05:00
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' ];
}
}
2011-01-08 12:21:49 -05:00
if ( ! empty ( $q [ 'tag_id' ]) ) {
2011-01-09 11:19:48 -05:00
$q [ 'tag_id' ] = absint ( $q [ 'tag_id' ] );
2010-10-06 06:40:30 -04:00
$tax_query [] = array (
'taxonomy' => 'post_tag' ,
2011-01-09 11:19:48 -05:00
'terms' => $q [ 'tag_id' ]
2010-10-06 06:40:30 -04:00
);
}
if ( ! empty ( $q [ 'tag__in' ]) ) {
2011-01-09 11:42:01 -05:00
$q [ 'tag__in' ] = array_map ( 'absint' , array_unique ( ( array ) $q [ 'tag__in' ] ) );
2010-10-06 06:40:30 -04:00
$tax_query [] = array (
'taxonomy' => 'post_tag' ,
2011-01-09 11:19:48 -05:00
'terms' => $q [ 'tag__in' ]
2010-10-06 06:40:30 -04:00
);
}
if ( ! empty ( $q [ 'tag__not_in' ]) ) {
2011-01-09 11:42:01 -05:00
$q [ 'tag__not_in' ] = array_map ( 'absint' , array_unique ( ( array ) $q [ 'tag__not_in' ] ) );
2010-10-06 06:40:30 -04:00
$tax_query [] = array (
'taxonomy' => 'post_tag' ,
'terms' => $q [ 'tag__not_in' ],
2011-01-09 11:19:48 -05:00
'operator' => 'NOT IN'
);
}
if ( ! empty ( $q [ 'tag__and' ]) ) {
2011-01-09 11:42:01 -05:00
$q [ 'tag__and' ] = array_map ( 'absint' , array_unique ( ( array ) $q [ 'tag__and' ] ) );
2011-01-09 11:19:48 -05:00
$tax_query [] = array (
'taxonomy' => 'post_tag' ,
'terms' => $q [ 'tag__and' ],
'operator' => 'AND'
);
}
if ( ! empty ( $q [ 'tag_slug__in' ]) ) {
2011-11-23 19:20:21 -05:00
$q [ 'tag_slug__in' ] = array_map ( 'sanitize_title_for_query' , array_unique ( ( array ) $q [ 'tag_slug__in' ] ) );
2011-01-09 11:19:48 -05:00
$tax_query [] = array (
'taxonomy' => 'post_tag' ,
'terms' => $q [ 'tag_slug__in' ],
'field' => 'slug'
);
}
if ( ! empty ( $q [ 'tag_slug__and' ]) ) {
2011-11-23 19:20:21 -05:00
$q [ 'tag_slug__and' ] = array_map ( 'sanitize_title_for_query' , array_unique ( ( array ) $q [ 'tag_slug__and' ] ) );
2011-01-09 11:19:48 -05:00
$tax_query [] = array (
'taxonomy' => 'post_tag' ,
'terms' => $q [ 'tag_slug__and' ],
'field' => 'slug' ,
'operator' => 'AND'
2010-10-06 06:40:30 -04:00
);
}
2010-12-12 11:38:51 -05:00
$this -> tax_query = new WP_Tax_Query ( $tax_query );
2013-09-09 22:36:09 -04:00
2014-02-20 12:54:13 -05:00
/**
* Fires after taxonomy - related query vars have been parsed .
*
* @ since 3.7 . 0
*
* @ param WP_Query $this The WP_Query instance .
*/
2013-09-09 22:36:09 -04:00
do_action ( 'parse_tax_query' , $this );
2010-10-06 06:40:30 -04:00
}
2013-09-27 13:34:09 -04:00
/**
* Generate SQL for the WHERE clause based on passed search terms .
*
* @ since 3.7 . 0
*
2013-11-09 11:05:10 -05:00
* @ global wpdb $wpdb
2013-09-27 13:34:09 -04:00
* @ param array $q Query variables .
2013-11-09 11:05:10 -05:00
* @ return string WHERE clause .
2013-09-27 13:34:09 -04:00
*/
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 ();
foreach ( $q [ 'search_terms' ] as $term ) {
2014-06-09 20:44:15 -04:00
if ( $n ) {
$like = '%' . $wpdb -> esc_like ( $term ) . '%' ;
$q [ 'search_orderby_title' ][] = $wpdb -> prepare ( " $wpdb->posts .post_title LIKE %s " , $like );
}
2013-09-27 13:34:09 -04:00
2014-06-09 20:44:15 -04:00
$like = $n . $wpdb -> esc_like ( $term ) . $n ;
$search .= $wpdb -> prepare ( " { $searchand } (( $wpdb->posts .post_title LIKE %s) OR ( $wpdb->posts .post_content LIKE %s)) " , $like , $like );
2013-09-27 13:34:09 -04:00
$searchand = ' AND ' ;
}
if ( ! empty ( $search ) ) {
$search = " AND ( { $search } ) " ;
if ( ! is_user_logged_in () )
$search .= " AND ( $wpdb->posts .post_password = '') " ;
}
2013-10-24 18:59:12 -04:00
return $search ;
2013-09-27 13:34:09 -04:00
}
/**
* 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
*
2014-11-30 17:56:25 -05:00
* @ param array $terms Terms to check .
2013-09-27 13:34:09 -04:00
* @ 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 , " \" ' " );
2013-10-27 16:51:10 -04:00
// Avoid single A-Z.
if ( ! $term || ( 1 === strlen ( $term ) && preg_match ( '/^[a-z]$/i' , $term ) ) )
2013-09-27 13:34:09 -04:00
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' ) );
2013-11-09 10:53:09 -05:00
$stopwords = array ();
2013-09-27 13:34:09 -04:00
foreach ( $words as $word ) {
$word = trim ( $word , " \r \n \t " );
if ( $word )
$stopwords [] = $word ;
}
/**
* Filter stopwords used when parsing search terms .
*
* @ since 3.7 . 0
*
* @ param array $stopwords Stopwords .
*/
$this -> stopwords = apply_filters ( 'wp_search_stopwords' , $stopwords );
return $this -> stopwords ;
}
/**
* Generate SQL for the ORDER BY condition based on passed search terms .
*
* @ global wpdb $wpdb
2015-05-27 14:15:25 -04:00
*
2013-09-27 13:34:09 -04:00
* @ 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' ] );
2014-06-09 20:44:15 -04:00
$like = '%' . $wpdb -> esc_like ( $q [ 's' ] ) . '%' ;
2013-09-27 13:34:09 -04:00
$search_orderby = '(CASE ' ;
// sentence match in 'post_title'
2014-06-09 20:44:15 -04:00
$search_orderby .= $wpdb -> prepare ( " WHEN $wpdb->posts .post_title LIKE %s THEN 1 " , $like );
2013-09-27 13:34:09 -04:00
// 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'
2014-06-09 20:44:15 -04:00
$search_orderby .= $wpdb -> prepare ( " WHEN $wpdb->posts .post_content LIKE %s THEN 4 " , $like );
2013-09-27 13:34:09 -04:00
$search_orderby .= 'ELSE 5 END)' ;
} else {
// single word or sentence search
$search_orderby = reset ( $q [ 'search_orderby_title' ] ) . ' DESC' ;
}
return $search_orderby ;
}
2014-07-08 13:16:15 -04:00
/**
* If the passed orderby value is allowed , convert the alias to a
* properly - prefixed orderby value .
*
* @ since 4.0 . 0
* @ access protected
*
2014-10-31 13:56:22 -04:00
* @ global wpdb $wpdb WordPress database abstraction object .
2014-07-08 13:16:15 -04:00
*
* @ param string $orderby Alias for the field to order by .
2015-05-27 14:15:25 -04:00
* @ return string | false Table - prefixed value to used in the ORDER clause . False otherwise .
2014-07-08 13:16:15 -04:00
*/
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' ,
);
2014-10-08 11:12:20 -04:00
$primary_meta_key = '' ;
$primary_meta_query = false ;
2015-01-31 10:48:24 -05:00
$meta_clauses = $this -> meta_query -> get_clauses ();
if ( ! empty ( $meta_clauses ) ) {
$primary_meta_query = reset ( $meta_clauses );
2014-10-08 11:12:20 -04:00
if ( ! empty ( $primary_meta_query [ 'key' ] ) ) {
$primary_meta_key = $primary_meta_query [ 'key' ];
$allowed_keys [] = $primary_meta_key ;
}
2014-07-08 13:16:15 -04:00
$allowed_keys [] = 'meta_value' ;
$allowed_keys [] = 'meta_value_num' ;
2015-01-31 10:48:24 -05:00
$allowed_keys = array_merge ( $allowed_keys , array_keys ( $meta_clauses ) );
2014-07-08 13:16:15 -04:00
}
if ( ! in_array ( $orderby , $allowed_keys ) ) {
return false ;
}
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' :
2015-01-31 10:48:24 -05:00
$orderby_clause = " $wpdb->posts . { $orderby } " ;
2014-07-08 13:16:15 -04:00
break ;
case 'rand' :
2015-01-31 10:48:24 -05:00
$orderby_clause = 'RAND()' ;
2014-07-08 13:16:15 -04:00
break ;
2014-10-08 11:12:20 -04:00
case $primary_meta_key :
2014-07-08 13:16:15 -04:00
case 'meta_value' :
2014-10-08 11:12:20 -04:00
if ( ! empty ( $primary_meta_query [ 'type' ] ) ) {
2015-01-31 10:48:24 -05:00
$orderby_clause = " CAST( { $primary_meta_query [ 'alias' ] } .meta_value AS { $primary_meta_query [ 'cast' ] } ) " ;
2014-07-08 13:16:15 -04:00
} else {
2015-01-31 10:48:24 -05:00
$orderby_clause = " { $primary_meta_query [ 'alias' ] } .meta_value " ;
2014-07-08 13:16:15 -04:00
}
break ;
case 'meta_value_num' :
2015-01-31 10:48:24 -05:00
$orderby_clause = " { $primary_meta_query [ 'alias' ] } .meta_value+0 " ;
2014-07-08 13:16:15 -04:00
break ;
default :
2015-01-31 10:48:24 -05:00
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' ] } ) " ;
} else {
// Default: order by post field.
$orderby_clause = " $wpdb->posts .post_ " . sanitize_key ( $orderby );
}
2014-07-08 13:16:15 -04:00
break ;
}
2015-01-31 10:48:24 -05:00
return $orderby_clause ;
2014-07-08 13:16:15 -04:00
}
/**
* Parse an 'order' query variable and cast it to ASC or DESC as necessary .
*
* @ since 4.0 . 0
* @ access protected
*
* @ 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' ;
}
}
2008-09-04 15:19:32 -04:00
/**
* Sets the 404 property and saves whether query is feed .
*
* @ since 2.0 . 0
* @ access public
*/
2014-05-19 02:49:16 -04:00
public function set_404 () {
2006-08-15 01:03:14 -04:00
$is_feed = $this -> is_feed ;
2006-03-12 20:44:32 -05:00
$this -> init_query_flags ();
$this -> is_404 = true ;
2006-08-15 01:03:14 -04:00
2010-05-11 14:28:12 -04:00
$this -> is_feed = $is_feed ;
2006-03-12 20:44:32 -05:00
}
2010-11-13 13:26:15 -05:00
/**
* Retrieve query variable .
*
* @ since 1.5 . 0
* @ access public
*
* @ param string $query_var Query variable key .
2014-02-26 18:58:14 -05:00
* @ param mixed $default Value to return if the query variable is not set . Default '' .
2010-11-13 13:26:15 -05:00
* @ return mixed
*/
2014-05-19 02:49:16 -04:00
public function get ( $query_var , $default = '' ) {
2014-02-26 18:58:14 -05:00
if ( isset ( $this -> query_vars [ $query_var ] ) ) {
return $this -> query_vars [ $query_var ];
}
2010-11-13 13:26:15 -05:00
2014-02-26 18:58:14 -05:00
return $default ;
2010-11-13 13:26:15 -05:00
}
/**
* Set query variable .
*
* @ since 1.5 . 0
* @ access public
*
* @ param string $query_var Query variable key .
2015-05-27 14:15:25 -04:00
* @ param mixed $value Query variable value .
2010-11-13 13:26:15 -05:00
*/
2014-05-19 02:49:16 -04:00
public function set ( $query_var , $value ) {
2010-11-13 13:26:15 -05:00
$this -> query_vars [ $query_var ] = $value ;
}
2008-09-04 15:19:32 -04:00
/**
* Retrieve the 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
* @ access public
*
2015-05-27 14:15:25 -04:00
* @ global wpdb $wpdb
*
2008-09-04 15:19:32 -04:00
* @ return array List of posts .
*/
2014-05-19 02:49:16 -04:00
public function get_posts () {
2013-10-02 17:10:09 -04:00
global $wpdb ;
2006-03-12 20:44:32 -05:00
2011-02-15 18:57:13 -05:00
$this -> parse_query ();
2014-02-20 12:54:13 -05:00
/**
* 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 ) );
2006-03-12 20:44:32 -05:00
// Shorthand.
$q = & $this -> query_vars ;
2007-02-27 10:24:54 -05:00
2011-03-24 12:07:24 -04:00
// Fill again in case pre_get_posts unset some vars.
2006-09-21 17:05:38 -04:00
$q = $this -> fill_query_vars ( $q );
2006-03-12 20:44:32 -05:00
2011-04-25 13:27:35 -04:00
// Parse meta query
$this -> meta_query = new WP_Meta_Query ();
$this -> meta_query -> parse_query_vars ( $q );
2011-03-24 12:07:24 -04:00
// 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 );
2006-03-12 20:44:32 -05:00
// First let's clear some variables
2006-05-07 22:16:24 -04:00
$distinct = '' ;
2006-03-12 20:44:32 -05:00
$whichauthor = '' ;
2008-02-19 01:13:20 -05:00
$whichmimetype = '' ;
2006-03-12 20:44:32 -05:00
$where = '' ;
$limits = '' ;
$join = '' ;
2006-09-21 17:05:38 -04:00
$search = '' ;
2006-11-07 18:43:59 -05:00
$groupby = '' ;
2009-05-20 20:10:04 -04:00
$post_status_join = false ;
2008-08-29 14:33:04 -04:00
$page = 1 ;
2006-03-12 20:44:32 -05:00
2010-09-07 00:46:08 -04:00
if ( isset ( $q [ 'caller_get_posts' ] ) ) {
_deprecated_argument ( 'WP_Query' , '3.1' , __ ( '"caller_get_posts" is deprecated. Use "ignore_sticky_posts" instead.' ) );
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 ;
2008-08-05 01:48:21 -04:00
2008-08-28 18:30:27 -04:00
if ( ! isset ( $q [ 'suppress_filters' ]) )
$q [ 'suppress_filters' ] = false ;
2010-05-15 11:00:53 -04:00
if ( ! isset ( $q [ 'cache_results' ]) ) {
2013-09-06 14:10:09 -04:00
if ( wp_using_ext_object_cache () )
2010-05-15 11:00:53 -04:00
$q [ 'cache_results' ] = false ;
else
$q [ 'cache_results' ] = true ;
}
2010-04-29 16:43:59 -04:00
2010-05-09 20:58:39 -04:00
if ( ! isset ( $q [ 'update_post_term_cache' ]) )
$q [ 'update_post_term_cache' ] = true ;
if ( ! isset ( $q [ 'update_post_meta_cache' ]) )
$q [ 'update_post_meta_cache' ] = true ;
2007-12-22 03:19:10 -05:00
if ( ! isset ( $q [ 'post_type' ]) ) {
if ( $this -> is_search )
$q [ 'post_type' ] = 'any' ;
else
2009-08-15 06:57:56 -04:00
$q [ 'post_type' ] = '' ;
2007-12-22 03:19:10 -05:00
}
2006-03-12 20:44:32 -05:00
$post_type = $q [ 'post_type' ];
2014-03-07 13:59:14 -05:00
if ( empty ( $q [ 'posts_per_page' ] ) ) {
$q [ 'posts_per_page' ] = get_option ( 'posts_per_page' );
2014-03-07 13:33:15 -05:00
}
2006-03-12 20:44:32 -05:00
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' ]) ) {
2010-05-03 16:19:13 -04:00
if ( $q [ 'posts_per_page' ] == - 1 ) {
2006-03-12 20:44:32 -05:00
$q [ 'nopaging' ] = true ;
} else {
$q [ 'nopaging' ] = false ;
}
}
2014-05-29 01:48:14 -04:00
2006-03-12 20:44:32 -05:00
if ( $this -> is_feed ) {
2014-03-07 13:59:14 -05:00
// This overrides posts_per_page.
if ( ! empty ( $q [ 'posts_per_rss' ] ) ) {
$q [ 'posts_per_page' ] = $q [ 'posts_per_rss' ];
2014-03-24 14:55:16 -04:00
} else {
2014-03-07 13:59:14 -05:00
$q [ 'posts_per_page' ] = get_option ( 'posts_per_rss' );
}
2006-12-06 18:14:37 -05:00
$q [ 'nopaging' ] = false ;
2006-03-12 20:44:32 -05:00
}
2006-08-24 18:33:16 -04:00
$q [ 'posts_per_page' ] = ( int ) $q [ 'posts_per_page' ];
if ( $q [ 'posts_per_page' ] < - 1 )
$q [ 'posts_per_page' ] = abs ( $q [ 'posts_per_page' ]);
2015-01-08 02:05:25 -05:00
elseif ( $q [ 'posts_per_page' ] == 0 )
2006-08-24 18:33:16 -04:00
$q [ 'posts_per_page' ] = 1 ;
2006-03-12 20:44:32 -05:00
2008-09-23 17:11:27 -04:00
if ( ! isset ( $q [ 'comments_per_page' ]) || $q [ 'comments_per_page' ] == 0 )
$q [ 'comments_per_page' ] = get_option ( 'comments_per_page' );
2006-06-21 23:39:23 -04:00
if ( $this -> is_home && ( empty ( $this -> query ) || $q [ 'preview' ] == 'true' ) && ( 'page' == get_option ( 'show_on_front' ) ) && get_option ( 'page_on_front' ) ) {
2006-03-12 20:44:32 -05:00
$this -> is_page = true ;
$this -> is_home = false ;
$q [ 'page_id' ] = get_option ( 'page_on_front' );
}
2010-05-03 16:19:13 -04:00
if ( isset ( $q [ 'page' ]) ) {
2006-03-12 20:44:32 -05:00
$q [ 'page' ] = trim ( $q [ 'page' ], '/' );
2008-05-08 01:17:27 -04:00
$q [ 'page' ] = absint ( $q [ 'page' ]);
2006-03-12 20:44:32 -05:00
}
2010-03-10 13:37:03 -05:00
// 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 ;
2010-10-26 15:01:55 -04:00
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 .* " ;
}
2012-09-04 17:09:27 -04:00
if ( '' !== $q [ 'menu_order' ] )
$where .= " AND $wpdb->posts .menu_order = " . $q [ 'menu_order' ];
2012-09-13 13:15:13 -04:00
2013-08-27 12:39:09 -04:00
// The "m" parameter is meant for months but accepts datetimes of varying specificity
2007-03-08 23:05:28 -05:00
if ( $q [ 'm' ] ) {
2008-03-23 13:02:11 -04:00
$where .= " AND YEAR( $wpdb->posts .post_date)= " . substr ( $q [ 'm' ], 0 , 4 );
2010-05-03 16:19:13 -04:00
if ( strlen ( $q [ 'm' ]) > 5 )
2008-03-23 13:02:11 -04:00
$where .= " AND MONTH( $wpdb->posts .post_date)= " . substr ( $q [ 'm' ], 4 , 2 );
2010-05-03 16:19:13 -04:00
if ( strlen ( $q [ 'm' ]) > 7 )
2008-03-23 13:02:11 -04:00
$where .= " AND DAYOFMONTH( $wpdb->posts .post_date)= " . substr ( $q [ 'm' ], 6 , 2 );
2010-05-03 16:19:13 -04:00
if ( strlen ( $q [ 'm' ]) > 9 )
2008-03-23 13:02:11 -04:00
$where .= " AND HOUR( $wpdb->posts .post_date)= " . substr ( $q [ 'm' ], 8 , 2 );
2010-05-03 16:19:13 -04:00
if ( strlen ( $q [ 'm' ]) > 11 )
2008-03-23 13:02:11 -04:00
$where .= " AND MINUTE( $wpdb->posts .post_date)= " . substr ( $q [ 'm' ], 10 , 2 );
2010-05-03 16:19:13 -04:00
if ( strlen ( $q [ 'm' ]) > 13 )
2008-03-23 13:02:11 -04:00
$where .= " AND SECOND( $wpdb->posts .post_date)= " . substr ( $q [ 'm' ], 12 , 2 );
2006-03-12 20:44:32 -05:00
}
2013-08-27 12:39:09 -04:00
// Handle the other individual date parameters
$date_parameters = array ();
2007-08-04 12:30:27 -04:00
if ( '' !== $q [ 'hour' ] )
2013-08-27 12:39:09 -04:00
$date_parameters [ 'hour' ] = $q [ 'hour' ];
2006-03-12 20:44:32 -05:00
2007-08-04 12:30:27 -04:00
if ( '' !== $q [ 'minute' ] )
2013-08-27 12:39:09 -04:00
$date_parameters [ 'minute' ] = $q [ 'minute' ];
2006-03-12 20:44:32 -05:00
2007-08-04 12:30:27 -04:00
if ( '' !== $q [ 'second' ] )
2013-08-27 12:39:09 -04:00
$date_parameters [ 'second' ] = $q [ 'second' ];
2006-03-12 20:44:32 -05:00
2007-03-08 23:05:28 -05:00
if ( $q [ 'year' ] )
2013-08-27 12:39:09 -04:00
$date_parameters [ 'year' ] = $q [ 'year' ];
2006-03-12 20:44:32 -05:00
2007-03-08 23:05:28 -05:00
if ( $q [ 'monthnum' ] )
2013-08-27 12:39:09 -04:00
$date_parameters [ 'monthnum' ] = $q [ 'monthnum' ];
if ( $q [ 'w' ] )
$date_parameters [ 'week' ] = $q [ 'w' ];
2006-03-12 20:44:32 -05:00
2007-03-08 23:05:28 -05:00
if ( $q [ 'day' ] )
2013-08-27 12:39:09 -04:00
$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 ();
}
2006-03-12 20:44:32 -05:00
2012-12-20 10:55:32 -05:00
// If we've got a post_type AND it's not "any" post_type.
2010-04-07 04:29:46 -04:00
if ( ! empty ( $q [ 'post_type' ]) && 'any' != $q [ 'post_type' ] ) {
2010-04-11 09:51:24 -04:00
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 ]) )
2010-03-27 01:56:27 -04:00
continue ;
2014-06-23 09:15:16 -04:00
if ( ! $ptype_obj -> hierarchical ) {
// Non-hierarchical post types can directly use 'name'.
2010-04-11 09:51:24 -04:00
$q [ 'name' ] = $q [ $ptype_obj -> query_var ];
2010-03-19 22:23:52 -04:00
} else {
2014-06-23 09:15:16 -04:00
// Hierarchical post types will operate through 'pagename'.
2010-04-11 09:51:24 -04:00
$q [ 'pagename' ] = $q [ $ptype_obj -> query_var ];
$q [ 'name' ] = '' ;
2010-03-19 22:23:52 -04:00
}
2010-04-11 09:51:24 -04:00
// Only one request for a slug is possible, this is why name & pagename are overwritten above.
break ;
2010-03-27 01:56:27 -04:00
} //end foreach
2010-04-11 09:51:24 -04:00
unset ( $ptype_obj );
}
2010-03-27 01:56:27 -04:00
2010-11-15 10:23:04 -05:00
if ( '' != $q [ 'name' ] ) {
2010-10-23 08:55:55 -04:00
$q [ 'name' ] = sanitize_title_for_query ( $q [ 'name' ] );
2008-03-23 13:02:11 -04:00
$where .= " AND $wpdb->posts .post_name = ' " . $q [ 'name' ] . " ' " ;
2010-03-19 22:23:52 -04:00
} elseif ( '' != $q [ 'pagename' ] ) {
2010-04-11 09:51:24 -04:00
if ( isset ( $this -> queried_object_id ) ) {
2007-02-28 00:22:29 -05:00
$reqpage = $this -> queried_object_id ;
2010-04-11 09:51:24 -04:00
} 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' ]);
}
2007-02-28 00:22:29 -05:00
if ( ! empty ( $reqpage ) )
$reqpage = $reqpage -> ID ;
else
$reqpage = 0 ;
}
2006-03-12 20:44:32 -05:00
2008-05-07 15:57:15 -04:00
$page_for_posts = get_option ( 'page_for_posts' );
2010-03-19 22:23:52 -04:00
if ( ( 'page' != get_option ( 'show_on_front' ) ) || empty ( $page_for_posts ) || ( $reqpage != $page_for_posts ) ) {
2010-11-02 13:28:28 -04:00
$q [ 'pagename' ] = sanitize_title_for_query ( wp_basename ( $q [ 'pagename' ] ) );
2006-03-12 20:44:32 -05:00
$q [ 'name' ] = $q [ 'pagename' ];
2008-06-24 13:49:24 -04:00
$where .= " AND ( $wpdb->posts .ID = ' $reqpage ') " ;
2012-08-23 16:01:10 -04:00
$reqpage_obj = get_post ( $reqpage );
2008-11-10 13:54:18 -05:00
if ( is_object ( $reqpage_obj ) && 'attachment' == $reqpage_obj -> post_type ) {
2007-12-12 06:45:55 -05:00
$this -> is_attachment = true ;
2010-04-11 09:51:24 -04:00
$post_type = $q [ 'post_type' ] = 'attachment' ;
2008-02-27 16:30:59 -05:00
$this -> is_page = true ;
2007-12-12 06:45:55 -05:00
$q [ 'attachment_id' ] = $reqpage ;
}
2006-03-12 20:44:32 -05:00
}
2010-05-03 16:19:13 -04:00
} elseif ( '' != $q [ 'attachment' ] ) {
2010-11-02 13:28:28 -04:00
$q [ 'attachment' ] = sanitize_title_for_query ( wp_basename ( $q [ 'attachment' ] ) );
2006-03-12 20:44:32 -05:00
$q [ 'name' ] = $q [ 'attachment' ];
2008-03-23 13:02:11 -04:00
$where .= " AND $wpdb->posts .post_name = ' " . $q [ 'attachment' ] . " ' " ;
2006-03-12 20:44:32 -05:00
}
if ( intval ( $q [ 'comments_popup' ]) )
2008-05-08 01:17:27 -04:00
$q [ 'p' ] = absint ( $q [ 'comments_popup' ]);
2006-03-12 20:44:32 -05:00
2011-09-05 15:08:15 -04:00
// If an attachment is requested by number, let it supersede any post number.
2007-03-08 23:05:28 -05:00
if ( $q [ 'attachment_id' ] )
2008-05-08 01:17:27 -04:00
$q [ 'p' ] = absint ( $q [ 'attachment_id' ]);
2006-03-12 20:44:32 -05:00
// If a post number is specified, load that post
2008-05-08 01:17:27 -04:00
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 ) " ;
2008-05-03 16:08:32 -04:00
} elseif ( $q [ 'post__not_in' ] ) {
2008-05-08 01:17:27 -04:00
$post__not_in = implode ( ',' , array_map ( 'absint' , $q [ 'post__not_in' ] ));
$where .= " AND { $wpdb -> posts } .ID NOT IN ( $post__not_in ) " ;
2008-05-03 16:08:32 -04:00
}
2006-03-12 20:44:32 -05:00
2013-02-15 21:08:46 -05:00
if ( is_numeric ( $q [ 'post_parent' ] ) ) {
2008-05-08 01:17:27 -04:00
$where .= $wpdb -> prepare ( " AND $wpdb->posts .post_parent = %d " , $q [ 'post_parent' ] );
2013-02-15 21:08:46 -05:00
} 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 ) " ;
}
2008-05-08 01:17:27 -04:00
2007-03-08 23:05:28 -05:00
if ( $q [ 'page_id' ] ) {
2007-02-28 00:22:29 -05:00
if ( ( 'page' != get_option ( 'show_on_front' ) ) || ( $q [ 'page_id' ] != get_option ( 'page_for_posts' ) ) ) {
2006-03-12 20:44:32 -05:00
$q [ 'p' ] = $q [ 'page_id' ];
2007-11-03 15:00:33 -04:00
$where = " AND { $wpdb -> posts } .ID = " . $q [ 'page_id' ];
2006-03-12 20:44:32 -05:00
}
}
2013-09-27 13:34:09 -04:00
// If a search pattern is specified, load the posts that match.
2014-05-29 16:50:15 -04:00
if ( ! empty ( $q [ 's' ] ) ) {
2013-09-27 13:34:09 -04:00
$search = $this -> parse_search ( $q );
2014-05-29 16:50:15 -04:00
}
2006-03-12 20:44:32 -05:00
2013-10-24 18:59:12 -04:00
/**
* Filter 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 ) );
2010-09-13 12:44:14 -04:00
// Taxonomies
2011-03-08 17:01:19 -05:00
if ( ! $this -> is_singular ) {
$this -> parse_tax_query ( $q );
2010-12-09 12:05:40 -05:00
2011-03-08 17:01:19 -05:00
$clauses = $this -> tax_query -> get_sql ( $wpdb -> posts , 'ID' );
2010-11-20 16:51:21 -05:00
2011-03-08 17:01:19 -05:00
$join .= $clauses [ 'join' ];
$where .= $clauses [ 'where' ];
}
2010-11-20 16:51:21 -05:00
2010-12-13 10:11:02 -05:00
if ( $this -> is_tax ) {
if ( empty ( $post_type ) ) {
2012-09-15 15:44:51 -04:00
// Do a fully inclusive search for currently registered post types of queried taxonomies
$post_type = array ();
2014-10-14 00:03:19 -04:00
$taxonomies = array_keys ( $this -> tax_query -> queried_terms );
2012-09-15 15:44:51 -04:00
foreach ( get_post_types ( array ( 'exclude_from_search' => false ) ) as $pt ) {
2012-11-20 12:33:21 -05:00
$object_taxonomies = $pt === 'attachment' ? get_taxonomies_for_attachments () : get_object_taxonomies ( $pt );
if ( array_intersect ( $taxonomies , $object_taxonomies ) )
2012-09-15 15:44:51 -04:00
$post_type [] = $pt ;
}
if ( ! $post_type )
$post_type = 'any' ;
2013-04-26 21:28:35 -04:00
elseif ( count ( $post_type ) == 1 )
$post_type = $post_type [ 0 ];
2012-09-15 15:44:51 -04:00
2010-12-13 10:11:02 -05:00
$post_status_join = true ;
} elseif ( in_array ( 'attachment' , ( array ) $post_type ) ) {
$post_status_join = true ;
2010-12-09 12:09:42 -05:00
}
2010-12-13 10:11:02 -05:00
}
2010-12-09 12:09:42 -05:00
2014-10-14 00:03:19 -04:00
/*
* 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 ;
}
2010-09-23 19:19:47 -04:00
2014-10-14 00:03:19 -04:00
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 ];
2010-11-15 05:51:39 -05:00
}
}
2010-12-09 12:09:42 -05:00
}
2014-10-14 00:03:19 -04:00
}
2010-11-15 05:51:39 -05:00
2014-10-14 00:03:19 -04:00
// 'cat', 'category_name', 'tag_id'
foreach ( $this -> tax_query -> queried_terms as $queried_taxonomy => $queried_items ) {
if ( empty ( $queried_items [ 'terms' ][ 0 ] ) ) {
continue ;
}
2013-06-20 13:21:13 -04:00
2014-10-14 00:03:19 -04:00
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 );
2010-11-15 05:51:39 -05:00
}
2014-10-14 00:03:19 -04:00
unset ( $the_cat );
2010-10-02 14:03:06 -04:00
}
2013-06-20 13:21:13 -04:00
2014-10-14 00:03:19 -04:00
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 );
2011-01-11 13:56:59 -05:00
}
2014-10-14 00:03:19 -04:00
unset ( $the_tag );
2011-01-11 13:56:59 -05:00
}
2010-10-02 14:03:06 -04:00
}
2007-09-02 23:24:23 -04:00
}
2011-04-25 13:27:35 -04:00
if ( ! empty ( $this -> tax_query -> queries ) || ! empty ( $this -> meta_query -> queries ) ) {
2010-09-13 12:44:14 -04:00
$groupby = " { $wpdb -> posts } .ID " ;
2008-03-23 13:02:11 -04:00
}
2006-03-12 20:44:32 -05:00
// Author/user stuff
2013-09-04 17:33:09 -04:00
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 );
2006-03-12 20:44:32 -05:00
}
2013-09-04 17:33:09 -04:00
$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 ) " ;
2006-03-12 20:44:32 -05:00
}
2006-08-30 12:40:17 -04:00
// Author stuff for nice URLs
2006-03-12 20:44:32 -05:00
2010-05-03 16:19:13 -04:00
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 ] ) {
2010-05-03 16:20:46 -04:00
$q [ 'author_name' ] = $q [ 'author_name' ][ count ( $q [ 'author_name' ]) - 1 ]; // no trailing slash
2006-03-12 20:44:32 -05:00
} else {
2011-09-05 15:08:15 -04:00
$q [ 'author_name' ] = $q [ 'author_name' ][ count ( $q [ 'author_name' ]) - 2 ]; // there was a trailing slash
2006-03-12 20:44:32 -05:00
}
}
2010-10-23 08:55:55 -04:00
$q [ 'author_name' ] = sanitize_title_for_query ( $q [ 'author_name' ] );
2009-04-17 17:25:11 -04:00
$q [ 'author' ] = get_user_by ( 'slug' , $q [ 'author_name' ]);
if ( $q [ 'author' ] )
2009-04-20 14:18:39 -04:00
$q [ 'author' ] = $q [ 'author' ] -> ID ;
2010-05-03 16:19:13 -04:00
$whichauthor .= " AND ( $wpdb->posts .post_author = " . absint ( $q [ 'author' ]) . ')' ;
2006-03-12 20:44:32 -05:00
}
2008-02-19 01:13:20 -05:00
// MIME-Type stuff for attachment browsing
2012-03-30 09:08:12 -04:00
if ( isset ( $q [ 'post_mime_type' ] ) && '' != $q [ 'post_mime_type' ] )
$whichmimetype = wp_post_mime_type_where ( $q [ 'post_mime_type' ], $wpdb -> posts );
2008-02-19 01:13:20 -05:00
2010-09-13 12:44:14 -04:00
$where .= $search . $whichauthor . $whichmimetype ;
2006-03-12 20:44:32 -05:00
2015-01-31 10:48:24 -05:00
if ( ! empty ( $this -> meta_query -> queries ) ) {
$clauses = $this -> meta_query -> get_sql ( 'post' , $wpdb -> posts , 'ID' , $this );
$join .= $clauses [ 'join' ];
$where .= $clauses [ 'where' ];
}
2014-09-22 23:52:15 -04:00
$rand = ( isset ( $q [ 'orderby' ] ) && 'rand' === $q [ 'orderby' ] );
2014-07-08 13:16:15 -04:00
if ( ! isset ( $q [ 'order' ] ) ) {
2014-09-22 23:52:15 -04:00
$q [ 'order' ] = $rand ? '' : 'DESC' ;
2014-07-08 13:16:15 -04:00
} else {
2014-09-22 23:52:15 -04:00
$q [ 'order' ] = $rand ? '' : $this -> parse_order ( $q [ 'order' ] );
2014-07-08 13:16:15 -04:00
}
2006-03-12 20:44:32 -05:00
2014-07-08 13:16:15 -04:00
// 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' ];
}
2009-05-20 17:26:00 -04:00
} elseif ( 'none' == $q [ 'orderby' ] ) {
2011-04-18 17:27:13 -04:00
$orderby = '' ;
2012-09-06 15:01:21 -04:00
} elseif ( $q [ 'orderby' ] == 'post__in' && ! empty ( $post__in ) ) {
$orderby = " FIELD( { $wpdb -> posts } .ID, $post__in ) " ;
2013-02-15 21:08:46 -05:00
} elseif ( $q [ 'orderby' ] == 'post_parent__in' && ! empty ( $post_parent__in ) ) {
$orderby = " FIELD( { $wpdb -> posts } .post_parent, $post_parent__in ) " ;
2006-03-12 20:44:32 -05:00
} else {
2011-04-18 17:27:13 -04:00
$orderby_array = array ();
2014-07-08 13:16:15 -04:00
if ( is_array ( $q [ 'orderby' ] ) ) {
foreach ( $q [ 'orderby' ] as $_orderby => $order ) {
$orderby = addslashes_gpc ( urldecode ( $_orderby ) );
$parsed = $this -> parse_orderby ( $orderby );
2010-02-28 07:49:10 -05:00
2014-07-08 13:16:15 -04:00
if ( ! $parsed ) {
continue ;
}
$orderby_array [] = $parsed . ' ' . $this -> parse_order ( $order );
2008-02-08 14:50:10 -05:00
}
2014-07-08 13:16:15 -04:00
$orderby = implode ( ', ' , $orderby_array );
2010-02-28 07:49:10 -05:00
2014-07-08 13:16:15 -04:00
} 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 ;
}
2010-02-28 07:49:10 -05:00
2014-07-08 13:16:15 -04:00
$orderby_array [] = $parsed ;
}
$orderby = implode ( ' ' . $q [ 'order' ] . ', ' , $orderby_array );
if ( empty ( $orderby ) ) {
2014-09-22 23:52:15 -04:00
$orderby = " $wpdb->posts .post_date " . $q [ 'order' ];
} elseif ( ! empty ( $q [ 'order' ] ) ) {
2014-07-08 13:16:15 -04:00
$orderby .= " { $q [ 'order' ] } " ;
}
}
2006-03-12 20:44:32 -05:00
}
2013-09-27 13:34:09 -04:00
// Order search results by relevance only when another "orderby" is not specified in the query.
if ( ! empty ( $q [ 's' ] ) ) {
$search_orderby = '' ;
2013-10-24 22:29:52 -04:00
if ( ! empty ( $q [ 'search_orderby_title' ] ) && ( empty ( $q [ 'orderby' ] ) && ! $this -> is_feed ) || ( isset ( $q [ 'orderby' ] ) && 'relevance' === $q [ 'orderby' ] ) )
2013-09-27 13:34:09 -04:00
$search_orderby = $this -> parse_search_order ( $q );
/**
* Filter 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 ;
}
2013-04-26 21:28:35 -04:00
if ( is_array ( $post_type ) && count ( $post_type ) > 1 ) {
2009-11-05 11:08:53 -05:00
$post_type_cap = 'multiple_post_type' ;
2010-02-16 16:13:44 -05:00
} else {
2013-04-26 21:28:35 -04:00
if ( is_array ( $post_type ) )
$post_type = reset ( $post_type );
2010-10-23 14:16:41 -04:00
$post_type_object = get_post_type_object ( $post_type );
if ( empty ( $post_type_object ) )
2010-01-04 11:58:43 -05:00
$post_type_cap = $post_type ;
}
2009-09-22 18:57:01 -04:00
2014-03-04 02:45:14 -05:00
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' ] ? '!=' : '=' );
}
2009-02-04 15:32:27 -05:00
if ( 'any' == $post_type ) {
2011-10-28 16:03:26 -04:00
$in_search_post_types = get_post_types ( array ( 'exclude_from_search' => false ) );
2013-09-04 14:51:10 -04:00
if ( empty ( $in_search_post_types ) )
$where .= ' AND 1=0 ' ;
2013-09-04 17:33:09 -04:00
else
2012-11-07 14:28:08 -05:00
$where .= " AND $wpdb->posts .post_type IN (' " . join ( " ', ' " , $in_search_post_types ) . " ') " ;
2009-11-05 11:08:53 -05:00
} elseif ( ! empty ( $post_type ) && is_array ( $post_type ) ) {
2010-01-15 17:11:12 -05:00
$where .= " AND $wpdb->posts .post_type IN (' " . join ( " ', ' " , $post_type ) . " ') " ;
2009-08-14 23:28:03 -04:00
} elseif ( ! empty ( $post_type ) ) {
$where .= " AND $wpdb->posts .post_type = ' $post_type ' " ;
2010-02-16 16:13:44 -05:00
$post_type_object = get_post_type_object ( $post_type );
2009-02-04 15:32:27 -05:00
} elseif ( $this -> is_attachment ) {
2008-03-23 13:02:11 -04:00
$where .= " AND $wpdb->posts .post_type = 'attachment' " ;
2010-02-16 16:13:44 -05:00
$post_type_object = get_post_type_object ( 'attachment' );
2010-05-03 16:19:13 -04:00
} elseif ( $this -> is_page ) {
2008-03-23 13:02:11 -04:00
$where .= " AND $wpdb->posts .post_type = 'page' " ;
2010-02-16 16:13:44 -05:00
$post_type_object = get_post_type_object ( 'page' );
2009-08-15 06:57:56 -04:00
} else {
2008-03-23 13:02:11 -04:00
$where .= " AND $wpdb->posts .post_type = 'post' " ;
2010-02-16 16:13:44 -05:00
$post_type_object = get_post_type_object ( 'post' );
}
2013-07-08 16:05:42 -04:00
$edit_cap = 'edit_post' ;
$read_cap = 'read_post' ;
2010-10-23 14:16:41 -04:00
if ( ! empty ( $post_type_object ) ) {
2010-05-12 17:03:33 -04:00
$edit_others_cap = $post_type_object -> cap -> edit_others_posts ;
2010-05-12 16:45:18 -04:00
$read_private_cap = $post_type_object -> cap -> read_private_posts ;
2010-02-16 16:13:44 -05:00
} else {
$edit_others_cap = 'edit_others_' . $post_type_cap . 's' ;
$read_private_cap = 'read_private_' . $post_type_cap . 's' ;
2007-05-28 14:34:06 -04:00
}
2013-10-03 09:36:09 -04:00
$user_id = get_current_user_id ();
2015-02-01 15:26:25 -05:00
$q_status = array ();
2011-04-23 06:36:22 -04:00
if ( ! empty ( $q [ 'post_status' ] ) ) {
2008-03-23 13:02:11 -04:00
$statuswheres = array ();
2011-04-23 06:36:22 -04:00
$q_status = $q [ 'post_status' ];
if ( ! is_array ( $q_status ) )
$q_status = explode ( ',' , $q_status );
2007-05-28 14:34:06 -04:00
$r_status = array ();
2008-02-29 16:49:49 -05:00
$p_status = array ();
2010-02-10 17:36:50 -05:00
$e_status = array ();
2014-05-29 16:42:18 -04:00
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 ' " ;
}
}
2009-12-01 03:14:42 -05:00
} else {
2010-02-06 12:51:24 -05:00
foreach ( get_post_stati () as $status ) {
2010-02-10 15:37:18 -05:00
if ( in_array ( $status , $q_status ) ) {
if ( 'private' == $status )
$p_status [] = " $wpdb->posts .post_status = ' $status ' " ;
else
$r_status [] = " $wpdb->posts .post_status = ' $status ' " ;
}
2010-02-06 12:51:24 -05:00
}
2009-12-01 03:14:42 -05:00
}
2008-02-29 16:49:49 -05:00
if ( empty ( $q [ 'perm' ] ) || 'readable' != $q [ 'perm' ] ) {
$r_status = array_merge ( $r_status , $p_status );
unset ( $p_status );
}
2010-02-10 17:36:50 -05:00
if ( ! empty ( $e_status ) ) {
$statuswheres [] = " ( " . join ( ' AND ' , $e_status ) . " ) " ;
}
2008-02-29 16:49:49 -05:00
if ( ! empty ( $r_status ) ) {
2010-02-16 16:13:44 -05:00
if ( ! empty ( $q [ 'perm' ] ) && 'editable' == $q [ 'perm' ] && ! current_user_can ( $edit_others_cap ) )
2013-10-02 17:10:09 -04:00
$statuswheres [] = " ( $wpdb->posts .post_author = $user_id " . " AND ( " . join ( ' OR ' , $r_status ) . " )) " ;
2008-02-29 16:49:49 -05:00
else
2008-03-23 13:02:11 -04:00
$statuswheres [] = " ( " . join ( ' OR ' , $r_status ) . " ) " ;
2008-02-29 16:49:49 -05:00
}
if ( ! empty ( $p_status ) ) {
2010-02-16 16:13:44 -05:00
if ( ! empty ( $q [ 'perm' ] ) && 'readable' == $q [ 'perm' ] && ! current_user_can ( $read_private_cap ) )
2013-10-02 17:10:09 -04:00
$statuswheres [] = " ( $wpdb->posts .post_author = $user_id " . " AND ( " . join ( ' OR ' , $p_status ) . " )) " ;
2008-02-29 16:49:49 -05:00
else
2008-03-23 13:02:11 -04:00
$statuswheres [] = " ( " . join ( ' OR ' , $p_status ) . " ) " ;
}
2009-05-20 20:10:04 -04:00
if ( $post_status_join ) {
2009-05-25 01:36:48 -04:00
$join .= " LEFT JOIN $wpdb->posts AS p2 ON ( $wpdb->posts .post_parent = p2.ID) " ;
2009-05-20 20:10:04 -04:00
foreach ( $statuswheres as $index => $statuswhere )
$statuswheres [ $index ] = " ( $statuswhere OR ( $wpdb->posts .post_status = 'inherit' AND " . str_replace ( $wpdb -> posts , 'p2' , $statuswhere ) . " )) " ;
}
2014-02-02 02:36:13 -05:00
$where_status = implode ( ' OR ' , $statuswheres );
if ( ! empty ( $where_status ) ) {
$where .= " AND ( $where_status ) " ;
2014-02-20 12:34:14 -05:00
}
2007-05-28 14:34:06 -04:00
} elseif ( ! $this -> is_singular ) {
2008-03-23 13:02:11 -04:00
$where .= " AND ( $wpdb->posts .post_status = 'publish' " ;
2006-03-12 20:44:32 -05:00
2010-02-16 16:13:44 -05:00
// 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 ' " ;
}
2012-02-15 14:58:10 -05:00
if ( $this -> is_admin ) {
2010-02-16 16:13:44 -05:00
// Add protected states that should show in the admin all list.
2010-04-16 10:08:58 -04:00
$admin_all_states = get_post_stati ( array ( 'protected' => true , 'show_in_admin_all_list' => true ) );
2010-02-16 16:13:44 -05:00
foreach ( ( array ) $admin_all_states as $state )
$where .= " OR $wpdb->posts .post_status = ' $state ' " ;
}
2007-06-13 22:25:30 -04:00
2007-05-28 16:39:24 -04:00
if ( is_user_logged_in () ) {
2010-02-16 16:13:44 -05:00
// 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 )
2013-10-02 17:10:09 -04:00
$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 ' " ;
2007-05-28 16:39:24 -04:00
}
2006-05-11 19:13:35 -04:00
2007-05-28 14:34:06 -04:00
$where .= ')' ;
2006-03-12 20:44:32 -05:00
}
2014-02-20 12:34:14 -05:00
/*
* Apply filters on where and join prior to paging so that any
* manipulations to them are reflected in the paging by day queries .
*/
2008-08-28 18:30:27 -04:00
if ( ! $q [ 'suppress_filters' ] ) {
2014-02-20 12:34:14 -05:00
/**
* Filter 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 ) );
/**
* Filter the JOIN clause of the query .
*
* @ since 1.5 . 0
*
* @ param string $where 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 ) );
2008-08-28 18:30:27 -04:00
}
2006-03-12 20:44:32 -05:00
// Paging
2007-03-08 23:05:28 -05:00
if ( empty ( $q [ 'nopaging' ]) && ! $this -> is_singular ) {
2008-01-29 13:48:38 -05:00
$page = absint ( $q [ 'paged' ]);
2012-01-09 15:08:57 -05:00
if ( ! $page )
2006-03-12 20:44:32 -05:00
$page = 1 ;
2013-12-02 11:26:10 -05:00
if ( empty ( $q [ 'offset' ]) ) {
2014-06-26 20:04:16 -04:00
$pgstrt = absint ( ( $page - 1 ) * $q [ 'posts_per_page' ] ) . ', ' ;
2013-12-02 11:26:10 -05:00
} else { // we're ignoring $page and using 'offset'
2008-01-29 13:48:38 -05:00
$q [ 'offset' ] = absint ( $q [ 'offset' ]);
2013-12-02 11:26:10 -05:00
$pgstrt = $q [ 'offset' ] . ', ' ;
2006-03-12 20:44:32 -05:00
}
2013-12-02 11:26:10 -05:00
$limits = 'LIMIT ' . $pgstrt . $q [ 'posts_per_page' ];
2006-03-12 20:44:32 -05:00
}
2007-02-27 10:24:54 -05:00
2007-02-24 02:33:29 -05:00
// Comments feeds
2014-07-21 11:38:14 -04:00
if ( $this -> is_comment_feed && ! $this -> is_singular ) {
2007-02-24 02:33:29 -05:00
if ( $this -> is_archive || $this -> is_search ) {
2009-05-11 00:56:00 -04:00
$cjoin = " JOIN $wpdb->posts ON ( $wpdb->comments .comment_post_ID = $wpdb->posts .ID) $join " ;
2007-02-24 02:33:29 -05:00
$cwhere = " WHERE comment_approved = '1' $where " ;
2009-05-05 18:41:26 -04:00
$cgroupby = " $wpdb->comments .comment_id " ;
2007-02-24 02:33:29 -05:00
} else { // Other non singular e.g. front
2009-05-11 00:56:00 -04:00
$cjoin = " JOIN $wpdb->posts ON ( $wpdb->comments .comment_post_ID = $wpdb->posts .ID ) " ;
2007-02-24 02:33:29 -05:00
$cwhere = " WHERE post_status = 'publish' AND comment_approved = '1' " ;
$cgroupby = '' ;
}
2007-02-27 10:24:54 -05:00
2008-08-28 18:30:27 -04:00
if ( ! $q [ 'suppress_filters' ] ) {
2014-02-20 12:46:13 -05:00
/**
* Filter 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 ) );
/**
* Filter 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 ) );
/**
* Filter 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 ) );
/**
* Filter 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 ) );
/**
* Filter 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 ) );
2008-08-28 18:30:27 -04:00
}
2009-05-05 18:41:26 -04:00
$cgroupby = ( ! empty ( $cgroupby ) ) ? 'GROUP BY ' . $cgroupby : '' ;
$corderby = ( ! empty ( $corderby ) ) ? 'ORDER BY ' . $corderby : '' ;
2007-02-27 10:24:54 -05:00
2009-05-05 18:41:26 -04:00
$this -> comments = ( array ) $wpdb -> get_results ( " SELECT $distinct $wpdb->comments .* FROM $wpdb->comments $cjoin $cwhere $cgroupby $corderby $climits " );
2007-02-24 02:33:29 -05:00
$this -> comment_count = count ( $this -> comments );
$post_ids = array ();
2007-02-27 10:24:54 -05:00
2010-05-03 16:19:13 -04:00
foreach ( $this -> comments as $comment )
2007-02-24 02:33:29 -05:00
$post_ids [] = ( int ) $comment -> comment_post_ID ;
2007-02-27 10:24:54 -05:00
2007-02-24 02:33:29 -05:00
$post_ids = join ( ',' , $post_ids );
$join = '' ;
if ( $post_ids )
$where = " AND $wpdb->posts .ID IN ( $post_ids ) " ;
else
$where = " AND 0 " ;
}
2006-03-12 20:44:32 -05:00
2010-10-13 12:37:01 -04:00
$pieces = array ( 'where' , 'groupby' , 'join' , 'orderby' , 'distinct' , 'fields' , 'limits' );
2014-02-20 12:34:14 -05:00
/*
* Apply post - paging filters on where and join . Only plugins that
* manipulate paging queries should use these hooks .
*/
2008-08-28 18:30:27 -04:00
if ( ! $q [ 'suppress_filters' ] ) {
2014-02-20 12:34:14 -05:00
/**
* Filter 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 ) .
*/
2014-02-20 12:59:13 -05:00
$where = apply_filters_ref_array ( 'posts_where_paged' , array ( $where , & $this ) );
2014-02-20 12:34:14 -05:00
/**
* Filter 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 ) .
*/
2014-02-20 12:59:13 -05:00
$groupby = apply_filters_ref_array ( 'posts_groupby' , array ( $groupby , & $this ) );
2014-02-20 12:34:14 -05:00
/**
* Filter 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 ) .
*/
2014-02-20 12:59:13 -05:00
$join = apply_filters_ref_array ( 'posts_join_paged' , array ( $join , & $this ) );
2014-02-20 12:34:14 -05:00
/**
* Filter 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 ) .
*/
2014-02-20 12:59:13 -05:00
$orderby = apply_filters_ref_array ( 'posts_orderby' , array ( $orderby , & $this ) );
2014-02-20 12:34:14 -05:00
/**
* Filter 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 ) .
*/
2014-02-20 12:59:13 -05:00
$distinct = apply_filters_ref_array ( 'posts_distinct' , array ( $distinct , & $this ) );
2014-02-20 12:34:14 -05:00
/**
* Filter 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 ) .
*/
2014-02-20 12:59:13 -05:00
$limits = apply_filters_ref_array ( 'post_limits' , array ( $limits , & $this ) );
2014-02-20 12:34:14 -05:00
/**
* Filter 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 ) .
*/
2014-02-20 12:59:13 -05:00
$fields = apply_filters_ref_array ( 'posts_fields' , array ( $fields , & $this ) );
2010-10-13 12:37:01 -04:00
2014-02-20 12:34:14 -05:00
/**
* Filter 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 array $clauses The list of clauses for the query .
* @ param WP_Query & $this The WP_Query instance ( passed by reference ) .
*/
2010-11-24 15:34:22 -05:00
$clauses = ( array ) apply_filters_ref_array ( 'posts_clauses' , array ( compact ( $pieces ), & $this ) );
2014-02-20 12:34:14 -05:00
2014-06-11 13:50:16 -04:00
$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' ] : '' ;
2008-08-28 18:30:27 -04:00
}
2007-11-18 14:36:30 -05:00
2014-02-20 12:41:12 -05:00
/**
* 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 .
*/
2007-11-18 14:36:30 -05:00
do_action ( 'posts_selection' , $where . $groupby . $orderby . $limits . $join );
2014-02-20 12:41:12 -05:00
/*
* Filter again for the benefit of caching plugins .
* Regular plugins should use the hooks above .
*/
2008-08-28 18:30:27 -04:00
if ( ! $q [ 'suppress_filters' ] ) {
2014-02-20 12:41:12 -05:00
/**
* Filter 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 ) .
*/
2014-02-20 12:59:13 -05:00
$where = apply_filters_ref_array ( 'posts_where_request' , array ( $where , & $this ) );
2014-02-20 12:41:12 -05:00
/**
* Filter 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 ) .
*/
2014-02-20 12:59:13 -05:00
$groupby = apply_filters_ref_array ( 'posts_groupby_request' , array ( $groupby , & $this ) );
2014-02-20 12:41:12 -05:00
/**
* Filter 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 ) .
*/
2014-02-20 12:59:13 -05:00
$join = apply_filters_ref_array ( 'posts_join_request' , array ( $join , & $this ) );
2014-02-20 12:41:12 -05:00
/**
* Filter 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 ) .
*/
2014-02-20 12:59:13 -05:00
$orderby = apply_filters_ref_array ( 'posts_orderby_request' , array ( $orderby , & $this ) );
2014-02-20 12:41:12 -05:00
/**
* Filter 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 ) .
*/
2014-02-20 12:59:13 -05:00
$distinct = apply_filters_ref_array ( 'posts_distinct_request' , array ( $distinct , & $this ) );
2014-02-20 12:41:12 -05:00
/**
* Filter 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 ) .
*/
2014-02-20 12:59:13 -05:00
$fields = apply_filters_ref_array ( 'posts_fields_request' , array ( $fields , & $this ) );
2014-02-20 12:41:12 -05:00
/**
* Filter 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 ) .
*/
2014-02-20 12:59:13 -05:00
$limits = apply_filters_ref_array ( 'post_limits_request' , array ( $limits , & $this ) );
2010-10-13 12:37:01 -04:00
2014-02-20 12:41:12 -05:00
/**
* Filter 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 array $pieces The pieces of the query .
* @ param WP_Query & $this The WP_Query instance ( passed by reference ) .
*/
2010-11-24 15:34:22 -05:00
$clauses = ( array ) apply_filters_ref_array ( 'posts_clauses_request' , array ( compact ( $pieces ), & $this ) );
2014-06-11 13:50:16 -04:00
$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' ] : '' ;
2008-08-28 18:30:27 -04:00
}
2007-11-18 14:36:30 -05:00
if ( ! empty ( $groupby ) )
$groupby = 'GROUP BY ' . $groupby ;
if ( ! empty ( $orderby ) )
$orderby = 'ORDER BY ' . $orderby ;
2010-10-26 15:01:55 -04:00
2006-11-08 04:13:11 -05:00
$found_rows = '' ;
2010-03-10 13:37:03 -05:00
if ( ! $q [ 'no_found_rows' ] && ! empty ( $limits ) )
2006-11-08 04:13:11 -05:00
$found_rows = 'SQL_CALC_FOUND_ROWS' ;
2006-12-01 05:15:15 -05:00
2012-02-14 10:09:35 -05:00
$this -> request = $old_request = " SELECT $found_rows $distinct $fields FROM $wpdb->posts $join WHERE 1=1 $where $groupby $orderby $limits " ;
if ( ! $q [ 'suppress_filters' ] ) {
2014-02-20 12:54:13 -05:00
/**
* Filter the completed SQL query before sending .
*
* @ since 2.0 . 0
*
* @ param array $request The complete SQL query .
* @ param WP_Query & $this The WP_Query instance ( passed by reference ) .
*/
2012-02-28 15:37:47 -05:00
$this -> request = apply_filters_ref_array ( 'posts_request' , array ( $this -> request , & $this ) );
2012-02-14 10:09:35 -05:00
}
2010-03-27 02:03:58 -04:00
2010-10-26 15:01:55 -04:00
if ( 'ids' == $q [ 'fields' ] ) {
2012-09-20 10:55:54 -04:00
$this -> posts = $wpdb -> get_col ( $this -> request );
2015-02-02 21:29:25 -05:00
$this -> posts = array_map ( 'intval' , $this -> posts );
2012-09-20 10:55:54 -04:00
$this -> post_count = count ( $this -> posts );
$this -> set_found_posts ( $q , $limits );
2010-10-26 15:01:55 -04:00
2015-02-02 21:29:25 -05:00
return $this -> posts ;
2010-10-26 15:01:55 -04:00
}
if ( 'id=>parent' == $q [ 'fields' ] ) {
2012-09-20 10:55:54 -04:00
$this -> posts = $wpdb -> get_results ( $this -> request );
$this -> post_count = count ( $this -> posts );
$this -> set_found_posts ( $q , $limits );
2010-10-26 15:01:55 -04:00
$r = array ();
2015-02-02 21:29:25 -05:00
foreach ( $this -> posts as $key => $post ) {
$this -> posts [ $key ] -> ID = ( int ) $post -> ID ;
$this -> posts [ $key ] -> post_parent = ( int ) $post -> post_parent ;
2014-03-24 14:55:16 -04:00
$r [ ( int ) $post -> ID ] = ( int ) $post -> post_parent ;
}
2015-02-02 21:29:25 -05:00
2010-10-26 15:01:55 -04:00
return $r ;
}
2012-05-09 13:20:22 -04:00
$split_the_query = ( $old_request == $this -> request && " $wpdb->posts .* " == $fields && ! empty ( $limits ) && $q [ 'posts_per_page' ] < 500 );
2014-02-20 12:54:13 -05:00
/**
* Filter 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 .
*/
2012-05-09 13:20:22 -04:00
$split_the_query = apply_filters ( 'split_the_query' , $split_the_query , $this );
2012-05-08 16:01:47 -04:00
if ( $split_the_query ) {
2012-02-14 10:09:35 -05:00
// 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 " ;
2014-02-20 12:54:13 -05:00
/**
* Filter 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 .
*/
2012-02-14 10:09:35 -05:00
$this -> request = apply_filters ( 'posts_request_ids' , $this -> request , $this );
$ids = $wpdb -> get_col ( $this -> request );
if ( $ids ) {
2012-09-20 10:55:54 -04:00
$this -> posts = $ids ;
2012-02-14 10:09:35 -05:00
$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 );
}
2010-10-26 15:01:55 -04:00
2012-08-20 15:47:52 -04:00
// Convert to WP_Post objects
2012-09-26 08:32:54 -04:00
if ( $this -> posts )
$this -> posts = array_map ( 'get_post' , $this -> posts );
2012-08-20 15:47:52 -04:00
2014-02-20 12:54:13 -05:00
if ( ! $q [ 'suppress_filters' ] ) {
/**
* Filter the raw post results array , prior to status checks .
*
* @ since 2.3 . 0
*
* @ param array $posts The post results array .
* @ param WP_Query & $this The WP_Query instance ( passed by reference ) .
*/
$this -> posts = apply_filters_ref_array ( 'posts_results' , array ( $this -> posts , & $this ) );
}
2007-02-24 02:33:29 -05:00
2008-01-29 14:01:39 -05:00
if ( ! empty ( $this -> posts ) && $this -> is_comment_feed && $this -> is_singular ) {
2014-02-20 12:46:13 -05:00
/** 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 ) );
2009-05-05 18:41:26 -04:00
$cgroupby = ( ! empty ( $cgroupby ) ) ? 'GROUP BY ' . $cgroupby : '' ;
2014-02-20 12:46:13 -05:00
/** This filter is documented in wp-includes/query.php */
$corderby = apply_filters_ref_array ( 'comment_feed_orderby' , array ( 'comment_date_gmt DESC' , & $this ) );
2009-05-05 18:41:26 -04:00
$corderby = ( ! empty ( $corderby ) ) ? 'ORDER BY ' . $corderby : '' ;
2014-02-20 12:46:13 -05:00
/** 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 ) );
2009-05-05 18:41:26 -04:00
$comments_request = " SELECT $wpdb->comments .* FROM $wpdb->comments $cjoin $cwhere $cgroupby $corderby $climits " ;
2007-02-24 02:33:29 -05:00
$this -> comments = $wpdb -> get_results ( $comments_request );
$this -> comment_count = count ( $this -> comments );
}
2007-02-27 10:24:54 -05:00
2006-03-12 20:44:32 -05:00
// Check post status to determine if post should be displayed.
if ( ! empty ( $this -> posts ) && ( $this -> is_single || $this -> is_page ) ) {
2012-06-12 19:09:27 -04:00
$status = get_post_status ( $this -> posts [ 0 ]);
2010-02-16 16:13:44 -05:00
$post_status_obj = get_post_status_object ( $status );
2006-03-12 20:44:32 -05:00
//$type = get_post_type($this->posts[0]);
2015-02-01 15:26:25 -05:00
// If the post_status was specifically requested, let it pass through.
if ( ! $post_status_obj -> public && ! in_array ( $status , $q_status ) ) {
2006-03-12 20:44:32 -05:00
if ( ! is_user_logged_in () ) {
// User must be logged in to view unpublished posts.
$this -> posts = array ();
} else {
2010-02-16 16:13:44 -05:00
if ( $post_status_obj -> protected ) {
2006-03-12 20:44:32 -05:00
// User must have edit permissions on the draft to preview.
2010-05-03 16:19:13 -04:00
if ( ! current_user_can ( $edit_cap , $this -> posts [ 0 ] -> ID ) ) {
2006-03-12 20:44:32 -05:00
$this -> posts = array ();
} else {
$this -> is_preview = true ;
2010-05-03 16:19:13 -04:00
if ( 'future' != $status )
2010-02-16 16:13:44 -05:00
$this -> posts [ 0 ] -> post_date = current_time ( 'mysql' );
2006-03-12 20:44:32 -05:00
}
2010-02-16 16:13:44 -05:00
} elseif ( $post_status_obj -> private ) {
if ( ! current_user_can ( $read_cap , $this -> posts [ 0 ] -> ID ) )
2006-03-12 20:44:32 -05:00
$this -> posts = array ();
2010-02-16 16:13:44 -05:00
} else {
$this -> posts = array ();
2006-03-12 20:44:32 -05:00
}
}
}
2008-11-04 08:00:12 -05:00
2014-02-20 12:54:13 -05:00
if ( $this -> is_preview && $this -> posts && current_user_can ( $edit_cap , $this -> posts [ 0 ] -> ID ) ) {
/**
* Filter 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 ) .
*/
2012-10-16 09:48:07 -04:00
$this -> posts [ 0 ] = get_post ( apply_filters_ref_array ( 'the_preview' , array ( $this -> posts [ 0 ], & $this ) ) );
2014-02-20 12:54:13 -05:00
}
2006-03-12 20:44:32 -05:00
}
2008-08-05 01:48:21 -04:00
// Put sticky posts at the top of the posts array
$sticky_posts = get_option ( 'sticky_posts' );
2010-09-07 00:46:08 -04:00
if ( $this -> is_home && $page <= 1 && is_array ( $sticky_posts ) && ! empty ( $sticky_posts ) && ! $q [ 'ignore_sticky_posts' ] ) {
2008-08-05 01:48:21 -04:00
$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 ));
2011-12-13 18:45:31 -05:00
// Increment the sticky offset. The next sticky will be placed at this offset.
2008-08-05 01:48:21 -04:00
$sticky_offset ++ ;
// Remove post from sticky posts array
$offset = array_search ( $sticky_post -> ID , $sticky_posts );
2010-04-18 01:11:05 -04:00
unset ( $sticky_posts [ $offset ] );
2008-08-05 01:48:21 -04:00
}
}
2010-04-24 02:04:05 -04:00
// 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' ]);
2008-08-05 01:48:21 -04:00
// Fetch sticky posts that weren't in the query results
2008-08-13 14:21:52 -04:00
if ( ! empty ( $sticky_posts ) ) {
2012-08-22 14:24:23 -04:00
$stickies = get_posts ( array (
'post__in' => $sticky_posts ,
'post_type' => $post_type ,
'post_status' => 'publish' ,
'nopaging' => true
) );
2010-04-24 02:04:05 -04:00
2008-08-13 14:21:52 -04:00
foreach ( $stickies as $sticky_post ) {
2012-08-22 14:24:23 -04:00
array_splice ( $this -> posts , $sticky_offset , 0 , array ( $sticky_post ) );
2010-02-13 01:08:15 -05:00
$sticky_offset ++ ;
2008-08-13 14:21:52 -04:00
}
2008-08-05 01:48:21 -04:00
}
}
2014-02-20 12:54:13 -05:00
if ( ! $q [ 'suppress_filters' ] ) {
/**
* Filter the array of retrieved posts after they ' ve been fetched and
* internally processed .
*
* @ since 1.5 . 0
*
* @ param array $posts The array of retrieved posts .
* @ param WP_Query & $this The WP_Query instance ( passed by reference ) .
*/
$this -> posts = apply_filters_ref_array ( 'the_posts' , array ( $this -> posts , & $this ) );
}
2006-11-23 10:38:22 -05:00
2012-10-15 16:42:57 -04:00
// Ensure that any posts added/modified via one of the filters above are
// of the type WP_Post and are filtered.
2012-11-08 08:52:40 -05:00
if ( $this -> posts ) {
$this -> post_count = count ( $this -> posts );
2012-11-17 10:11:29 -05:00
2012-10-15 16:42:57 -04:00
$this -> posts = array_map ( 'get_post' , $this -> posts );
2009-10-19 17:28:44 -04:00
2012-11-08 08:52:40 -05:00
if ( $q [ 'cache_results' ] )
update_post_caches ( $this -> posts , $post_type , $q [ 'update_post_term_cache' ], $q [ 'update_post_meta_cache' ]);
2006-03-12 20:44:32 -05:00
2012-11-17 10:11:29 -05:00
$this -> post = reset ( $this -> posts );
2012-11-08 08:52:40 -05:00
} else {
$this -> post_count = 0 ;
$this -> posts = array ();
2006-03-12 20:44:32 -05:00
}
return $this -> posts ;
}
2012-09-20 10:55:54 -04:00
/**
* 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
* @ access private
2015-05-27 14:15:25 -04:00
*
* @ global wpdb $wpdb
2012-09-20 10:55:54 -04:00
*/
2014-05-19 13:41:13 -04:00
private function set_found_posts ( $q , $limits ) {
2012-02-14 10:09:35 -05:00
global $wpdb ;
2013-04-25 19:10:36 -04:00
// Bail if posts is an empty array. Continue if posts is an empty string,
2012-10-17 16:57:23 -04:00
// null, or false to accommodate caching plugins that fill posts later.
if ( $q [ 'no_found_rows' ] || ( is_array ( $this -> posts ) && ! $this -> posts ) )
2012-02-14 10:09:35 -05:00
return ;
2014-02-20 12:54:13 -05:00
if ( ! empty ( $limits ) ) {
/**
* Filter 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 ) .
*/
2012-09-20 10:55:54 -04:00
$this -> found_posts = $wpdb -> get_var ( apply_filters_ref_array ( 'found_posts_query' , array ( 'SELECT FOUND_ROWS()' , & $this ) ) );
2014-02-20 12:54:13 -05:00
} else {
2012-09-20 10:55:54 -04:00
$this -> found_posts = count ( $this -> posts );
2014-02-20 12:54:13 -05:00
}
2012-09-20 10:55:54 -04:00
2014-02-20 12:54:13 -05:00
/**
* Filter 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 ) .
*/
2012-02-28 15:37:47 -05:00
$this -> found_posts = apply_filters_ref_array ( 'found_posts' , array ( $this -> found_posts , & $this ) );
2012-02-14 10:09:35 -05:00
2012-09-20 10:55:54 -04:00
if ( ! empty ( $limits ) )
$this -> max_num_pages = ceil ( $this -> found_posts / $q [ 'posts_per_page' ] );
2012-02-14 10:09:35 -05:00
}
2008-09-04 15:19:32 -04:00
/**
2010-03-17 00:39:50 -04:00
* Set up the next post and iterate current post index .
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
* @ access public
*
2012-08-23 16:34:41 -04:00
* @ return WP_Post Next post .
2008-09-04 15:19:32 -04:00
*/
2014-05-19 02:49:16 -04:00
public function next_post () {
2006-11-19 02:56:05 -05:00
2006-03-12 20:44:32 -05:00
$this -> current_post ++ ;
$this -> post = $this -> posts [ $this -> current_post ];
return $this -> post ;
}
2008-09-04 15:19:32 -04:00
/**
* 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
* @ access public
2015-05-27 14:15:25 -04:00
*
* @ global WP_Post $post
2008-09-04 15:19:32 -04:00
*/
2014-05-19 02:49:16 -04:00
public function the_post () {
2006-03-12 20:44:32 -05:00
global $post ;
$this -> in_the_loop = true ;
2009-05-26 19:57:01 -04:00
if ( $this -> current_post == - 1 ) // loop has just started
2014-02-20 12:54:13 -05:00
/**
* 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 ) );
2009-05-26 19:57:01 -04:00
$post = $this -> next_post ();
2014-10-28 22:32:24 -04:00
$this -> setup_postdata ( $post );
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
* Whether there are more posts available in the loop .
*
* Calls action 'loop_end' , when the loop is complete .
*
* @ since 1.5 . 0
* @ access public
*
* @ return bool True if posts are available , false if end of loop .
*/
2014-05-19 02:49:16 -04:00
public function have_posts () {
2010-05-03 16:19:13 -04:00
if ( $this -> current_post + 1 < $this -> post_count ) {
2006-03-12 20:44:32 -05:00
return true ;
2010-05-03 16:19:13 -04:00
} elseif ( $this -> current_post + 1 == $this -> post_count && $this -> post_count > 0 ) {
2014-02-20 12:54:13 -05:00
/**
* 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 ) );
2006-03-12 20:44:32 -05:00
// Do some cleaning up after the loop
$this -> rewind_posts ();
}
$this -> in_the_loop = false ;
return false ;
}
2008-09-04 15:19:32 -04:00
/**
* Rewind the posts and reset post index .
*
* @ since 1.5 . 0
* @ access public
*/
2014-05-19 02:49:16 -04:00
public function rewind_posts () {
2006-03-12 20:44:32 -05:00
$this -> current_post = - 1 ;
2010-05-03 16:19:13 -04:00
if ( $this -> post_count > 0 ) {
2006-03-12 20:44:32 -05:00
$this -> post = $this -> posts [ 0 ];
}
}
2007-02-27 10:24:54 -05:00
2008-09-04 15:19:32 -04:00
/**
* Iterate current comment index and return comment object .
*
* @ since 2.2 . 0
* @ access public
*
* @ return object Comment object .
*/
2014-05-19 02:49:16 -04:00
public function next_comment () {
2007-02-24 02:33:29 -05:00
$this -> current_comment ++ ;
2007-02-27 10:24:54 -05:00
2007-02-24 02:33:29 -05:00
$this -> comment = $this -> comments [ $this -> current_comment ];
return $this -> comment ;
}
2007-02-27 10:24:54 -05:00
2008-09-04 15:19:32 -04:00
/**
* Sets up the current comment .
*
* @ since 2.2 . 0
* @ access public
* @ global object $comment Current comment .
*/
2014-05-19 02:49:16 -04:00
public function the_comment () {
2007-02-24 02:33:29 -05:00
global $comment ;
2007-02-27 10:24:54 -05:00
2007-02-24 02:33:29 -05:00
$comment = $this -> next_comment ();
2007-02-27 10:24:54 -05:00
2010-05-03 16:19:13 -04:00
if ( $this -> current_comment == 0 ) {
2014-02-20 12:54:13 -05:00
/**
* Fires once the comment loop is started .
*
* @ since 2.2 . 0
*/
do_action ( 'comment_loop_start' );
2007-02-24 02:33:29 -05:00
}
}
2007-02-27 10:24:54 -05:00
2008-09-04 15:19:32 -04:00
/**
* Whether there are more comments available .
*
* Automatically rewinds comments when finished .
*
* @ since 2.2 . 0
* @ access public
*
* @ return bool True , if more comments . False , if no more posts .
*/
2014-05-19 02:49:16 -04:00
public function have_comments () {
2010-05-03 16:19:13 -04:00
if ( $this -> current_comment + 1 < $this -> comment_count ) {
2007-02-24 02:33:29 -05:00
return true ;
2010-05-03 16:19:13 -04:00
} elseif ( $this -> current_comment + 1 == $this -> comment_count ) {
2007-02-24 02:33:29 -05:00
$this -> rewind_comments ();
}
2007-02-27 10:24:54 -05:00
2007-02-24 02:33:29 -05:00
return false ;
}
2007-02-27 10:24:54 -05:00
2008-09-04 15:19:32 -04:00
/**
* Rewind the comments , resets the comment index and comment to first .
*
* @ since 2.2 . 0
* @ access public
*/
2014-05-19 02:49:16 -04:00
public function rewind_comments () {
2007-02-24 02:33:29 -05:00
$this -> current_comment = - 1 ;
2010-05-03 16:19:13 -04:00
if ( $this -> comment_count > 0 ) {
2007-02-24 02:33:29 -05:00
$this -> comment = $this -> comments [ 0 ];
}
}
2006-11-19 02:56:05 -05:00
2008-09-04 15:19:32 -04:00
/**
* Sets up the WordPress query by parsing query string .
*
* @ since 1.5 . 0
* @ access public
*
* @ param string $query URL query string .
* @ return array List of posts .
*/
2014-05-19 02:49:16 -04:00
public function query ( $query ) {
2011-02-15 18:57:13 -05:00
$this -> init ();
$this -> query = $this -> query_vars = wp_parse_args ( $query );
2006-03-12 20:44:32 -05:00
return $this -> get_posts ();
}
2008-09-04 15:19:32 -04:00
/**
* 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
* @ access public
*
* @ return object
*/
2014-05-19 02:49:16 -04:00
public function get_queried_object () {
2010-02-08 17:05:05 -05:00
if ( isset ( $this -> queried_object ) )
2006-03-12 20:44:32 -05:00
return $this -> queried_object ;
2012-01-05 15:50:54 -05:00
$this -> queried_object = null ;
2006-03-12 20:44:32 -05:00
$this -> queried_object_id = 0 ;
2010-12-10 02:51:04 -05:00
if ( $this -> is_category || $this -> is_tag || $this -> is_tax ) {
2013-11-04 18:54:10 -05:00
if ( $this -> is_category ) {
2013-12-22 13:31:12 -05:00
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' );
}
2013-11-04 18:54:10 -05:00
} elseif ( $this -> is_tag ) {
2014-03-12 00:08:18 -04:00
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' );
}
2013-12-27 14:30:10 -05:00
} else {
2014-12-07 09:58:22 -05:00
// For other tax queries, grab the first term from the first clause.
$tax_query_in_and = wp_list_filter ( $this -> tax_query -> queried_terms , array ( 'operator' => 'NOT IN' ), 'NOT' );
2015-02-07 14:50:24 -05:00
if ( ! empty ( $tax_query_in_and ) ) {
$queried_taxonomies = array_keys ( $tax_query_in_and );
$matched_taxonomy = reset ( $queried_taxonomies );
$query = $tax_query_in_and [ $matched_taxonomy ];
if ( $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 );
}
2013-12-27 14:30:10 -05:00
}
}
2013-11-04 18:54:10 -05:00
}
2010-09-13 12:44:14 -04:00
2012-11-07 17:09:05 -05:00
if ( ! empty ( $term ) && ! is_wp_error ( $term ) ) {
2010-10-17 02:14:58 -04:00
$this -> queried_object = $term ;
2010-11-22 19:32:19 -05:00
$this -> queried_object_id = ( int ) $term -> term_id ;
2011-03-22 16:27:45 -04:00
2013-11-04 18:54:10 -05:00
if ( $this -> is_category && 'category' === $this -> queried_object -> taxonomy )
2011-03-22 16:27:45 -04:00
_make_cat_compat ( $this -> queried_object );
2010-10-17 02:14:58 -04:00
}
2010-12-08 03:57:38 -05:00
} elseif ( $this -> is_post_type_archive ) {
2013-09-09 23:02:10 -04:00
$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 );
2010-02-08 17:05:05 -05:00
} elseif ( $this -> is_posts_page ) {
2010-07-25 03:35:59 -04:00
$page_for_posts = get_option ( 'page_for_posts' );
2012-08-23 16:01:10 -04:00
$this -> queried_object = get_post ( $page_for_posts );
2007-03-22 20:59:21 -04:00
$this -> queried_object_id = ( int ) $this -> queried_object -> ID ;
2014-06-04 19:43:15 -04:00
} elseif ( $this -> is_singular && ! empty ( $this -> post ) ) {
2006-03-12 20:44:32 -05:00
$this -> queried_object = $this -> post ;
2007-03-22 20:59:21 -04:00
$this -> queried_object_id = ( int ) $this -> post -> ID ;
2010-02-08 17:05:05 -05:00
} elseif ( $this -> is_author ) {
2010-11-22 19:47:45 -05:00
$this -> queried_object_id = ( int ) $this -> get ( 'author' );
$this -> queried_object = get_userdata ( $this -> queried_object_id );
2006-03-12 20:44:32 -05:00
}
2010-11-22 19:49:23 -05:00
2006-03-12 20:44:32 -05:00
return $this -> queried_object ;
}
2008-09-04 15:19:32 -04:00
/**
* Retrieve ID of the current queried object .
*
* @ since 1.5 . 0
* @ access public
*
* @ return int
*/
2014-05-19 02:49:16 -04:00
public function get_queried_object_id () {
2006-03-12 20:44:32 -05:00
$this -> get_queried_object ();
2010-05-03 16:19:13 -04:00
if ( isset ( $this -> queried_object_id ) ) {
2006-03-12 20:44:32 -05:00
return $this -> queried_object_id ;
}
return 0 ;
}
2008-09-04 15:19:32 -04:00
/**
2011-04-29 16:05:12 -04:00
* Constructor .
2008-09-04 15:19:32 -04:00
*
* Sets up the WordPress query , if parameter is not empty .
*
* @ since 1.5 . 0
* @ access public
*
2015-01-16 14:03:23 -05:00
* @ param string | array $query URL query string or array of vars .
2008-09-04 15:19:32 -04:00
*/
2014-05-19 02:49:16 -04:00
public function __construct ( $query = '' ) {
2010-05-03 16:19:13 -04:00
if ( ! empty ( $query ) ) {
2006-03-12 20:44:32 -05:00
$this -> query ( $query );
}
}
2010-08-25 14:05:33 -04:00
2014-05-19 02:49:16 -04:00
/**
2014-07-13 19:36:14 -04:00
* Make private properties readable for backwards compatibility .
2014-05-19 02:49:16 -04:00
*
* @ since 4.0 . 0
2014-07-13 19:36:14 -04:00
* @ access public
*
2014-08-09 15:30:17 -04:00
* @ param string $name Property to get .
2014-07-13 19:36:14 -04:00
* @ return mixed Property .
2014-05-19 02:49:16 -04:00
*/
public function __get ( $name ) {
2015-01-11 17:41:24 -05:00
if ( in_array ( $name , $this -> compat_fields ) ) {
return $this -> $name ;
}
2014-05-19 02:49:16 -04:00
}
/**
2015-01-11 17:41:24 -05:00
* Make private properties checkable for backwards compatibility .
2014-05-19 02:49:16 -04:00
*
* @ since 4.0 . 0
2014-07-13 19:36:14 -04:00
* @ access public
*
* @ param string $name Property to check if set .
* @ return bool Whether the property is set .
2014-05-19 02:49:16 -04:00
*/
public function __isset ( $name ) {
2015-01-11 17:41:24 -05:00
if ( in_array ( $name , $this -> compat_fields ) ) {
return isset ( $this -> $name );
}
2014-05-19 02:49:16 -04:00
}
/**
2014-07-13 19:36:14 -04:00
* Make private / protected methods readable for backwards compatibility .
2014-05-19 02:49:16 -04:00
*
* @ since 4.0 . 0
2014-07-13 19:36:14 -04:00
* @ access public
*
* @ param callable $name Method to call .
* @ param array $arguments Arguments to pass when calling .
2015-05-27 14:15:25 -04:00
* @ return mixed | false Return value of the callback , false otherwise .
2014-05-19 02:49:16 -04:00
*/
public function __call ( $name , $arguments ) {
2015-01-11 17:41:24 -05:00
if ( in_array ( $name , $this -> compat_methods ) ) {
return call_user_func_array ( array ( $this , $name ), $arguments );
}
return false ;
2014-05-19 02:49:16 -04:00
}
2010-08-25 14:05:33 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing archive page ?
2010-08-25 14:05:33 -04:00
*
2010-10-23 15:20:47 -04:00
* Month , Year , Category , Author , Post Type archive ...
2010-10-14 06:39:47 -04:00
*
2010-08-25 14:05:33 -04:00
* @ since 3.1 . 0
*
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_archive () {
2010-10-23 15:20:47 -04:00
return ( bool ) $this -> is_archive ;
2010-08-25 14:05:33 -04:00
}
2010-10-15 15:44:57 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing post type archive page ?
2010-10-15 15:44:57 -04:00
*
* @ since 3.1 . 0
*
* @ param mixed $post_types Optional . Post type or array of posts types to check against .
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_post_type_archive ( $post_types = '' ) {
2013-09-06 18:07:09 -04:00
if ( empty ( $post_types ) || ! $this -> is_post_type_archive )
2010-10-15 15:44:57 -04:00
return ( bool ) $this -> is_post_type_archive ;
2013-09-09 23:02:10 -04:00
$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 );
2010-10-15 15:44:57 -04:00
2011-01-24 16:15:50 -05:00
return in_array ( $post_type_object -> name , ( array ) $post_types );
2010-10-15 15:44:57 -04:00
}
2010-08-25 14:05:33 -04:00
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing attachment page ?
2010-08-25 14:05:33 -04:00
*
* @ since 3.1 . 0
2014-01-22 17:35:12 -05:00
*
2014-01-22 17:34:12 -05:00
* @ param mixed $attachment Attachment ID , title , slug , or array of such .
2010-08-25 14:05:33 -04:00
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_attachment ( $attachment = '' ) {
2014-01-22 17:31:12 -05:00
if ( ! $this -> is_attachment ) {
return false ;
}
if ( empty ( $attachment ) ) {
return true ;
}
$attachment = ( array ) $attachment ;
$post_obj = $this -> get_queried_object ();
2015-02-13 21:09:25 -05:00
if ( in_array ( ( string ) $post_obj -> ID , $attachment ) ) {
2014-01-22 17:31:12 -05:00
return true ;
} elseif ( in_array ( $post_obj -> post_title , $attachment ) ) {
return true ;
} elseif ( in_array ( $post_obj -> post_name , $attachment ) ) {
return true ;
}
return false ;
2010-08-25 14:05:33 -04:00
}
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing author archive page ?
2010-08-25 14:05:33 -04:00
*
* 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
*/
2014-05-19 02:49:16 -04:00
public function is_author ( $author = '' ) {
2010-08-25 14:05:33 -04:00
if ( ! $this -> is_author )
return false ;
if ( empty ( $author ) )
return true ;
$author_obj = $this -> get_queried_object ();
$author = ( array ) $author ;
2015-02-13 21:09:25 -05:00
if ( in_array ( ( string ) $author_obj -> ID , $author ) )
2010-08-25 14:05:33 -04:00
return true ;
elseif ( in_array ( $author_obj -> nickname , $author ) )
return true ;
elseif ( in_array ( $author_obj -> user_nicename , $author ) )
return true ;
return false ;
}
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing category archive page ?
2010-08-25 14:05:33 -04:00
*
* 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
*/
2014-05-19 02:49:16 -04:00
public function is_category ( $category = '' ) {
2010-08-25 14:05:33 -04:00
if ( ! $this -> is_category )
return false ;
if ( empty ( $category ) )
return true ;
$cat_obj = $this -> get_queried_object ();
$category = ( array ) $category ;
2015-02-13 21:09:25 -05:00
if ( in_array ( ( string ) $cat_obj -> term_id , $category ) )
2010-08-25 14:05:33 -04:00
return true ;
elseif ( in_array ( $cat_obj -> name , $category ) )
return true ;
elseif ( in_array ( $cat_obj -> slug , $category ) )
return true ;
return false ;
}
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing tag archive page ?
2010-08-25 14:05:33 -04:00
*
* 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
*
2013-09-06 13:27:08 -04:00
* @ param mixed $tag Optional . Tag ID , name , slug , or array of Tag IDs , names , and slugs .
2010-08-25 14:05:33 -04:00
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_tag ( $tag = '' ) {
2013-09-06 13:27:08 -04:00
if ( ! $this -> is_tag )
2010-08-25 14:05:33 -04:00
return false ;
2013-09-06 13:27:08 -04:00
if ( empty ( $tag ) )
2010-08-25 14:05:33 -04:00
return true ;
$tag_obj = $this -> get_queried_object ();
2013-09-06 13:27:08 -04:00
$tag = ( array ) $tag ;
2010-08-25 14:05:33 -04:00
2015-02-13 21:09:25 -05:00
if ( in_array ( ( string ) $tag_obj -> term_id , $tag ) )
2013-09-06 13:27:08 -04:00
return true ;
elseif ( in_array ( $tag_obj -> name , $tag ) )
return true ;
elseif ( in_array ( $tag_obj -> slug , $tag ) )
2010-08-25 14:05:33 -04:00
return true ;
return false ;
}
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing taxonomy archive page ?
2010-08-25 14:05:33 -04:00
*
* 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
*
2015-05-27 14:15:25 -04:00
* @ global array $wp_taxonomies
*
2010-08-25 14:05:33 -04:00
* @ param mixed $taxonomy Optional . Taxonomy slug or slugs .
2015-01-10 01:54:23 -05:00
* @ param mixed $term Optional . Term ID , name , slug or array of Term IDs , names , and slugs .
2010-08-25 14:05:33 -04:00
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_tax ( $taxonomy = '' , $term = '' ) {
2010-08-25 14:05:33 -04:00
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 ;
2012-09-13 13:15:13 -04:00
// 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 ;
2010-08-25 14:05:33 -04:00
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
*
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_comments_popup () {
2010-08-25 14:05:33 -04:00
return ( bool ) $this -> is_comments_popup ;
}
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing date archive ?
2010-08-25 14:05:33 -04:00
*
* @ since 3.1 . 0
*
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_date () {
2010-08-25 14:05:33 -04:00
return ( bool ) $this -> is_date ;
}
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing day archive ?
2010-08-25 14:05:33 -04:00
*
* @ since 3.1 . 0
*
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_day () {
2010-08-25 14:05:33 -04:00
return ( bool ) $this -> is_day ;
}
/**
* Is the query for a feed ?
*
* @ since 3.1 . 0
*
2010-11-17 22:19:08 -05:00
* @ param string | array $feeds Optional feed types to check .
2010-08-25 14:05:33 -04:00
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_feed ( $feeds = '' ) {
2010-11-17 22:19:08 -05:00
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 );
2010-08-25 14:05:33 -04:00
}
/**
* Is the query for a comments feed ?
*
* @ since 3.1 . 0
*
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_comment_feed () {
2010-08-25 14:05:33 -04:00
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 .
*/
2014-05-19 02:49:16 -04:00
public function is_front_page () {
2010-08-25 14:05:33 -04:00
// 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 .
*/
2014-05-19 02:49:16 -04:00
public function is_home () {
2010-08-25 14:05:33 -04:00
return ( bool ) $this -> is_home ;
}
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing month archive ?
2010-08-25 14:05:33 -04:00
*
* @ since 3.1 . 0
*
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_month () {
2010-08-25 14:05:33 -04:00
return ( bool ) $this -> is_month ;
}
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing single page ?
2010-08-25 14:05:33 -04:00
*
* If the $page parameter is specified , this function will additionally
2010-12-09 00:27:37 -05:00
* check if the query is for one of the pages specified .
2010-08-25 14:05:33 -04:00
*
* @ see WP_Query :: is_single ()
* @ see WP_Query :: is_singular ()
*
* @ since 3.1 . 0
*
2014-07-09 12:04:16 -04:00
* @ param mixed $page Page ID , title , slug , path , or array of such .
2010-08-25 14:05:33 -04:00
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_page ( $page = '' ) {
2010-08-25 14:05:33 -04:00
if ( ! $this -> is_page )
return false ;
if ( empty ( $page ) )
return true ;
$page_obj = $this -> get_queried_object ();
$page = ( array ) $page ;
2015-02-13 21:09:25 -05:00
if ( in_array ( ( string ) $page_obj -> ID , $page ) ) {
2010-08-25 14:05:33 -04:00
return true ;
2014-07-09 12:04:16 -04:00
} elseif ( in_array ( $page_obj -> post_title , $page ) ) {
2010-08-25 14:05:33 -04:00
return true ;
2015-01-08 02:05:25 -05:00
} elseif ( in_array ( $page_obj -> post_name , $page ) ) {
2010-08-25 14:05:33 -04:00
return true ;
2014-07-09 12:04:16 -04:00
} 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 ;
}
}
}
2010-08-25 14:05:33 -04:00
return false ;
}
/**
* Is the query for paged result and not for the first page ?
*
* @ since 3.1 . 0
*
2010-10-04 13:51:17 -04:00
* @ return bool
2010-08-25 14:05:33 -04:00
*/
2014-05-19 02:49:16 -04:00
public function is_paged () {
2010-08-25 14:05:33 -04:00
return ( bool ) $this -> is_paged ;
}
/**
* Is the query for a post or page preview ?
*
* @ since 3.1 . 0
*
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_preview () {
2010-08-25 14:05:33 -04:00
return ( bool ) $this -> is_preview ;
}
/**
* Is the query for the robots file ?
*
* @ since 3.1 . 0
*
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_robots () {
2010-08-25 14:05:33 -04:00
return ( bool ) $this -> is_robots ;
}
/**
* Is the query for a search ?
*
* @ since 3.1 . 0
*
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_search () {
2010-08-25 14:05:33 -04:00
return ( bool ) $this -> is_search ;
}
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing single post ?
2010-08-25 14:05:33 -04:00
*
2010-12-09 00:27:37 -05:00
* Works for any post type , except attachments and pages
*
2010-08-25 14:05:33 -04:00
* 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
*
2014-07-09 12:04:16 -04:00
* @ param mixed $post Post ID , title , slug , path , or array of such .
2010-08-25 14:05:33 -04:00
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_single ( $post = '' ) {
2010-08-25 14:05:33 -04:00
if ( ! $this -> is_single )
return false ;
if ( empty ( $post ) )
return true ;
$post_obj = $this -> get_queried_object ();
$post = ( array ) $post ;
2015-02-13 21:09:25 -05:00
if ( in_array ( ( string ) $post_obj -> ID , $post ) ) {
2010-08-25 14:05:33 -04:00
return true ;
2014-07-09 12:04:16 -04:00
} elseif ( in_array ( $post_obj -> post_title , $post ) ) {
2010-08-25 14:05:33 -04:00
return true ;
2014-07-09 12:04:16 -04:00
} elseif ( in_array ( $post_obj -> post_name , $post ) ) {
2010-08-25 14:05:33 -04:00
return true ;
2014-07-09 12:04:16 -04:00
} else {
foreach ( $post as $postpath ) {
if ( ! strpos ( $postpath , '/' ) ) {
continue ;
}
$postpath_obj = get_page_by_path ( $postpath , OBJECT , $post_obj -> post_type );
2010-08-25 14:05:33 -04:00
2014-07-09 12:04:16 -04:00
if ( $postpath_obj && ( $postpath_obj -> ID == $post_obj -> ID ) ) {
return true ;
}
}
}
2010-08-25 14:05:33 -04:00
return false ;
}
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing single post of any post type ( post , attachment , page , ... ) ?
2010-08-25 14:05:33 -04:00
*
* 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 mixed $post_types Optional . Post Type or array of Post Types
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_singular ( $post_types = '' ) {
2010-08-25 14:05:33 -04:00
if ( empty ( $post_types ) || ! $this -> is_singular )
2010-10-14 06:39:47 -04:00
return ( bool ) $this -> is_singular ;
2010-08-25 14:05:33 -04:00
$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
*/
2014-05-19 02:49:16 -04:00
public function is_time () {
2010-08-25 14:05:33 -04:00
return ( bool ) $this -> is_time ;
}
/**
* Is the query for a trackback endpoint call ?
*
* @ since 3.1 . 0
*
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_trackback () {
2010-08-25 14:05:33 -04:00
return ( bool ) $this -> is_trackback ;
}
/**
2012-09-18 13:35:11 -04:00
* Is the query for an existing year archive ?
2010-08-25 14:05:33 -04:00
*
* @ since 3.1 . 0
*
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_year () {
2010-08-25 14:05:33 -04:00
return ( bool ) $this -> is_year ;
}
/**
* Is the query a 404 ( returns no results ) ?
*
* @ since 3.1 . 0
*
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_404 () {
2010-08-25 14:05:33 -04:00
return ( bool ) $this -> is_404 ;
}
2011-09-17 16:46:35 -04:00
/**
* Is the query the main query ?
*
* @ since 3.3 . 0
*
2015-05-27 14:15:25 -04:00
* @ global WP_Query $wp_query
*
2011-09-17 16:46:35 -04:00
* @ return bool
*/
2014-05-19 02:49:16 -04:00
public function is_main_query () {
2011-09-17 16:46:35 -04:00
global $wp_the_query ;
return $wp_the_query === $this ;
}
2013-09-24 11:53:09 -04:00
2014-10-28 22:32:24 -04:00
/**
* Set up global post data .
*
* @ since 4.1 . 0
*
2015-05-27 14:15:25 -04:00
* @ 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
*
2014-11-30 17:56:25 -05:00
* @ param WP_Post $post Post data .
2015-05-27 14:15:25 -04:00
* @ return true True when finished .
2014-10-28 22:32:24 -04:00
*/
public function setup_postdata ( $post ) {
global $id , $authordata , $currentday , $currentmonth , $page , $pages , $multipage , $more , $numpages ;
$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 ;
2014-11-28 07:18:22 -05:00
/*
* Force full post content when viewing the permalink for the $post ,
* or when on an RSS feed . Otherwise respect the 'more' tag .
*/
2014-10-28 22:32:24 -04:00
if ( $post -> ID === get_queried_object_id () && ( $this -> is_page () || $this -> is_single () ) ) {
$more = 1 ;
2015-01-08 02:05:25 -05:00
} elseif ( $this -> is_feed () ) {
2014-10-28 22:32:24 -04:00
$more = 1 ;
} else {
$more = 0 ;
}
$content = $post -> post_content ;
if ( false !== strpos ( $content , '<!--nextpage-->' ) ) {
if ( $page > 1 )
$more = 1 ;
$content = str_replace ( " \n <!--nextpage--> \n " , '<!--nextpage-->' , $content );
$content = str_replace ( " \n <!--nextpage--> " , '<!--nextpage-->' , $content );
$content = str_replace ( " <!--nextpage--> \n " , '<!--nextpage-->' , $content );
2014-11-28 07:18:22 -05:00
2014-10-28 22:32:24 -04:00
// Ignore nextpage at the beginning of the content.
if ( 0 === strpos ( $content , '<!--nextpage-->' ) )
$content = substr ( $content , 15 );
2014-11-28 07:18:22 -05:00
2014-10-28 22:32:24 -04:00
$pages = explode ( '<!--nextpage-->' , $content );
$numpages = count ( $pages );
if ( $numpages > 1 )
$multipage = 1 ;
} else {
$pages = array ( $post -> post_content );
}
/**
* Fires once the post data has been setup .
*
* @ since 2.8 . 0
2014-11-28 07:18:22 -05:00
* @ since 4.1 . 0 Introduced `$this` parameter .
2014-10-28 22:32:24 -04:00
*
2014-11-12 21:25:22 -05:00
* @ param WP_Post & $post The Post object ( passed by reference ) .
* @ param WP_Query & $this The current Query object ( passed by reference ) .
2014-10-28 22:32:24 -04:00
*/
2014-11-12 21:25:22 -05:00
do_action_ref_array ( 'the_post' , array ( & $post , & $this ) );
2014-10-28 22:32:24 -04:00
return true ;
}
2013-09-24 11:53:09 -04:00
/**
* After looping through a nested query , this function
* restores the $post global to the current post in this query .
*
* @ since 3.7 . 0
2015-05-27 14:15:25 -04:00
*
* @ global WP_Post $post
2013-09-24 11:53:09 -04:00
*/
2014-05-19 02:49:16 -04:00
public function reset_postdata () {
2013-09-24 11:53:09 -04:00
if ( ! empty ( $this -> post ) ) {
$GLOBALS [ 'post' ] = $this -> post ;
setup_postdata ( $this -> post );
}
}
2006-03-12 20:44:32 -05:00
}
2008-09-04 15:19:32 -04:00
/**
* Redirect old slugs to the correct permalink .
*
* Attempts to find the current slug from the past slugs .
*
* @ since 2.1 . 0
2014-10-31 13:56:22 -04:00
*
2015-05-27 14:15:25 -04:00
* @ global WP_Query $wp_query
* @ global wpdb $wpdb WordPress database abstraction object .
2008-09-04 15:19:32 -04:00
*/
2010-03-20 22:52:00 -04:00
function wp_old_slug_redirect () {
2006-11-30 03:48:56 -05:00
global $wp_query ;
if ( is_404 () && '' != $wp_query -> query_vars [ 'name' ] ) :
global $wpdb ;
2010-10-19 06:27:34 -04:00
// Guess the current post_type based on the query vars.
if ( get_query_var ( 'post_type' ) )
$post_type = get_query_var ( 'post_type' );
elseif ( ! empty ( $wp_query -> query_vars [ 'pagename' ]) )
$post_type = 'page' ;
else
$post_type = 'post' ;
2011-06-23 12:35:34 -04:00
if ( is_array ( $post_type ) ) {
if ( count ( $post_type ) > 1 )
return ;
2015-03-18 23:56:27 -04:00
$post_type = reset ( $post_type );
2011-06-23 12:35:34 -04:00
}
2010-12-08 16:10:38 -05:00
// Do not attempt redirect for hierarchical post types
2010-12-08 16:17:01 -05:00
if ( is_post_type_hierarchical ( $post_type ) )
2010-12-08 16:10:38 -05:00
return ;
2010-10-19 06:27:34 -04:00
$query = $wpdb -> prepare ( " SELECT post_id FROM $wpdb->postmeta , $wpdb->posts WHERE ID = post_id AND post_type = %s AND meta_key = '_wp_old_slug' AND meta_value = %s " , $post_type , $wp_query -> query_vars [ 'name' ]);
2006-11-30 03:48:56 -05:00
// if year, monthnum, or day have been specified, make our query more precise
// just in case there are multiple identical _wp_old_slug values
if ( '' != $wp_query -> query_vars [ 'year' ] )
2010-10-18 07:44:19 -04:00
$query .= $wpdb -> prepare ( " AND YEAR(post_date) = %d " , $wp_query -> query_vars [ 'year' ]);
2006-11-30 03:48:56 -05:00
if ( '' != $wp_query -> query_vars [ 'monthnum' ] )
2010-10-18 07:44:19 -04:00
$query .= $wpdb -> prepare ( " AND MONTH(post_date) = %d " , $wp_query -> query_vars [ 'monthnum' ]);
2006-11-30 03:48:56 -05:00
if ( '' != $wp_query -> query_vars [ 'day' ] )
2010-10-18 07:44:19 -04:00
$query .= $wpdb -> prepare ( " AND DAYOFMONTH(post_date) = %d " , $wp_query -> query_vars [ 'day' ]);
2006-11-30 03:48:56 -05:00
$id = ( int ) $wpdb -> get_var ( $query );
2010-10-18 07:44:19 -04:00
if ( ! $id )
2006-11-30 03:48:56 -05:00
return ;
$link = get_permalink ( $id );
if ( ! $link )
return ;
2011-05-05 13:33:19 -04:00
wp_redirect ( $link , 301 ); // Permanent redirect
2006-11-30 03:48:56 -05:00
exit ;
endif ;
}
2008-09-04 15:19:32 -04:00
/**
2010-03-17 00:39:50 -04:00
* Set up global post data .
2008-09-04 15:19:32 -04:00
*
* @ since 1.5 . 0
*
2015-05-27 14:15:25 -04:00
* @ global WP_Query $wp_query
*
2008-09-04 15:19:32 -04:00
* @ param object $post Post data .
* @ return bool True when finished .
*/
2013-05-20 07:05:50 -04:00
function setup_postdata ( $post ) {
2014-10-28 22:32:24 -04:00
global $wp_query ;
2006-06-07 22:22:16 -04:00
2014-10-28 22:32:24 -04:00
if ( ! empty ( $wp_query ) && $wp_query instanceof WP_Query ) {
return $wp_query -> setup_postdata ( $post );
Remove wp_parse_post_content(), get_paged_content(), paginate_content() from 3.6, and remove the new $id parameters for get_the_content() and the_content().
The content parsing functions are good abstractions, but are no longer needed by core and are too closely tied to legacy globals, rather than paving a new path.
For get_the_content() and the_content(), this only worsens the function prototype. It muddies theme-specific display (more links, etc) with filtered content. `apply_filters( 'the_content', $post->post_content )` is sufficient practice for now.
see #24330, [24301]. see #23625, [23804].
git-svn-id: http://core.svn.wordpress.org/trunk@24598 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2013-07-09 01:22:50 -04:00
}
2009-05-26 19:57:01 -04:00
2014-10-28 22:32:24 -04:00
return false ;
2006-06-07 22:22:16 -04:00
}