/**
* Prepare the query variables.
*
* @since 0.0.1
* @access public
*
* @global hqdb $hqdb
* @global int $blog_id
*
* @param string|array $query {
* Optional. Array or string of Query parameters.
*
* @type int $blog_id The site ID. Default is the global blog id.
* @type string $role Role name. Default empty.
* @type string $meta_key User meta key. Default empty.
* @type string $meta_value User meta value. Default empty.
* @type string $meta_compare Comparison operator to test the `$meta_value`. Accepts '=', '!=',
* '>', '>=', '<', '<=', 'LIKE', 'NOT LIKE', 'IN', 'NOT IN',
* 'BETWEEN', 'NOT BETWEEN', 'EXISTS', 'NOT EXISTS', 'REGEXP',
* 'NOT REGEXP', or 'RLIKE'. Default '='.
* @type array $include An array of user IDs to include. Default empty array.
* @type array $exclude An array of user IDs to exclude. Default empty array.
* @type string $search Search keyword. Searches for possible string matches on columns.
* When `$search_columns` is left empty, it tries to determine which
* column to search in based on search string. Default empty.
* @type array $search_columns Array of column names to be searched. Accepts 'ID', 'login',
* 'nicename', 'email', 'url'. Default empty array.
* @type string|array $orderby Field(s) to sort the retrieved users by. May be a single value,
* an array of values, or a multi-dimensional array with fields as
* keys and orders ('ASC' or 'DESC') as values. Accepted values are
* 'ID', 'display_name' (or 'name'), 'user_login' (or 'login'),
* 'user_nicename' (or 'nicename'), 'user_email' (or 'email'),
* 'user_url' (or 'url'), 'user_registered' (or 'registered'),
* 'post_count', 'meta_value', 'meta_value_num', the value of
* `$meta_key`, or an array key of `$meta_query`. To use
* 'meta_value' or 'meta_value_num', `$meta_key` must be also be
* defined. Default 'user_login'.
* @type string $order Designates ascending or descending order of users. Order values
* passed as part of an `$orderby` array take precedence over this
* parameter. Accepts 'ASC', 'DESC'. Default 'ASC'.
* @type int $offset Number of users to offset in retrieved results. Can be used in
* conjunction with pagination. Default 0.
* @type int $number Number of users to limit the query for. Can be used in
* conjunction with pagination. Value -1 (all) is not supported.
* Default empty (all users).
* @type bool $count_total Whether to count the total number of users found. If pagination
* is not needed, setting this to false can improve performance.
* Default true.
* @type string|array $fields Which fields to return. Single or all fields (string), or array
* of fields. Accepts 'ID', 'display_name', 'login', 'nicename',
* 'email', 'url', 'registered'. Use 'all' for all fields and
* 'all_with_meta' to include meta fields. Default 'all'.
* @type string $who Type of users to query. Accepts 'authors'.
* Default empty (all users).
* @type bool|array $has_published_posts Pass an array of post types to filter results to users who have
* published posts in those post types. `true` is an alias for all
* public post types.
* }
*/
public function prepare_query($query = array())
{
global $hqdb;
if (empty($this->query_vars) || !empty($query)) {
$this->query_limit = null;
$this->query_vars = hq_parse_args($query, array('blog_id' => $GLOBALS['blog_id'], 'role' => '', 'meta_key' => '', 'meta_value' => '', 'meta_compare' => '', 'include' => array(), 'exclude' => array(), 'search' => '', 'search_columns' => array(), 'orderby' => 'login', 'order' => 'ASC', 'offset' => '', 'number' => '', 'count_total' => true, 'fields' => 'all', 'who' => '', 'has_published_posts' => null));
}
/**
* Fires before the HQ_User_Query has been parsed.
*
* The passed HQ_User_Query object contains the query variables, not
* yet passed into SQL.
*
* @since 0.0.1
*
* @param HQ_User_Query $this The current HQ_User_Query instance,
* passed by reference.
*/
do_action('pre_get_users', $this);
$qv =& $this->query_vars;
if (is_array($qv['fields'])) {
$qv['fields'] = array_unique($qv['fields']);
$this->query_fields = array();
foreach ($qv['fields'] as $field) {
$field = 'ID' === $field ? 'ID' : sanitize_key($field);
$this->query_fields[] = "{$hqdb->users}.{$field}";
}
$this->query_fields = implode(',', $this->query_fields);
} elseif ('all' == $qv['fields']) {
$this->query_fields = "{$hqdb->users}.*";
} else {
$this->query_fields = "{$hqdb->users}.ID";
}
if (isset($qv['count_total']) && $qv['count_total']) {
$this->query_fields = 'SQL_CALC_FOUND_ROWS ' . $this->query_fields;
}
$this->query_from = "FROM {$hqdb->users}";
$this->query_where = "WHERE 1=1";
// Parse and sanitize 'include', for use by 'orderby' as well as 'include' below.
if (!empty($qv['include'])) {
$include = hq_parse_id_list($qv['include']);
} else {
$include = false;
}
$blog_id = 0;
if (isset($qv['blog_id'])) {
$blog_id = absint($qv['blog_id']);
}
if (isset($qv['who']) && 'authors' == $qv['who'] && $blog_id) {
$qv['meta_key'] = $hqdb->get_blog_prefix($blog_id) . 'user_level';
$qv['meta_value'] = 0;
$qv['meta_compare'] = '!=';
$qv['blog_id'] = $blog_id = 0;
// Prevent extra meta query
}
if ($qv['has_published_posts'] && $blog_id) {
if (true === $qv['has_published_posts']) {
$post_types = get_post_types(array('public' => true));
} else {
$post_types = (array) $qv['has_published_posts'];
}
foreach ($post_types as &$post_type) {
$post_type = $hqdb->prepare('%s', $post_type);
}
$posts_table = $hqdb->get_blog_prefix($blog_id) . 'posts';
$this->query_where .= " AND {$hqdb->users}.ID IN ( SELECT DISTINCT {$posts_table}.post_author FROM {$posts_table} WHERE {$posts_table}.post_status = 'publish' AND {$posts_table}.post_type IN ( " . join(", ", $post_types) . " ) )";
}
// Meta query.
$this->meta_query = new HQ_Meta_Query();
$this->meta_query->parse_query_vars($qv);
$role = '';
if (isset($qv['role'])) {
$role = trim($qv['role']);
}
if ($blog_id && ($role || is_multisite())) {
$cap_meta_query = array();
$cap_meta_query['key'] = $hqdb->get_blog_prefix($blog_id) . 'capabilities';
if ($role) {
$cap_meta_query['value'] = '"' . $role . '"';
$cap_meta_query['compare'] = 'like';
}
if (empty($this->meta_query->queries)) {
$this->meta_query->queries = array($cap_meta_query);
} elseif (!in_array($cap_meta_query, $this->meta_query->queries, true)) {
// Append the cap query to the original queries and reparse the query.
$this->meta_query->queries = array('relation' => 'AND', array($this->meta_query->queries, $cap_meta_query));
}
$this->meta_query->parse_query_vars($this->meta_query->queries);
}
if (!empty($this->meta_query->queries)) {
$clauses = $this->meta_query->get_sql('user', $hqdb->users, 'ID', $this);
$this->query_from .= $clauses['join'];
$this->query_where .= $clauses['where'];
if ($this->meta_query->has_or_relation()) {
$this->query_fields = 'DISTINCT ' . $this->query_fields;
}
}
// sorting
$qv['order'] = isset($qv['order']) ? strtoupper($qv['order']) : '';
$order = $this->parse_order($qv['order']);
if (empty($qv['orderby'])) {
// Default order is by 'user_login'.
$ordersby = array('user_login' => $order);
} elseif (is_array($qv['orderby'])) {
$ordersby = $qv['orderby'];
} else {
// 'orderby' values may be a comma- or space-separated list.
$ordersby = preg_split('/[,\\s]+/', $qv['orderby']);
}
$orderby_array = array();
foreach ($ordersby as $_key => $_value) {
if (!$_value) {
continue;
}
if (is_int($_key)) {
// Integer key means this is a flat array of 'orderby' fields.
$_orderby = $_value;
$_order = $order;
} else {
// Non-integer key means this the key is the field and the value is ASC/DESC.
$_orderby = $_key;
$_order = $_value;
}
$parsed = $this->parse_orderby($_orderby);
if (!$parsed) {
continue;
}
$orderby_array[] = $parsed . ' ' . $this->parse_order($_order);
}
// If no valid clauses were found, order by user_login.
if (empty($orderby_array)) {
$orderby_array[] = "user_login {$order}";
}
$this->query_orderby = 'ORDER BY ' . implode(', ', $orderby_array);
// limit
if (isset($qv['number']) && $qv['number']) {
if ($qv['offset']) {
$this->query_limit = $hqdb->prepare("LIMIT %d, %d", $qv['offset'], $qv['number']);
} else {
$this->query_limit = $hqdb->prepare("LIMIT %d", $qv['number']);
}
}
$search = '';
if (isset($qv['search'])) {
$search = trim($qv['search']);
}
if ($search) {
$leading_wild = ltrim($search, '*') != $search;
$trailing_wild = rtrim($search, '*') != $search;
if ($leading_wild && $trailing_wild) {
$wild = 'both';
} elseif ($leading_wild) {
$wild = 'leading';
} elseif ($trailing_wild) {
$wild = 'trailing';
} else {
$wild = false;
}
if ($wild) {
$search = trim($search, '*');
}
$search_columns = array();
if ($qv['search_columns']) {
$search_columns = array_intersect($qv['search_columns'], array('ID', 'user_login', 'user_email', 'user_url', 'user_nicename'));
}
if (!$search_columns) {
if (false !== strpos($search, '@')) {
$search_columns = array('user_email');
} elseif (is_numeric($search)) {
$search_columns = array('user_login', 'ID');
} elseif (preg_match('|^https?://|', $search) && !(is_multisite() && hq_is_large_network('users'))) {
$search_columns = array('user_url');
} else {
$search_columns = array('user_login', 'user_url', 'user_email', 'user_nicename', 'display_name');
}
}
/**
* Filter the columns to search in a HQ_User_Query search.
*
* The default columns depend on the search term, and include 'user_email',
* 'user_login', 'ID', 'user_url', 'display_name', and 'user_nicename'.
*
* @since 0.0.1
*
* @param array $search_columns Array of column names to be searched.
* @param string $search Text being searched.
* @param HQ_User_Query $this The current HQ_User_Query instance.
*/
$search_columns = apply_filters('user_search_columns', $search_columns, $search, $this);
$this->query_where .= $this->get_search_sql($search, $search_columns, $wild);
}
if (!empty($include)) {
// Sanitized earlier.
$ids = implode(',', $include);
$this->query_where .= " AND {$hqdb->users}.ID IN ({$ids})";
} elseif (!empty($qv['exclude'])) {
$ids = implode(',', hq_parse_id_list($qv['exclude']));
$this->query_where .= " AND {$hqdb->users}.ID NOT IN ({$ids})";
}
// Date queries are allowed for the user_registered field.
if (!empty($qv['date_query']) && is_array($qv['date_query'])) {
$date_query = new HQ_Date_Query($qv['date_query'], 'user_registered');
$this->query_where .= $date_query->get_sql();
}
/**
* Fires after the HQ_User_Query has been parsed, and before
* the query is executed.
*
* The passed HQ_User_Query object contains SQL parts formed
* from parsing the given query.
*
* @since 0.0.1
*
* @param HQ_User_Query $this The current HQ_User_Query instance,
* passed by reference.
*/
do_action_ref_array('pre_user_query', array(&$this));
}
/**
* Get a list of comments matching the query vars.
*
* @since 0.0.1
* @access public
*
* @global hqdb $hqdb HiveQueen database abstraction object.
*
* @return int|array The list of comments.
*/
public function get_comments()
{
global $hqdb;
$groupby = '';
$this->parse_query();
// Parse meta query
$this->meta_query = new HQ_Meta_Query();
$this->meta_query->parse_query_vars($this->query_vars);
/**
* Fires before comments are retrieved.
*
* @since 0.0.1
*
* @param HQ_Comment_Query &$this Current instance of HQ_Comment_Query, passed by reference.
*/
do_action_ref_array('pre_get_comments', array(&$this));
// Reparse query vars, in case they were modified in a 'pre_get_comments' callback.
$this->meta_query->parse_query_vars($this->query_vars);
if (!empty($this->meta_query->queries)) {
$meta_query_clauses = $this->meta_query->get_sql('comment', $hqdb->comments, 'comment_ID', $this);
}
// $args can include anything. Only use the args defined in the query_var_defaults to compute the key.
$key = md5(serialize(hq_array_slice_assoc($this->query_vars, array_keys($this->query_var_defaults))));
$last_changed = hq_cache_get('last_changed', 'comment');
if (!$last_changed) {
$last_changed = microtime();
hq_cache_set('last_changed', $last_changed, 'comment');
}
$cache_key = "get_comments:{$key}:{$last_changed}";
if ($cache = hq_cache_get($cache_key, 'comment')) {
$this->comments = $cache;
return $this->comments;
}
$where = array();
// Assemble clauses related to 'comment_approved'.
$approved_clauses = array();
// 'status' accepts an array or a comma-separated string.
$status_clauses = array();
$statuses = $this->query_vars['status'];
if (!is_array($statuses)) {
$statuses = preg_split('/[\\s,]+/', $statuses);
}
// 'any' overrides other statuses.
if (!in_array('any', $statuses)) {
foreach ($statuses as $status) {
switch ($status) {
case 'hold':
$status_clauses[] = "comment_approved = '0'";
break;
case 'approve':
$status_clauses[] = "comment_approved = '1'";
break;
case 'all':
case '':
$status_clauses[] = "( comment_approved = '0' OR comment_approved = '1' )";
break;
default:
$status_clauses[] = $hqdb->prepare("comment_approved = %s", $status);
break;
}
}
if (!empty($status_clauses)) {
$approved_clauses[] = '( ' . implode(' OR ', $status_clauses) . ' )';
}
}
// User IDs or emails whose unapproved comments are included, regardless of $status.
if (!empty($this->query_vars['include_unapproved'])) {
$include_unapproved = $this->query_vars['include_unapproved'];
// Accepts arrays or comma-separated strings.
if (!is_array($include_unapproved)) {
$include_unapproved = preg_split('/[\\s,]+/', $include_unapproved);
}
$unapproved_ids = $unapproved_emails = array();
foreach ($include_unapproved as $unapproved_identifier) {
// Numeric values are assumed to be user ids.
if (is_numeric($unapproved_identifier)) {
$approved_clauses[] = $hqdb->prepare("( user_id = %d AND comment_approved = '0' )", $unapproved_identifier);
// Otherwise we match against email addresses.
} else {
$approved_clauses[] = $hqdb->prepare("( comment_author_email = %s AND comment_approved = '0' )", $unapproved_identifier);
}
}
}
// Collapse comment_approved clauses into a single OR-separated clause.
if (!empty($approved_clauses)) {
if (1 === count($approved_clauses)) {
$where[] = $approved_clauses[0];
} else {
$where[] = '( ' . implode(' OR ', $approved_clauses) . ' )';
}
}
$order = 'ASC' == strtoupper($this->query_vars['order']) ? 'ASC' : 'DESC';
// Disable ORDER BY with 'none', an empty array, or boolean false.
if (in_array($this->query_vars['orderby'], array('none', array(), false), true)) {
$orderby = '';
} elseif (!empty($this->query_vars['orderby'])) {
$ordersby = is_array($this->query_vars['orderby']) ? $this->query_vars['orderby'] : preg_split('/[,\\s]/', $this->query_vars['orderby']);
$orderby_array = array();
$found_orderby_comment_ID = false;
foreach ($ordersby as $_key => $_value) {
if (!$_value) {
continue;
}
if (is_int($_key)) {
$_orderby = $_value;
$_order = $order;
} else {
$_orderby = $_key;
$_order = $_value;
}
if (!$found_orderby_comment_ID && 'comment_ID' === $_orderby) {
$found_orderby_comment_ID = true;
}
$parsed = $this->parse_orderby($_orderby);
if (!$parsed) {
continue;
}
$orderby_array[] = $parsed . ' ' . $this->parse_order($_order);
}
// If no valid clauses were found, order by comment_date_gmt.
if (empty($orderby_array)) {
$orderby_array[] = "{$hqdb->comments}.comment_date_gmt {$order}";
}
// To ensure determinate sorting, always include a comment_ID clause.
if (!$found_orderby_comment_ID) {
$comment_ID_order = '';
// Inherit order from comment_date or comment_date_gmt, if available.
foreach ($orderby_array as $orderby_clause) {
if (preg_match('/comment_date(?:_gmt)*\\ (ASC|DESC)/', $orderby_clause, $match)) {
$comment_ID_order = $match[1];
break;
}
}
// If no date-related order is available, use the date from the first available clause.
if (!$comment_ID_order) {
foreach ($orderby_array as $orderby_clause) {
if (false !== strpos('ASC', $orderby_clause)) {
$comment_ID_order = 'ASC';
} else {
$comment_ID_order = 'DESC';
}
break;
}
}
// Default to DESC.
if (!$comment_ID_order) {
$comment_ID_order = 'DESC';
}
$orderby_array[] = "{$hqdb->comments}.comment_ID {$comment_ID_order}";
}
$orderby = implode(', ', $orderby_array);
} else {
$orderby = "{$hqdb->comments}.comment_date_gmt {$order}";
}
$number = absint($this->query_vars['number']);
$offset = absint($this->query_vars['offset']);
if (!empty($number)) {
if ($offset) {
$limits = 'LIMIT ' . $offset . ',' . $number;
} else {
$limits = 'LIMIT ' . $number;
}
} else {
$limits = '';
}
if ($this->query_vars['count']) {
$fields = 'COUNT(*)';
} else {
switch (strtolower($this->query_vars['fields'])) {
case 'ids':
$fields = "{$hqdb->comments}.comment_ID";
break;
default:
$fields = "*";
break;
}
}
$join = '';
$post_id = absint($this->query_vars['post_id']);
if (!empty($post_id)) {
$where[] = $hqdb->prepare('comment_post_ID = %d', $post_id);
}
// Parse comment IDs for an IN clause.
if (!empty($this->query_vars['comment__in'])) {
$where[] = "{$hqdb->comments}.comment_ID IN ( " . implode(',', hq_parse_id_list($this->query_vars['comment__in'])) . ' )';
}
// Parse comment IDs for a NOT IN clause.
if (!empty($this->query_vars['comment__not_in'])) {
$where[] = "{$hqdb->comments}.comment_ID NOT IN ( " . implode(',', hq_parse_id_list($this->query_vars['comment__not_in'])) . ' )';
}
// Parse comment post IDs for an IN clause.
if (!empty($this->query_vars['post__in'])) {
$where[] = 'comment_post_ID IN ( ' . implode(',', hq_parse_id_list($this->query_vars['post__in'])) . ' )';
}
// Parse comment post IDs for a NOT IN clause.
if (!empty($this->query_vars['post__not_in'])) {
$where[] = 'comment_post_ID NOT IN ( ' . implode(',', hq_parse_id_list($this->query_vars['post__not_in'])) . ' )';
}
if ('' !== $this->query_vars['author_email']) {
$where[] = $hqdb->prepare('comment_author_email = %s', $this->query_vars['author_email']);
}
if ('' !== $this->query_vars['karma']) {
$where[] = $hqdb->prepare('comment_karma = %d', $this->query_vars['karma']);
}
// Filtering by comment_type: 'type', 'type__in', 'type__not_in'.
$raw_types = array('IN' => array_merge((array) $this->query_vars['type'], (array) $this->query_vars['type__in']), 'NOT IN' => (array) $this->query_vars['type__not_in']);
$comment_types = array();
foreach ($raw_types as $operator => $_raw_types) {
$_raw_types = array_unique($_raw_types);
foreach ($_raw_types as $type) {
switch ($type) {
// An empty translates to 'all', for backward compatibility
case '':
case 'all':
break;
case 'comment':
case 'comments':
$comment_types[$operator][] = "''";
break;
case 'pings':
$comment_types[$operator][] = "'pingback'";
$comment_types[$operator][] = "'trackback'";
break;
default:
$comment_types[$operator][] = $hqdb->prepare('%s', $type);
break;
}
}
if (!empty($comment_types[$operator])) {
$types_sql = implode(', ', $comment_types[$operator]);
$where[] = "comment_type {$operator} ({$types_sql})";
}
}
if ('' !== $this->query_vars['parent']) {
$where[] = $hqdb->prepare('comment_parent = %d', $this->query_vars['parent']);
}
if (is_array($this->query_vars['user_id'])) {
$where[] = 'user_id IN (' . implode(',', array_map('absint', $this->query_vars['user_id'])) . ')';
} elseif ('' !== $this->query_vars['user_id']) {
$where[] = $hqdb->prepare('user_id = %d', $this->query_vars['user_id']);
}
if ('' !== $this->query_vars['search']) {
$search_sql = $this->get_search_sql($this->query_vars['search'], array('comment_author', 'comment_author_email', 'comment_author_url', 'comment_author_IP', 'comment_content'));
// Strip leading 'AND'.
$where[] = preg_replace('/^\\s*AND\\s*/', '', $search_sql);
}
// If any post-related query vars are passed, join the posts table.
$join_posts_table = false;
$plucked = hq_array_slice_assoc($this->query_vars, array('post_author', 'post_name', 'post_parent', 'post_status', 'post_type'));
$post_fields = array_filter($plucked);
if (!empty($post_fields)) {
$join_posts_table = true;
foreach ($post_fields as $field_name => $field_value) {
// $field_value may be an array.
$esses = array_fill(0, count((array) $field_value), '%s');
$where[] = $hqdb->prepare(" {$hqdb->posts}.{$field_name} IN (" . implode(',', $esses) . ')', $field_value);
}
}
// Comment author IDs for an IN clause.
if (!empty($this->query_vars['author__in'])) {
$where[] = 'user_id IN ( ' . implode(',', hq_parse_id_list($this->query_vars['author__in'])) . ' )';
}
// Comment author IDs for a NOT IN clause.
if (!empty($this->query_vars['author__not_in'])) {
$where[] = 'user_id NOT IN ( ' . implode(',', hq_parse_id_list($this->query_vars['author__not_in'])) . ' )';
}
// Post author IDs for an IN clause.
if (!empty($this->query_vars['post_author__in'])) {
$join_posts_table = true;
$where[] = 'post_author IN ( ' . implode(',', hq_parse_id_list($this->query_vars['post_author__in'])) . ' )';
}
// Post author IDs for a NOT IN clause.
if (!empty($this->query_vars['post_author__not_in'])) {
$join_posts_table = true;
$where[] = 'post_author NOT IN ( ' . implode(',', hq_parse_id_list($this->query_vars['post_author__not_in'])) . ' )';
}
if ($join_posts_table) {
$join = "JOIN {$hqdb->posts} ON {$hqdb->posts}.ID = {$hqdb->comments}.comment_post_ID";
}
if (!empty($meta_query_clauses)) {
$join .= $meta_query_clauses['join'];
// Strip leading 'AND'.
$where[] = preg_replace('/^\\s*AND\\s*/', '', $meta_query_clauses['where']);
if (!$this->query_vars['count']) {
$groupby = "{$hqdb->comments}.comment_ID";
}
}
$date_query = $this->query_vars['date_query'];
if (!empty($date_query) && is_array($date_query)) {
$date_query_object = new HQ_Date_Query($date_query, 'comment_date');
$where[] = preg_replace('/^\\s*AND\\s*/', '', $date_query_object->get_sql());
}
$where = implode(' AND ', $where);
$pieces = array('fields', 'join', 'where', 'orderby', 'limits', 'groupby');
/**
* Filter the comment query clauses.
*
* @since 0.0.1
*
* @param array $pieces A compacted array of comment query clauses.
* @param HQ_Comment_Query &$this Current instance of HQ_Comment_Query, passed by reference.
*/
$clauses = apply_filters_ref_array('comments_clauses', array(compact($pieces), &$this));
$fields = isset($clauses['fields']) ? $clauses['fields'] : '';
$join = isset($clauses['join']) ? $clauses['join'] : '';
$where = isset($clauses['where']) ? $clauses['where'] : '';
$orderby = isset($clauses['orderby']) ? $clauses['orderby'] : '';
$limits = isset($clauses['limits']) ? $clauses['limits'] : '';
$groupby = isset($clauses['groupby']) ? $clauses['groupby'] : '';
if ($where) {
$where = 'WHERE ' . $where;
}
if ($groupby) {
$groupby = 'GROUP BY ' . $groupby;
}
if ($orderby) {
$orderby = "ORDER BY {$orderby}";
}
$this->request = "SELECT {$fields} FROM {$hqdb->comments} {$join} {$where} {$groupby} {$orderby} {$limits}";
if ($this->query_vars['count']) {
return $hqdb->get_var($this->request);
}
if ('ids' == $this->query_vars['fields']) {
$this->comments = $hqdb->get_col($this->request);
return array_map('intval', $this->comments);
}
$results = $hqdb->get_results($this->request);
/**
* Filter the comment query results.
*
* @since 0.0.1
*
* @param array $results An array of comments.
* @param HQ_Comment_Query &$this Current instance of HQ_Comment_Query, passed by reference.
*/
$comments = apply_filters_ref_array('the_comments', array($results, &$this));
hq_cache_add($cache_key, $comments, 'comment');
if ('*' === $fields) {
update_comment_cache($comments);
}
$this->comments = $comments;
return $this->comments;
}
/**
* 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 0.0.1
* @access public
*
* @global hqdb $hqdb
*
* @return array List of posts.
*/
public function get_posts()
{
global $hqdb;
//Goyo: Debug
//print("get_posts: Begin");
$this->parse_query();
/**
* Fires after the query variable object is created, but before the actual query is run.
*
* Note: If using conditional tags, use the method versions within the passed instance
* (e.g. $this->is_main_query() instead of is_main_query()). This is because the functions
* like is_main_query() test against the global $hq_query instance, not the passed one.
*
* @since 0.0.1
*
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
do_action_ref_array('pre_get_posts', array(&$this));
// Shorthand.
$q =& $this->query_vars;
// Fill again in case pre_get_posts unset some vars.
$q = $this->fill_query_vars($q);
// Parse meta query
$this->meta_query = new HQ_Meta_Query();
$this->meta_query->parse_query_vars($q);
// Set a flag if a pre_get_posts hook changed the query vars.
$hash = md5(serialize($this->query_vars));
if ($hash != $this->query_vars_hash) {
$this->query_vars_changed = true;
$this->query_vars_hash = $hash;
}
unset($hash);
// First let's clear some variables
$distinct = '';
$whichauthor = '';
$whichmimetype = '';
$where = '';
$limits = '';
$join = '';
$search = '';
$groupby = '';
$post_status_join = false;
$page = 1;
if (isset($q['caller_get_posts'])) {
_deprecated_argument('HQ_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;
}
if (!isset($q['suppress_filters'])) {
$q['suppress_filters'] = false;
}
if (!isset($q['cache_results'])) {
if (hq_using_ext_object_cache()) {
$q['cache_results'] = false;
} else {
$q['cache_results'] = true;
}
}
if (!isset($q['update_post_term_cache'])) {
$q['update_post_term_cache'] = true;
}
if (!isset($q['update_post_meta_cache'])) {
$q['update_post_meta_cache'] = true;
}
if (!isset($q['post_type'])) {
if ($this->is_search) {
$q['post_type'] = 'any';
} else {
$q['post_type'] = '';
}
}
$post_type = $q['post_type'];
if (empty($q['posts_per_page'])) {
$q['posts_per_page'] = get_option('posts_per_page');
}
if (isset($q['showposts']) && $q['showposts']) {
$q['showposts'] = (int) $q['showposts'];
$q['posts_per_page'] = $q['showposts'];
}
if (isset($q['posts_per_archive_page']) && $q['posts_per_archive_page'] != 0 && ($this->is_archive || $this->is_search)) {
$q['posts_per_page'] = $q['posts_per_archive_page'];
}
if (!isset($q['nopaging'])) {
if ($q['posts_per_page'] == -1) {
$q['nopaging'] = true;
} else {
$q['nopaging'] = false;
}
}
if ($this->is_feed) {
// This overrides posts_per_page.
if (!empty($q['posts_per_rss'])) {
$q['posts_per_page'] = $q['posts_per_rss'];
} else {
$q['posts_per_page'] = get_option('posts_per_rss');
}
$q['nopaging'] = false;
}
$q['posts_per_page'] = (int) $q['posts_per_page'];
if ($q['posts_per_page'] < -1) {
$q['posts_per_page'] = abs($q['posts_per_page']);
} elseif ($q['posts_per_page'] == 0) {
$q['posts_per_page'] = 1;
}
if (!isset($q['comments_per_page']) || $q['comments_per_page'] == 0) {
$q['comments_per_page'] = get_option('comments_per_page');
}
if ($this->is_home && (empty($this->query) || $q['preview'] == 'true') && 'page' == get_option('show_on_front') && get_option('page_on_front')) {
$this->is_page = true;
$this->is_home = false;
$q['page_id'] = get_option('page_on_front');
}
if (isset($q['page'])) {
$q['page'] = trim($q['page'], '/');
$q['page'] = absint($q['page']);
}
// If true, forcibly turns off SQL_CALC_FOUND_ROWS even when limits are present.
if (isset($q['no_found_rows'])) {
$q['no_found_rows'] = (bool) $q['no_found_rows'];
} else {
$q['no_found_rows'] = false;
}
switch ($q['fields']) {
case 'ids':
$fields = "{$hqdb->posts}.ID";
break;
case 'id=>parent':
$fields = "{$hqdb->posts}.ID, {$hqdb->posts}.post_parent";
break;
default:
$fields = "{$hqdb->posts}.*";
}
if ('' !== $q['menu_order']) {
$where .= " AND {$hqdb->posts}.menu_order = " . $q['menu_order'];
}
// The "m" parameter is meant for months but accepts datetimes of varying specificity
if ($q['m']) {
$where .= " AND YEAR({$hqdb->posts}.post_date)=" . substr($q['m'], 0, 4);
if (strlen($q['m']) > 5) {
$where .= " AND MONTH({$hqdb->posts}.post_date)=" . substr($q['m'], 4, 2);
}
if (strlen($q['m']) > 7) {
$where .= " AND DAYOFMONTH({$hqdb->posts}.post_date)=" . substr($q['m'], 6, 2);
}
if (strlen($q['m']) > 9) {
$where .= " AND HOUR({$hqdb->posts}.post_date)=" . substr($q['m'], 8, 2);
}
if (strlen($q['m']) > 11) {
$where .= " AND MINUTE({$hqdb->posts}.post_date)=" . substr($q['m'], 10, 2);
}
if (strlen($q['m']) > 13) {
$where .= " AND SECOND({$hqdb->posts}.post_date)=" . substr($q['m'], 12, 2);
}
}
// Handle the other individual date parameters
$date_parameters = array();
if ('' !== $q['hour']) {
$date_parameters['hour'] = $q['hour'];
}
if ('' !== $q['minute']) {
$date_parameters['minute'] = $q['minute'];
}
if ('' !== $q['second']) {
$date_parameters['second'] = $q['second'];
}
if ($q['year']) {
$date_parameters['year'] = $q['year'];
}
if ($q['monthnum']) {
$date_parameters['monthnum'] = $q['monthnum'];
}
if ($q['w']) {
$date_parameters['week'] = $q['w'];
}
if ($q['day']) {
$date_parameters['day'] = $q['day'];
}
if ($date_parameters) {
$date_query = new HQ_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 HQ_Date_Query($q['date_query']);
$where .= $this->date_query->get_sql();
}
// If we've got a post_type AND it's not "any" post_type.
if (!empty($q['post_type']) && 'any' != $q['post_type']) {
foreach ((array) $q['post_type'] as $_post_type) {
$ptype_obj = get_post_type_object($_post_type);
if (!$ptype_obj || !$ptype_obj->query_var || empty($q[$ptype_obj->query_var])) {
continue;
}
if (!$ptype_obj->hierarchical) {
// Non-hierarchical post types can directly use 'name'.
$q['name'] = $q[$ptype_obj->query_var];
} else {
// Hierarchical post types will operate through 'pagename'.
$q['pagename'] = $q[$ptype_obj->query_var];
$q['name'] = '';
}
// Only one request for a slug is possible, this is why name & pagename are overwritten above.
break;
}
//end foreach
unset($ptype_obj);
}
if ('' != $q['name']) {
$q['name'] = sanitize_title_for_query($q['name']);
$where .= " AND {$hqdb->posts}.post_name = '" . $q['name'] . "'";
} elseif ('' != $q['pagename']) {
if (isset($this->queried_object_id)) {
$reqpage = $this->queried_object_id;
} else {
if ('page' != $q['post_type']) {
foreach ((array) $q['post_type'] as $_post_type) {
$ptype_obj = get_post_type_object($_post_type);
if (!$ptype_obj || !$ptype_obj->hierarchical) {
continue;
}
$reqpage = get_page_by_path($q['pagename'], OBJECT, $_post_type);
if ($reqpage) {
break;
}
}
unset($ptype_obj);
} else {
$reqpage = get_page_by_path($q['pagename']);
}
if (!empty($reqpage)) {
$reqpage = $reqpage->ID;
} else {
$reqpage = 0;
}
}
$page_for_posts = get_option('page_for_posts');
if ('page' != get_option('show_on_front') || empty($page_for_posts) || $reqpage != $page_for_posts) {
$q['pagename'] = sanitize_title_for_query(hq_basename($q['pagename']));
$q['name'] = $q['pagename'];
$where .= " AND ({$hqdb->posts}.ID = '{$reqpage}')";
$reqpage_obj = get_post($reqpage);
if (is_object($reqpage_obj) && 'attachment' == $reqpage_obj->post_type) {
$this->is_attachment = true;
$post_type = $q['post_type'] = 'attachment';
$this->is_page = true;
$q['attachment_id'] = $reqpage;
}
}
} elseif ('' != $q['attachment']) {
$q['attachment'] = sanitize_title_for_query(hq_basename($q['attachment']));
$q['name'] = $q['attachment'];
$where .= " AND {$hqdb->posts}.post_name = '" . $q['attachment'] . "'";
}
if (intval($q['comments_popup'])) {
$q['p'] = absint($q['comments_popup']);
}
// If an attachment is requested by number, let it supersede any post number.
if ($q['attachment_id']) {
$q['p'] = absint($q['attachment_id']);
}
// If a post number is specified, load that post
if ($q['p']) {
$where .= " AND {$hqdb->posts}.ID = " . $q['p'];
} elseif ($q['post__in']) {
$post__in = implode(',', array_map('absint', $q['post__in']));
$where .= " AND {$hqdb->posts}.ID IN ({$post__in})";
} elseif ($q['post__not_in']) {
$post__not_in = implode(',', array_map('absint', $q['post__not_in']));
$where .= " AND {$hqdb->posts}.ID NOT IN ({$post__not_in})";
}
if (is_numeric($q['post_parent'])) {
$where .= $hqdb->prepare(" AND {$hqdb->posts}.post_parent = %d ", $q['post_parent']);
} elseif ($q['post_parent__in']) {
$post_parent__in = implode(',', array_map('absint', $q['post_parent__in']));
$where .= " AND {$hqdb->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 {$hqdb->posts}.post_parent NOT IN ({$post_parent__not_in})";
}
if ($q['page_id']) {
if ('page' != get_option('show_on_front') || $q['page_id'] != get_option('page_for_posts')) {
$q['p'] = $q['page_id'];
$where = " AND {$hqdb->posts}.ID = " . $q['page_id'];
}
}
// If a search pattern is specified, load the posts that match.
if (!empty($q['s'])) {
$search = $this->parse_search($q);
}
/**
* Filter the search SQL that is used in the WHERE clause of HQ_Query.
*
* @param string $search Search SQL for WHERE clause.
* @param HQ_Query $this The current HQ_Query object.
*/
$search = apply_filters_ref_array('posts_search', array($search, &$this));
// Taxonomies
//TODO: Goyo no taxonomy
/*
if ( !$this->is_singular ) {
$this->parse_tax_query( $q );
$clauses = $this->tax_query->get_sql( $hqdb->posts, 'ID' );
$join .= $clauses['join'];
$where .= $clauses['where'];
}
*/
//TODO: Goyo no taxonomy
//if ( $this->is_tax ) {
if (false) {
if (empty($post_type)) {
// Do a fully inclusive search for currently registered post types of queried taxonomies
$post_type = array();
$taxonomies = array_keys($this->tax_query->queried_terms);
foreach (get_post_types(array('exclude_from_search' => false)) as $pt) {
$object_taxonomies = $pt === 'attachment' ? get_taxonomies_for_attachments() : get_object_taxonomies($pt);
if (array_intersect($taxonomies, $object_taxonomies)) {
$post_type[] = $pt;
}
}
if (!$post_type) {
$post_type = 'any';
} elseif (count($post_type) == 1) {
$post_type = $post_type[0];
}
$post_status_join = true;
} elseif (in_array('attachment', (array) $post_type)) {
$post_status_join = true;
}
}
/*
* Ensure that 'taxonomy', 'term', 'term_id', 'cat', and
* 'category_name' vars are set for backward compatibility.
*/
if (!empty($this->tax_query->queried_terms)) {
/*
* Set 'taxonomy', 'term', and 'term_id' to the
* first taxonomy other than 'post_tag' or 'category'.
*/
if (!isset($q['taxonomy'])) {
foreach ($this->tax_query->queried_terms as $queried_taxonomy => $queried_items) {
if (empty($queried_items['terms'][0])) {
continue;
}
if (!in_array($queried_taxonomy, array('category', 'post_tag'))) {
$q['taxonomy'] = $queried_taxonomy;
if ('slug' === $queried_items['field']) {
$q['term'] = $queried_items['terms'][0];
} else {
$q['term_id'] = $queried_items['terms'][0];
}
}
}
}
// 'cat', 'category_name', 'tag_id'
foreach ($this->tax_query->queried_terms as $queried_taxonomy => $queried_items) {
if (empty($queried_items['terms'][0])) {
continue;
}
if ('category' === $queried_taxonomy) {
$the_cat = get_term_by($queried_items['field'], $queried_items['terms'][0], 'category');
if ($the_cat) {
$this->set('cat', $the_cat->term_id);
$this->set('category_name', $the_cat->slug);
}
unset($the_cat);
}
if ('post_tag' === $queried_taxonomy) {
$the_tag = get_term_by($queried_items['field'], $queried_items['terms'][0], 'post_tag');
if ($the_tag) {
$this->set('tag_id', $the_tag->term_id);
}
unset($the_tag);
}
}
}
if (!empty($this->tax_query->queries) || !empty($this->meta_query->queries)) {
$groupby = "{$hqdb->posts}.ID";
}
// Author/user stuff
if (!empty($q['author']) && $q['author'] != '0') {
$q['author'] = addslashes_gpc('' . urldecode($q['author']));
$authors = array_unique(array_map('intval', preg_split('/[,\\s]+/', $q['author'])));
foreach ($authors as $author) {
$key = $author > 0 ? 'author__in' : 'author__not_in';
$q[$key][] = abs($author);
}
$q['author'] = implode(',', $authors);
}
if (!empty($q['author__not_in'])) {
$author__not_in = implode(',', array_map('absint', array_unique((array) $q['author__not_in'])));
$where .= " AND {$hqdb->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 {$hqdb->posts}.post_author IN ({$author__in}) ";
}
// Author stuff for nice URLs
if ('' != $q['author_name']) {
if (strpos($q['author_name'], '/') !== false) {
$q['author_name'] = explode('/', $q['author_name']);
if ($q['author_name'][count($q['author_name']) - 1]) {
$q['author_name'] = $q['author_name'][count($q['author_name']) - 1];
// no trailing slash
} else {
$q['author_name'] = $q['author_name'][count($q['author_name']) - 2];
// there was a trailing slash
}
}
$q['author_name'] = sanitize_title_for_query($q['author_name']);
$q['author'] = get_user_by('slug', $q['author_name']);
if ($q['author']) {
$q['author'] = $q['author']->ID;
}
$whichauthor .= " AND ({$hqdb->posts}.post_author = " . absint($q['author']) . ')';
}
// MIME-Type stuff for attachment browsing
if (isset($q['post_mime_type']) && '' != $q['post_mime_type']) {
$whichmimetype = hq_post_mime_type_where($q['post_mime_type'], $hqdb->posts);
}
$where .= $search . $whichauthor . $whichmimetype;
if (!empty($this->meta_query->queries)) {
$clauses = $this->meta_query->get_sql('post', $hqdb->posts, 'ID', $this);
$join .= $clauses['join'];
$where .= $clauses['where'];
}
$rand = isset($q['orderby']) && 'rand' === $q['orderby'];
if (!isset($q['order'])) {
$q['order'] = $rand ? '' : 'DESC';
} else {
$q['order'] = $rand ? '' : $this->parse_order($q['order']);
}
// 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 = "{$hqdb->posts}.post_date " . $q['order'];
}
} elseif ('none' == $q['orderby']) {
$orderby = '';
} elseif ($q['orderby'] == 'post__in' && !empty($post__in)) {
$orderby = "FIELD( {$hqdb->posts}.ID, {$post__in} )";
} elseif ($q['orderby'] == 'post_parent__in' && !empty($post_parent__in)) {
$orderby = "FIELD( {$hqdb->posts}.post_parent, {$post_parent__in} )";
} else {
$orderby_array = array();
if (is_array($q['orderby'])) {
foreach ($q['orderby'] as $_orderby => $order) {
$orderby = addslashes_gpc(urldecode($_orderby));
$parsed = $this->parse_orderby($orderby);
if (!$parsed) {
continue;
}
$orderby_array[] = $parsed . ' ' . $this->parse_order($order);
}
$orderby = implode(', ', $orderby_array);
} else {
$q['orderby'] = urldecode($q['orderby']);
$q['orderby'] = addslashes_gpc($q['orderby']);
foreach (explode(' ', $q['orderby']) as $i => $orderby) {
$parsed = $this->parse_orderby($orderby);
// Only allow certain values for safety.
if (!$parsed) {
continue;
}
$orderby_array[] = $parsed;
}
$orderby = implode(' ' . $q['order'] . ', ', $orderby_array);
if (empty($orderby)) {
$orderby = "{$hqdb->posts}.post_date " . $q['order'];
} elseif (!empty($q['order'])) {
$orderby .= " {$q['order']}";
}
}
}
// Order search results by relevance only when another "orderby" is not specified in the query.
if (!empty($q['s'])) {
$search_orderby = '';
if (!empty($q['search_orderby_title']) && (empty($q['orderby']) && !$this->is_feed) || isset($q['orderby']) && 'relevance' === $q['orderby']) {
$search_orderby = $this->parse_search_order($q);
}
/**
* Filter the ORDER BY used when ordering search results.
*
* @since 0.0.1
*
* @param string $search_orderby The ORDER BY clause.
* @param HQ_Query $this The current HQ_Query instance.
*/
$search_orderby = apply_filters('posts_search_orderby', $search_orderby, $this);
if ($search_orderby) {
$orderby = $orderby ? $search_orderby . ', ' . $orderby : $search_orderby;
}
}
if (is_array($post_type) && count($post_type) > 1) {
$post_type_cap = 'multiple_post_type';
} else {
if (is_array($post_type)) {
$post_type = reset($post_type);
}
$post_type_object = get_post_type_object($post_type);
if (empty($post_type_object)) {
$post_type_cap = $post_type;
}
}
if (isset($q['post_password'])) {
$where .= $hqdb->prepare(" AND {$hqdb->posts}.post_password = %s", $q['post_password']);
if (empty($q['perm'])) {
$q['perm'] = 'readable';
}
} elseif (isset($q['has_password'])) {
$where .= sprintf(" AND {$hqdb->posts}.post_password %s ''", $q['has_password'] ? '!=' : '=');
}
if ('any' == $post_type) {
$in_search_post_types = get_post_types(array('exclude_from_search' => false));
if (empty($in_search_post_types)) {
$where .= ' AND 1=0 ';
} else {
$where .= " AND {$hqdb->posts}.post_type IN ('" . join("', '", $in_search_post_types) . "')";
}
} elseif (!empty($post_type) && is_array($post_type)) {
$where .= " AND {$hqdb->posts}.post_type IN ('" . join("', '", $post_type) . "')";
} elseif (!empty($post_type)) {
$where .= " AND {$hqdb->posts}.post_type = '{$post_type}'";
$post_type_object = get_post_type_object($post_type);
} elseif ($this->is_attachment) {
$where .= " AND {$hqdb->posts}.post_type = 'attachment'";
$post_type_object = get_post_type_object('attachment');
} elseif ($this->is_page) {
$where .= " AND {$hqdb->posts}.post_type = 'page'";
$post_type_object = get_post_type_object('page');
} else {
$where .= " AND {$hqdb->posts}.post_type = 'post'";
$post_type_object = get_post_type_object('post');
}
$edit_cap = 'edit_post';
$read_cap = 'read_post';
if (!empty($post_type_object)) {
$edit_others_cap = $post_type_object->cap->edit_others_posts;
$read_private_cap = $post_type_object->cap->read_private_posts;
} else {
$edit_others_cap = 'edit_others_' . $post_type_cap . 's';
$read_private_cap = 'read_private_' . $post_type_cap . 's';
}
$user_id = get_current_user_id();
$q_status = array();
if (!empty($q['post_status'])) {
$statuswheres = array();
$q_status = $q['post_status'];
if (!is_array($q_status)) {
$q_status = explode(',', $q_status);
}
$r_status = array();
$p_status = array();
$e_status = array();
if (in_array('any', $q_status)) {
foreach (get_post_stati(array('exclude_from_search' => true)) as $status) {
if (!in_array($status, $q_status)) {
$e_status[] = "{$hqdb->posts}.post_status <> '{$status}'";
}
}
} else {
foreach (get_post_stati() as $status) {
if (in_array($status, $q_status)) {
if ('private' == $status) {
$p_status[] = "{$hqdb->posts}.post_status = '{$status}'";
} else {
$r_status[] = "{$hqdb->posts}.post_status = '{$status}'";
}
}
}
}
if (empty($q['perm']) || 'readable' != $q['perm']) {
$r_status = array_merge($r_status, $p_status);
unset($p_status);
}
if (!empty($e_status)) {
$statuswheres[] = "(" . join(' AND ', $e_status) . ")";
}
if (!empty($r_status)) {
if (!empty($q['perm']) && 'editable' == $q['perm'] && !current_user_can($edit_others_cap)) {
$statuswheres[] = "({$hqdb->posts}.post_author = {$user_id} " . "AND (" . join(' OR ', $r_status) . "))";
} else {
$statuswheres[] = "(" . join(' OR ', $r_status) . ")";
}
}
if (!empty($p_status)) {
if (!empty($q['perm']) && 'readable' == $q['perm'] && !current_user_can($read_private_cap)) {
$statuswheres[] = "({$hqdb->posts}.post_author = {$user_id} " . "AND (" . join(' OR ', $p_status) . "))";
} else {
$statuswheres[] = "(" . join(' OR ', $p_status) . ")";
}
}
if ($post_status_join) {
$join .= " LEFT JOIN {$hqdb->posts} AS p2 ON ({$hqdb->posts}.post_parent = p2.ID) ";
foreach ($statuswheres as $index => $statuswhere) {
$statuswheres[$index] = "({$statuswhere} OR ({$hqdb->posts}.post_status = 'inherit' AND " . str_replace($hqdb->posts, 'p2', $statuswhere) . "))";
}
}
$where_status = implode(' OR ', $statuswheres);
if (!empty($where_status)) {
$where .= " AND ({$where_status})";
}
} elseif (!$this->is_singular) {
$where .= " AND ({$hqdb->posts}.post_status = 'publish'";
// Add public states.
$public_states = get_post_stati(array('public' => true));
foreach ((array) $public_states as $state) {
if ('publish' == $state) {
// Publish is hard-coded above.
continue;
}
$where .= " OR {$hqdb->posts}.post_status = '{$state}'";
}
if ($this->is_admin) {
// Add protected states that should show in the admin all list.
$admin_all_states = get_post_stati(array('protected' => true, 'show_in_admin_all_list' => true));
foreach ((array) $admin_all_states as $state) {
$where .= " OR {$hqdb->posts}.post_status = '{$state}'";
}
}
if (is_user_logged_in()) {
// Add private states that are limited to viewing by the author of a post or someone who has caps to read private states.
$private_states = get_post_stati(array('private' => true));
foreach ((array) $private_states as $state) {
$where .= current_user_can($read_private_cap) ? " OR {$hqdb->posts}.post_status = '{$state}'" : " OR {$hqdb->posts}.post_author = {$user_id} AND {$hqdb->posts}.post_status = '{$state}'";
}
}
$where .= ')';
}
/*
* Apply filters on where and join prior to paging so that any
* manipulations to them are reflected in the paging by day queries.
*/
if (!$q['suppress_filters']) {
/**
* Filter the WHERE clause of the query.
*
* @since 0.0.1
*
* @param string $where The WHERE clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$where = apply_filters_ref_array('posts_where', array($where, &$this));
/**
* Filter the JOIN clause of the query.
*
* @since 0.0.1
*
* @param string $where The JOIN clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$join = apply_filters_ref_array('posts_join', array($join, &$this));
}
// Paging
if (empty($q['nopaging']) && !$this->is_singular) {
$page = absint($q['paged']);
if (!$page) {
$page = 1;
}
if (empty($q['offset'])) {
$pgstrt = absint(($page - 1) * $q['posts_per_page']) . ', ';
} else {
// we're ignoring $page and using 'offset'
$q['offset'] = absint($q['offset']);
$pgstrt = $q['offset'] . ', ';
}
$limits = 'LIMIT ' . $pgstrt . $q['posts_per_page'];
}
// Comments feeds
if ($this->is_comment_feed && !$this->is_singular) {
if ($this->is_archive || $this->is_search) {
$cjoin = "JOIN {$hqdb->posts} ON ({$hqdb->comments}.comment_post_ID = {$hqdb->posts}.ID) {$join} ";
$cwhere = "WHERE comment_approved = '1' {$where}";
$cgroupby = "{$hqdb->comments}.comment_id";
} else {
// Other non singular e.g. front
$cjoin = "JOIN {$hqdb->posts} ON ( {$hqdb->comments}.comment_post_ID = {$hqdb->posts}.ID )";
$cwhere = "WHERE post_status = 'publish' AND comment_approved = '1'";
$cgroupby = '';
}
if (!$q['suppress_filters']) {
/**
* Filter the JOIN clause of the comments feed query before sending.
*
* @since 0.0.1
*
* @param string $cjoin The JOIN clause of the query.
* @param HQ_Query &$this The HQ_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 0.0.1
*
* @param string $cwhere The WHERE clause of the query.
* @param HQ_Query &$this The HQ_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 0.0.1
*
* @param string $cgroupby The GROUP BY clause of the query.
* @param HQ_Query &$this The HQ_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 0.0.1
*
* @param string $corderby The ORDER BY clause of the query.
* @param HQ_Query &$this The HQ_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 0.0.1
*
* @param string $climits The JOIN clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$climits = apply_filters_ref_array('comment_feed_limits', array('LIMIT ' . get_option('posts_per_rss'), &$this));
}
$cgroupby = !empty($cgroupby) ? 'GROUP BY ' . $cgroupby : '';
$corderby = !empty($corderby) ? 'ORDER BY ' . $corderby : '';
$this->comments = (array) $hqdb->get_results("SELECT {$distinct} {$hqdb->comments}.* FROM {$hqdb->comments} {$cjoin} {$cwhere} {$cgroupby} {$corderby} {$climits}");
$this->comment_count = count($this->comments);
$post_ids = array();
foreach ($this->comments as $comment) {
$post_ids[] = (int) $comment->comment_post_ID;
}
$post_ids = join(',', $post_ids);
$join = '';
if ($post_ids) {
$where = "AND {$hqdb->posts}.ID IN ({$post_ids}) ";
} else {
$where = "AND 0";
}
}
$pieces = array('where', 'groupby', 'join', 'orderby', 'distinct', 'fields', 'limits');
/*
* Apply post-paging filters on where and join. Only plugins that
* manipulate paging queries should use these hooks.
*/
if (!$q['suppress_filters']) {
/**
* Filter the WHERE clause of the query.
*
* Specifically for manipulating paging queries.
*
* @since 0.0.1
*
* @param string $where The WHERE clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$where = apply_filters_ref_array('posts_where_paged', array($where, &$this));
/**
* Filter the GROUP BY clause of the query.
*
* @since 0.0.1
*
* @param string $groupby The GROUP BY clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$groupby = apply_filters_ref_array('posts_groupby', array($groupby, &$this));
/**
* Filter the JOIN clause of the query.
*
* Specifically for manipulating paging queries.
*
* @since 0.0.1
*
* @param string $join The JOIN clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$join = apply_filters_ref_array('posts_join_paged', array($join, &$this));
/**
* Filter the ORDER BY clause of the query.
*
* @since 0.0.1
*
* @param string $orderby The ORDER BY clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$orderby = apply_filters_ref_array('posts_orderby', array($orderby, &$this));
/**
* Filter the DISTINCT clause of the query.
*
* @since 0.0.1
*
* @param string $distinct The DISTINCT clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$distinct = apply_filters_ref_array('posts_distinct', array($distinct, &$this));
/**
* Filter the LIMIT clause of the query.
*
* @since 0.0.1
*
* @param string $limits The LIMIT clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$limits = apply_filters_ref_array('post_limits', array($limits, &$this));
/**
* Filter the SELECT clause of the query.
*
* @since 0.0.1
*
* @param string $fields The SELECT clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$fields = apply_filters_ref_array('posts_fields', array($fields, &$this));
/**
* Filter all query clauses at once, for convenience.
*
* Covers the WHERE, GROUP BY, JOIN, ORDER BY, DISTINCT,
* fields (SELECT), and LIMITS clauses.
*
* @since 0.0.1
*
* @param array $clauses The list of clauses for the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$clauses = (array) apply_filters_ref_array('posts_clauses', array(compact($pieces), &$this));
$where = isset($clauses['where']) ? $clauses['where'] : '';
$groupby = isset($clauses['groupby']) ? $clauses['groupby'] : '';
$join = isset($clauses['join']) ? $clauses['join'] : '';
$orderby = isset($clauses['orderby']) ? $clauses['orderby'] : '';
$distinct = isset($clauses['distinct']) ? $clauses['distinct'] : '';
$fields = isset($clauses['fields']) ? $clauses['fields'] : '';
$limits = isset($clauses['limits']) ? $clauses['limits'] : '';
}
/**
* Fires to announce the query's current selection parameters.
*
* For use by caching plugins.
*
* @since 0.0.1
*
* @param string $selection The assembled selection query.
*/
do_action('posts_selection', $where . $groupby . $orderby . $limits . $join);
/*
* Filter again for the benefit of caching plugins.
* Regular plugins should use the hooks above.
*/
if (!$q['suppress_filters']) {
/**
* Filter the WHERE clause of the query.
*
* For use by caching plugins.
*
* @since 0.0.1
*
* @param string $where The WHERE clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$where = apply_filters_ref_array('posts_where_request', array($where, &$this));
/**
* Filter the GROUP BY clause of the query.
*
* For use by caching plugins.
*
* @since 0.0.1
*
* @param string $groupby The GROUP BY clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$groupby = apply_filters_ref_array('posts_groupby_request', array($groupby, &$this));
/**
* Filter the JOIN clause of the query.
*
* For use by caching plugins.
*
* @since 0.0.1
*
* @param string $join The JOIN clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$join = apply_filters_ref_array('posts_join_request', array($join, &$this));
/**
* Filter the ORDER BY clause of the query.
*
* For use by caching plugins.
*
* @since 0.0.1
*
* @param string $orderby The ORDER BY clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$orderby = apply_filters_ref_array('posts_orderby_request', array($orderby, &$this));
/**
* Filter the DISTINCT clause of the query.
*
* For use by caching plugins.
*
* @since 0.0.1
*
* @param string $distinct The DISTINCT clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$distinct = apply_filters_ref_array('posts_distinct_request', array($distinct, &$this));
/**
* Filter the SELECT clause of the query.
*
* For use by caching plugins.
*
* @since 0.0.1
*
* @param string $fields The SELECT clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$fields = apply_filters_ref_array('posts_fields_request', array($fields, &$this));
/**
* Filter the LIMIT clause of the query.
*
* For use by caching plugins.
*
* @since 0.0.1
*
* @param string $limits The LIMIT clause of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$limits = apply_filters_ref_array('post_limits_request', array($limits, &$this));
/**
* 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 0.0.1
*
* @param array $pieces The pieces of the query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$clauses = (array) apply_filters_ref_array('posts_clauses_request', array(compact($pieces), &$this));
$where = isset($clauses['where']) ? $clauses['where'] : '';
$groupby = isset($clauses['groupby']) ? $clauses['groupby'] : '';
$join = isset($clauses['join']) ? $clauses['join'] : '';
$orderby = isset($clauses['orderby']) ? $clauses['orderby'] : '';
$distinct = isset($clauses['distinct']) ? $clauses['distinct'] : '';
$fields = isset($clauses['fields']) ? $clauses['fields'] : '';
$limits = isset($clauses['limits']) ? $clauses['limits'] : '';
}
if (!empty($groupby)) {
$groupby = 'GROUP BY ' . $groupby;
}
if (!empty($orderby)) {
$orderby = 'ORDER BY ' . $orderby;
}
$found_rows = '';
if (!$q['no_found_rows'] && !empty($limits)) {
$found_rows = 'SQL_CALC_FOUND_ROWS';
}
$this->request = $old_request = "SELECT {$found_rows} {$distinct} {$fields} FROM {$hqdb->posts} {$join} WHERE 1=1 {$where} {$groupby} {$orderby} {$limits}";
if (!$q['suppress_filters']) {
/**
* Filter the completed SQL query before sending.
*
* @since 0.0.1
*
* @param array $request The complete SQL query.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$this->request = apply_filters_ref_array('posts_request', array($this->request, &$this));
}
if ('ids' == $q['fields']) {
$this->posts = $hqdb->get_col($this->request);
$this->posts = array_map('intval', $this->posts);
$this->post_count = count($this->posts);
$this->set_found_posts($q, $limits);
return $this->posts;
}
if ('id=>parent' == $q['fields']) {
$this->posts = $hqdb->get_results($this->request);
$this->post_count = count($this->posts);
$this->set_found_posts($q, $limits);
$r = array();
foreach ($this->posts as $key => $post) {
$this->posts[$key]->ID = (int) $post->ID;
$this->posts[$key]->post_parent = (int) $post->post_parent;
$r[(int) $post->ID] = (int) $post->post_parent;
}
return $r;
}
$split_the_query = $old_request == $this->request && "{$hqdb->posts}.*" == $fields && !empty($limits) && $q['posts_per_page'] < 500;
/**
* 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 0.0.1
*
* @param bool $split_the_query Whether or not to split the query.
* @param HQ_Query $this The HQ_Query instance.
*/
$split_the_query = apply_filters('split_the_query', $split_the_query, $this);
if ($split_the_query) {
// First get the IDs and then fill in the objects
$this->request = "SELECT {$found_rows} {$distinct} {$hqdb->posts}.ID FROM {$hqdb->posts} {$join} WHERE 1=1 {$where} {$groupby} {$orderby} {$limits}";
/**
* Filter the Post IDs SQL request before sending.
*
* @since 0.0.1
*
* @param string $request The post ID request.
* @param HQ_Query $this The HQ_Query instance.
*/
$this->request = apply_filters('posts_request_ids', $this->request, $this);
$ids = $hqdb->get_col($this->request);
if ($ids) {
$this->posts = $ids;
$this->set_found_posts($q, $limits);
//TODO: Goyo no cache
//_prime_post_caches( $ids, $q['update_post_term_cache'], $q['update_post_meta_cache'] );
} else {
$this->posts = array();
}
} else {
$this->posts = $hqdb->get_results($this->request);
$this->set_found_posts($q, $limits);
}
// Convert to HQ_Post objects
if ($this->posts) {
$this->posts = array_map('get_post', $this->posts);
}
if (!$q['suppress_filters']) {
/**
* Filter the raw post results array, prior to status checks.
*
* @since 0.0.1
*
* @param array $posts The post results array.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$this->posts = apply_filters_ref_array('posts_results', array($this->posts, &$this));
}
if (!empty($this->posts) && $this->is_comment_feed && $this->is_singular) {
/** This filter is documented in hq-includes/query.php */
$cjoin = apply_filters_ref_array('comment_feed_join', array('', &$this));
/** This filter is documented in hq-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 hq-includes/query.php */
$cgroupby = apply_filters_ref_array('comment_feed_groupby', array('', &$this));
$cgroupby = !empty($cgroupby) ? 'GROUP BY ' . $cgroupby : '';
/** This filter is documented in hq-includes/query.php */
$corderby = apply_filters_ref_array('comment_feed_orderby', array('comment_date_gmt DESC', &$this));
$corderby = !empty($corderby) ? 'ORDER BY ' . $corderby : '';
/** This filter is documented in hq-includes/query.php */
$climits = apply_filters_ref_array('comment_feed_limits', array('LIMIT ' . get_option('posts_per_rss'), &$this));
$comments_request = "SELECT {$hqdb->comments}.* FROM {$hqdb->comments} {$cjoin} {$cwhere} {$cgroupby} {$corderby} {$climits}";
$this->comments = $hqdb->get_results($comments_request);
$this->comment_count = count($this->comments);
}
// Check post status to determine if post should be displayed.
if (!empty($this->posts) && ($this->is_single || $this->is_page)) {
$status = get_post_status($this->posts[0]);
$post_status_obj = get_post_status_object($status);
//$type = get_post_type($this->posts[0]);
// If the post_status was specifically requested, let it pass through.
if (!$post_status_obj->public && !in_array($status, $q_status)) {
if (!is_user_logged_in()) {
// User must be logged in to view unpublished posts.
$this->posts = array();
} else {
if ($post_status_obj->protected) {
// User must have edit permissions on the draft to preview.
if (!current_user_can($edit_cap, $this->posts[0]->ID)) {
$this->posts = array();
} else {
$this->is_preview = true;
if ('future' != $status) {
$this->posts[0]->post_date = current_time('mysql');
}
}
} elseif ($post_status_obj->private) {
if (!current_user_can($read_cap, $this->posts[0]->ID)) {
$this->posts = array();
}
} else {
$this->posts = array();
}
}
}
if ($this->is_preview && $this->posts && current_user_can($edit_cap, $this->posts[0]->ID)) {
/**
* Filter the single post for preview mode.
*
* @since 0.0.1
*
* @param HQ_Post $post_preview The Post object.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$this->posts[0] = get_post(apply_filters_ref_array('the_preview', array($this->posts[0], &$this)));
}
}
// Put sticky posts at the top of the posts array
$sticky_posts = get_option('sticky_posts');
if ($this->is_home && $page <= 1 && is_array($sticky_posts) && !empty($sticky_posts) && !$q['ignore_sticky_posts']) {
$num_posts = count($this->posts);
$sticky_offset = 0;
// Loop over posts and relocate stickies to the front.
for ($i = 0; $i < $num_posts; $i++) {
if (in_array($this->posts[$i]->ID, $sticky_posts)) {
$sticky_post = $this->posts[$i];
// Remove sticky from current position
array_splice($this->posts, $i, 1);
// Move to front, after other stickies
array_splice($this->posts, $sticky_offset, 0, array($sticky_post));
// Increment the sticky offset. The next sticky will be placed at this offset.
$sticky_offset++;
// Remove post from sticky posts array
$offset = array_search($sticky_post->ID, $sticky_posts);
unset($sticky_posts[$offset]);
}
}
// If any posts have been excluded specifically, Ignore those that are sticky.
if (!empty($sticky_posts) && !empty($q['post__not_in'])) {
$sticky_posts = array_diff($sticky_posts, $q['post__not_in']);
}
// Fetch sticky posts that weren't in the query results
if (!empty($sticky_posts)) {
$stickies = get_posts(array('post__in' => $sticky_posts, 'post_type' => $post_type, 'post_status' => 'publish', 'nopaging' => true));
foreach ($stickies as $sticky_post) {
array_splice($this->posts, $sticky_offset, 0, array($sticky_post));
$sticky_offset++;
}
}
}
if (!$q['suppress_filters']) {
/**
* Filter the array of retrieved posts after they've been fetched and
* internally processed.
*
* @param array $posts The array of retrieved posts.
* @param HQ_Query &$this The HQ_Query instance (passed by reference).
*/
$this->posts = apply_filters_ref_array('the_posts', array($this->posts, &$this));
}
//Goyo: Debug
//print("get_posts: AQui");
// Ensure that any posts added/modified via one of the filters above are
// of the type HQ_Post and are filtered.
if ($this->posts) {
$this->post_count = count($this->posts);
$this->posts = array_map('get_post', $this->posts);
//TODO: Goyo no caches
//
//if ( $q['cache_results'] )
// update_post_caches($this->posts, $post_type, $q['update_post_term_cache'], $q['update_post_meta_cache']);
$this->post = reset($this->posts);
} else {
$this->post_count = 0;
$this->posts = array();
}
return $this->posts;
}
