/**
  * Parse and sanitize 'orderby' keys passed to the user query.
  *
  * @since 4.2.0
  * @access protected
  *
  * @global wpdb $wpdb WordPress database abstraction object.
  *
  * @param string $orderby Alias for the field to order by.
  * @return string Value to used in the ORDER clause, if `$orderby` is valid.
  */
 protected function parse_orderby($orderby)
 {
     global $wpdb;
     $meta_query_clauses = $this->meta_query->get_clauses();
     $_orderby = '';
     if (in_array($orderby, array('login', 'nicename', 'email', 'url', 'registered'))) {
         $_orderby = 'user_' . $orderby;
     } elseif (in_array($orderby, array('user_login', 'user_nicename', 'user_email', 'user_url', 'user_registered'))) {
         $_orderby = $orderby;
     } elseif ('name' == $orderby || 'display_name' == $orderby) {
         $_orderby = 'display_name';
     } elseif ('post_count' == $orderby) {
         // todo: avoid the JOIN
         $where = get_posts_by_author_sql('post');
         $this->query_from .= " LEFT OUTER JOIN (\n\t\t\t\tSELECT post_author, COUNT(*) as post_count\n\t\t\t\tFROM {$wpdb->posts}\n\t\t\t\t{$where}\n\t\t\t\tGROUP BY post_author\n\t\t\t) p ON ({$wpdb->users}.ID = p.post_author)\n\t\t\t";
         $_orderby = 'post_count';
     } elseif ('ID' == $orderby || 'id' == $orderby) {
         $_orderby = 'ID';
     } elseif ('meta_value' == $orderby || $this->get('meta_key') == $orderby) {
         $_orderby = "{$wpdb->usermeta}.meta_value";
     } elseif ('meta_value_num' == $orderby) {
         $_orderby = "{$wpdb->usermeta}.meta_value+0";
     } elseif ('include' === $orderby && !empty($this->query_vars['include'])) {
         $include = wp_parse_id_list($this->query_vars['include']);
         $include_sql = implode(',', $include);
         $_orderby = "FIELD( {$wpdb->users}.ID, {$include_sql} )";
     } elseif (isset($meta_query_clauses[$orderby])) {
         $meta_clause = $meta_query_clauses[$orderby];
         $_orderby = sprintf("CAST(%s.meta_value AS %s)", esc_sql($meta_clause['alias']), esc_sql($meta_clause['cast']));
     }
     return $_orderby;
 }

 /**
  * Retrieve list of latest posts or posts matching criteria.
  *
  * The defaults are as follows:
  *     'numberposts' - Default is 5. Total number of posts to retrieve.
  *     'offset' - Default is 0. See {@link WP_Query::query()} for more.
  *     'category' - What category to pull the posts from.
  *     'orderby' - Default is 'date', which orders based on post_date. How to order the posts.
  *     'order' - Default is 'DESC'. The order to retrieve the posts.
  *     'include' - See {@link WP_Query::query()} for more.
  *     'exclude' - See {@link WP_Query::query()} for more.
  *     'meta_key' - See {@link WP_Query::query()} for more.
  *     'meta_value' - See {@link WP_Query::query()} for more.
  *     'post_type' - Default is 'post'. Can be 'page', or 'attachment' to name a few.
  *     'post_parent' - The parent of the post or post type.
  *     'post_status' - Default is 'publish'. Post status to retrieve.
  *
  * @uses WP_Query::query() See for more default arguments and information.
  * @uses ES_WP_Query
  * @link http://codex.wordpress.org/Template_Tags/get_posts
  *
  * @param array $args Optional. Overrides defaults.
  * @return array List of posts.
  */
 function es_get_posts($args = null)
 {
     $defaults = array('numberposts' => 5, 'offset' => 0, 'category' => 0, 'orderby' => 'date', 'order' => 'DESC', 'include' => array(), 'exclude' => array(), 'meta_key' => '', 'meta_value' => '', 'post_type' => 'post', 'suppress_filters' => true);
     $r = wp_parse_args($args, $defaults);
     if (empty($r['post_status'])) {
         $r['post_status'] = 'attachment' == $r['post_type'] ? 'inherit' : 'publish';
     }
     if (!empty($r['numberposts']) && empty($r['posts_per_page'])) {
         $r['posts_per_page'] = $r['numberposts'];
     }
     if (!empty($r['category'])) {
         $r['cat'] = $r['category'];
     }
     if (!empty($r['include'])) {
         $incposts = wp_parse_id_list($r['include']);
         $r['posts_per_page'] = count($incposts);
         // only the number of posts included
         $r['post__in'] = $incposts;
     } elseif (!empty($r['exclude'])) {
         $r['post__not_in'] = wp_parse_id_list($r['exclude']);
     }
     $r['ignore_sticky_posts'] = true;
     $r['no_found_rows'] = true;
     $get_posts = new ES_WP_Query();
     return $get_posts->query($r);
 }

 function setup_group_ids()
 {
     global $wpdb, $bp;
     $sql = "SELECT group_id FROM {$bp->groups->table_name_groupmeta} WHERE ";
     $join_clauses = array();
     $where_clauses = array();
     $counter = 1;
     $filter_count = count($this->filters);
     foreach ($this->filters as $key => $value) {
         $table_shortname = 'gmf' . $counter;
         $join_sql = $counter > 1 ? " LEFT JOIN {$bp->groups->table_name_groupmeta} {$table_shortname} ON gmf1.group_id = {$table_shortname}.group_id " : "{$bp->groups->table_name_groupmeta} {$table_shortname}";
         $join_clauses[] = $join_sql;
         $clause = $wpdb->prepare("{$table_shortname}.meta_key = %s", $key);
         if (false !== $value) {
             $clause .= $wpdb->prepare(" AND {$table_shortname}.meta_value = %s", $value);
         }
         $where_clauses[] = $clause;
         // If this key matches the orderby param, stash the table shortname
         if (!empty($this->orderby) && $this->orderby == $key) {
             $this->orderby_shortname = $table_shortname;
         }
         $counter++;
     }
     if (!empty($where_clauses)) {
         $sql = "SELECT gmf1.group_id FROM " . implode(' ', $join_clauses) . " WHERE " . implode(' AND ', $where_clauses);
     } else {
         $sql = $wpdb->get_results("SELECT id FROM {$bp->groups->table_name} WHERE 1 = 0");
     }
     $this->group_ids = wp_parse_id_list($wpdb->get_col($sql));
 }

 /**
  * Standard meta retrieval
  *
  * @param int   $post_id
  * @param bool  $saved
  * @param array $field
  *
  * @return array
  */
 public static function meta($post_id, $saved, $field)
 {
     $meta = get_post_meta($post_id, $field['id'], true);
     $meta = wp_parse_id_list($meta);
     $meta = array_filter($meta);
     return $meta;
 }

 /**
  * Filters out product categories the user does not have access to. 
  * @since 2.5.8
  * @global type $wpdb
  * @param array $args
  * @param array $taxonomies
  * @return array
  */
 public function taxonomy_filter($args, $taxonomies)
 {
     global $wpdb;
     if (in_array('product_cat', $taxonomies)) {
         $disallowed = $this->get_cached_exclusions('cat');
         if ($disallowed === false) {
             $user_roles = $this->get_roles_for_current_user();
             $sql = " SELECT term_id FROM {$wpdb->prefix}term_taxonomy WHERE taxonomy = 'product_cat' AND term_id NOT IN (\n\t\t\t\tSELECT term_id FROM {$wpdb->prefix}term_taxonomy WHERE taxonomy = 'product_cat' AND term_id NOT IN (SELECT {$wpdb->prefix}woocommerce_termmeta.woocommerce_term_id FROM {$wpdb->prefix}woocommerce_termmeta WHERE meta_key = '_wc_restrictions')\n\t\t\t\tUNION ALL \n\t\t\t\tSELECT {$wpdb->prefix}woocommerce_termmeta.woocommerce_term_id FROM {$wpdb->prefix}woocommerce_termmeta WHERE ( (meta_key ='_wc_restrictions' AND meta_value = 'public') OR (meta_key = '_wc_restrictions_allowed' AND meta_value IN ('" . implode("','", $user_roles) . "') ) ) )";
             $disallowed = $wpdb->get_col($sql);
             if ($disallowed !== false) {
                 $session_id = WC_Catalog_Visibility_Compatibility::WC()->session->get_customer_id();
                 set_transient('twccr_' . $session_id . '_cat', $disallowed, 60 * 60 * 24);
             }
         }
         if ($disallowed && count($disallowed)) {
             $disallowed = array_map('intval', $disallowed);
             if (isset($args['include']) && !empty($args['include'])) {
                 $include = wp_parse_id_list($args['include']);
                 $allowed = array_filter(array_diff($include, $disallowed));
                 if (empty($allowed)) {
                     $args['include'] = array();
                     $args['exclude'] = $disallowed;
                 } else {
                     $args['include'] = $allowed;
                 }
             } else {
                 $exclude = wp_parse_id_list($args['exclude']);
                 $args['exclude'] = isset($exclude) && !empty($exclude) ? array_merge($exclude, $disallowed) : $disallowed;
             }
         }
     } else {
     }
     return $args;
 }

function circleflip_post_formats_save_metabox($post_id)
{
    if (!isset($_POST['_circleflip_post_formats']) || !wp_verify_nonce($_POST['_circleflip_post_formats']['_nonce'], __FILE__) || defined('DOING_AUTOSAVE') && DOING_AUTOSAVE || !current_user_can('edit_post', $post_id)) {
        return $post_id;
    }
    $format = get_post_format($post_id);
    $data = array();
    if ('audio' === $format) {
        if (!empty($_POST['_circleflip_post_formats']['audio_id'])) {
            $data['audio_id'] = (int) $_POST['_circleflip_post_formats']['audio_id'];
        } else {
            $data['audio_embed'] = $_POST['_circleflip_post_formats']['audio_embed'];
        }
    } else {
        if ('video' === $format) {
            if (!empty($_POST['_circleflip_post_formats']['video_id'])) {
                $data['video_id'] = (int) $_POST['_circleflip_post_formats']['video_id'];
            } else {
                $data['video_embed'] = $_POST['_circleflip_post_formats']['video_embed'];
            }
        } else {
            if ('gallery' === $format) {
                $ids_string = $_POST['_circleflip_post_formats']['gallery'];
                $data['gallery'] = wp_parse_id_list($ids_string);
                $data['gallery_layout'] = $_POST['_circleflip_post_formats']['layout'];
            }
        }
    }
    update_post_meta($post_id, '_circleflip_post_formats', $data);
}

 /**
  * Modify query to filter users by group.
  * 
  * @param WP_User_Query $user_query
  * @return WP_User_Query
  */
 public static function pre_user_query($user_query)
 {
     global $pagenow, $wpdb;
     if ($pagenow == 'users.php' && empty($_GET['page'])) {
         if (isset($_REQUEST['group'])) {
             $group_id = $_REQUEST['group'];
             if (Groups_Group::read($group_id)) {
                 $group = new Groups_Group($group_id);
                 $users = $group->users;
                 $include = array();
                 if (count($users) > 0) {
                     foreach ($users as $user) {
                         $include[] = $user->user->ID;
                     }
                 } else {
                     // no results
                     $include[] = 0;
                 }
                 $ids = implode(',', wp_parse_id_list($include));
                 $user_query->query_where .= " AND {$wpdb->users}.ID IN ({$ids})";
             }
         }
     }
     return $user_query;
 }

 /**
  * @group get_current_threads_for_user
  * @expectedDeprecated BP_Messages_Thread::get_current_threads_for_user
  */
 public function test_get_current_threads_for_user_with_old_args()
 {
     $u1 = $this->factory->user->create();
     $u2 = $this->factory->user->create();
     $t1 = $this->factory->message->create(array('sender_id' => $u1, 'recipients' => array($u2), 'subject' => 'Foo'));
     $t2 = $this->factory->message->create(array('sender_id' => $u1, 'recipients' => array($u2), 'subject' => 'Bar'));
     $threads = BP_Messages_Thread::get_current_threads_for_user($u1, 'sentbox', 'all', null, null, 'ar');
     $expected = array($t2);
     $found = wp_parse_id_list(wp_list_pluck($threads['threads'], 'thread_id'));
     $this->assertSame($expected, $found);
 }

 public function find($ids)
 {
     if (is_numeric($ids)) {
         return $this->get_term($ids);
     }
     $incposts = wp_parse_id_list($ids);
     $this->posts_per_page = count($incposts);
     // only the number of posts included
     $this->post__in = $incposts;
     return count($incposts) == 1 ? $this->first() : $this->get();
 }

function mb_remove_user_topic_bookmark($user_id, $topic_id)
{
    $user_id = mb_get_user_id($user_id);
    $topic_id = mb_get_topic_id($topic_id);
    $favs = mb_get_user_topic_bookmarks($user_id);
    if (in_array($topic_id, $favs)) {
        wp_cache_delete('mb_get_topic_bookmarkers_' . $topic_id, 'message-board-users');
        $_sub = array_search($topic_id, $favs);
        unset($favs[$_sub]);
        $favs = implode(',', wp_parse_id_list(array_filter($favs)));
        return update_user_meta($user_id, mb_get_user_topic_bookmarks_meta_key(), $favs);
    }
    return false;
}

 /**
  * Loads variation child IDs.
  * @param  WC_Product
  * @param  bool $force_read True to bypass the transient.
  * @return WC_Product
  */
 public function read_children(&$product, $force_read = false)
 {
     $children_transient_name = 'wc_product_children_' . $product->get_id();
     $children = get_transient($children_transient_name);
     if (empty($children) || !is_array($children) || !isset($children['all']) || !isset($children['visible']) || $force_read) {
         $all_args = $visible_only_args = array('post_parent' => $product->get_id(), 'post_type' => 'product_variation', 'orderby' => 'menu_order', 'order' => 'ASC', 'fields' => 'ids', 'post_status' => 'publish', 'numberposts' => -1);
         if ('yes' === get_option('woocommerce_hide_out_of_stock_items')) {
             $visible_only_args['meta_query'][] = array('key' => '_stock_status', 'value' => 'instock', 'compare' => '=');
         }
         $children['all'] = get_posts(apply_filters('woocommerce_variable_children_args', $all_args, $product, false));
         $children['visible'] = get_posts(apply_filters('woocommerce_variable_children_args', $visible_only_args, $product, true));
         set_transient($children_transient_name, $children, DAY_IN_SECONDS * 30);
     }
     $product->set_children(wp_parse_id_list((array) $children['all']));
     $product->set_visible_children(wp_parse_id_list((array) $children['visible']));
 }

/**
 * Filter BP_User_Query::populate_extras to add confirmed friendship status.
 *
 * Each member in the user query is checked for confirmed friendship status
 * against the logged-in user.
 *
 * @since 1.7.0
 *
 * @global WPDB $wpdb WordPress database access object.
 *
 * @param BP_User_Query $user_query   The BP_User_Query object.
 * @param string        $user_ids_sql Comma-separated list of user IDs to fetch extra
 *                                    data for, as determined by BP_User_Query.
 */
function bp_friends_filter_user_query_populate_extras(BP_User_Query $user_query, $user_ids_sql)
{
    global $wpdb;
    // Stop if user isn't logged in.
    if (!($user_id = bp_loggedin_user_id())) {
        return;
    }
    $maybe_friend_ids = wp_parse_id_list($user_ids_sql);
    foreach ($maybe_friend_ids as $friend_id) {
        $status = BP_Friends_Friendship::check_is_friend($user_id, $friend_id);
        $user_query->results[$friend_id]->friendship_status = $status;
        if ('is_friend' == $status) {
            $user_query->results[$friend_id]->is_friend = 1;
        }
    }
}

 /**
  * Setup the object
  *
  * @param array $args Arguments containing from taxonomy, to taxonomy,
  *                    and additional optional params
  *
  * @since 1.0.0
  */
 public function __construct($args = array())
 {
     $args = wp_parse_args($args, array('from_tax' => '', 'to_tax' => '', 'parent' => '', 'terms' => ''));
     if (!$args['from_tax'] || !$args['to_tax']) {
         return;
     }
     if (!empty($args['parent'])) {
         $this->parent = absint($args['parent']);
     }
     if (!empty($args['terms'])) {
         $this->terms = wp_parse_id_list($args['terms']);
     }
     $this->is_ui = isset($_GET['page']) && 'taxonomy-switcher' == $_GET['page'];
     $this->from = sanitize_text_field($args['from_tax']);
     $this->to = sanitize_text_field($args['to_tax']);
 }

 public function exclude($taxonomy, $string)
 {
     global $yarpp;
     echo "<div class='yarpp_form_row yarpp_form_exclude'><div class='yarpp_form_label'>";
     echo $string;
     echo "</div><div class='yarpp_scroll_wrapper'><div class='exclude_terms' id='exclude_{$taxonomy}'>";
     $exclude_tt_ids = wp_parse_id_list(yarpp_get_option('exclude'));
     $exclude_term_ids = $yarpp->admin->get_term_ids_from_tt_ids($taxonomy, $exclude_tt_ids);
     if (count($exclude_term_ids)) {
         $terms = get_terms($taxonomy, array('include' => $exclude_term_ids));
         foreach ($terms as $term) {
             echo "<input type='checkbox' name='exclude[{$term->term_taxonomy_id}]' id='exclude_{$term->term_taxonomy_id}' value='true' checked='checked' /> <label for='exclude_{$term->term_taxonomy_id}'>" . esc_html($term->name) . "</label> ";
         }
     }
     echo "</div></div></div>";
 }

/**
 * Update the metadata cache for the specified objects.
 *
 * @since BuddyPress (1.6)
 * @global $wpdb WordPress database object for queries.
 * @param array $args See $defaults definition for more details
 * @return mixed Metadata cache for the specified objects, or false on failure.
 */
function bp_update_meta_cache($args = array())
{
    global $wpdb;
    $defaults = array('object_ids' => array(), 'object_type' => '', 'meta_table' => '', 'object_column' => '', 'cache_key_prefix' => '');
    $r = wp_parse_args($args, $defaults);
    extract($r);
    if (empty($object_ids) || empty($object_type) || empty($meta_table)) {
        return false;
    }
    if (empty($cache_key_prefix)) {
        $cache_key_prefix = $meta_table;
    }
    if (empty($object_column)) {
        $object_column = $object_type . '_id';
    }
    $object_ids = wp_parse_id_list($object_ids);
    $cache = array();
    // Get meta info
    $id_list = join(',', $object_ids);
    $meta_list = $wpdb->get_results($wpdb->prepare("SELECT {$object_column}, meta_key, meta_value FROM {$meta_table} WHERE {$object_column} IN ({$id_list})", $object_type), ARRAY_A);
    if (!empty($meta_list)) {
        foreach ($meta_list as $metarow) {
            $mpid = intval($metarow[$object_column]);
            $mkey = $metarow['meta_key'];
            $mval = $metarow['meta_value'];
            // Force subkeys to be array type:
            if (!isset($cache[$mpid]) || !is_array($cache[$mpid])) {
                $cache[$mpid] = array();
            }
            if (!isset($cache[$mpid][$mkey]) || !is_array($cache[$mpid][$mkey])) {
                $cache[$mpid][$mkey] = array();
            }
            // Add a value to the current pid/key:
            $cache[$mpid][$mkey][] = $mval;
        }
    }
    foreach ($object_ids as $id) {
        if (!isset($cache[$id])) {
            $cache[$id] = array();
        }
        foreach ($cache[$id] as $meta_key => $meta_value) {
            wp_cache_set($cache_key_prefix . '_' . $id . '_' . $meta_key, $meta_value, 'bp');
        }
    }
    return $cache;
}

 /**
  * Standard meta retrieval
  *
  * @param int   $post_id
  * @param bool  $saved
  * @param array $field
  *
  * @return array
  */
 public static function meta($post_id, $saved, $field)
 {
     $meta = get_post_meta($post_id, $field['id'], true);
     $meta = wp_parse_id_list($meta);
     $meta = array_filter($meta);
     // Use $field['std'] only when the meta box hasn't been saved (i.e. the first time we run)
     $meta = !$saved ? $field['std'] : $meta;
     // Escape attributes
     $meta = self::call($field, 'esc_meta', $meta);
     // Make sure meta value is an array for clonable and multiple fields
     if ($field['clone'] || $field['multiple']) {
         if (empty($meta) || !is_array($meta)) {
             /**
              * Note: if field is clonable, $meta must be an array with values
              * so that the foreach loop in self::show() runs properly
              * @see self::show()
              */
             $meta = $field['clone'] ? array('') : array();
         }
     }
     return $meta;
 }

 /**
  * Get post meta
  *
  * @param string   $key     Meta key. Required.
  * @param int|null $post_id Post ID. null for current post. Optional
  * @param array    $args    Array of arguments. Optional.
  *
  * @return mixed
  */
 public static function meta($key, $args = array(), $post_id = null)
 {
     $post_id = empty($post_id) ? get_the_ID() : $post_id;
     $args = wp_parse_args($args, array('type' => 'text', 'multiple' => false, 'clone' => false));
     // Always set 'multiple' true for following field types
     if (in_array($args['type'], array('checkbox_list', 'autocomplete', 'file', 'file_advanced', 'image', 'image_advanced', 'plupload_image', 'thickbox_image'))) {
         $args['multiple'] = true;
     }
     $field = array('id' => $key, 'type' => $args['type'], 'clone' => $args['clone'], 'multiple' => $args['multiple']);
     $class = RW_Meta_Box::get_class_name($field);
     switch ($args['type']) {
         case 'taxonomy_advanced':
             if (empty($args['taxonomy'])) {
                 break;
             }
             $meta = get_post_meta($post_id, $key, !$args['multiple']);
             $term_ids = wp_parse_id_list($meta);
             // Allow to pass more arguments to "get_terms"
             $func_args = wp_parse_args(array('include' => $term_ids, 'hide_empty' => false), $args);
             unset($func_args['type'], $func_args['taxonomy'], $func_args['multiple']);
             $meta = get_terms($args['taxonomy'], $func_args);
             break;
         case 'taxonomy':
             $meta = empty($args['taxonomy']) ? array() : get_the_terms($post_id, $args['taxonomy']);
             break;
         case 'map':
             $field = array('id' => $key, 'multiple' => false, 'clone' => false);
             $meta = RWMB_Map_Field::the_value($field, $args, $post_id);
             break;
         case 'oembed':
             $meta = RWMB_OEmbed_Field::the_value($field, $args, $post_id);
             break;
         default:
             $meta = call_user_func(array($class, 'get_value'), $field, $args, $post_id);
             break;
     }
     return apply_filters('rwmb_meta', $meta, $key, $args, $post_id);
 }

 function validate_args($args)
 {
     $args = wp_parse_args($args, self::$options->get_defaults());
     // Category IDs
     foreach (array('exclude_cat', 'include_cat') as $key) {
         if (!empty($args[$key])) {
             $args[$key] = wp_parse_id_list($args[$key]);
         }
     }
     // Anchors
     if ('both' != $args['format']) {
         $args['anchors'] = false;
     }
     // Block numeric
     if (array_key_exists('block_numeric', $args)) {
         if ('block' == $args['format'] && !array_key_exists('month_format', $args)) {
             $args['month_format'] = $args['block_numeric'] ? 'numeric' : 'short';
         }
         unset($args['block_numeric']);
     }
     // List format
     $args['list_format'] = trim($args['list_format']);
     return $args;
 }

 /**
  * List all unlocked achievements for the specified user
  *
  * @since Achievements (3.3)
  * @subcommand list
  * @synopsis --user_id=<id> [--format=<table|csv|json>]
  */
 public function _list($args, $assoc_args)
 {
     global $wpdb;
     $defaults = array('format' => 'table');
     $assoc_args = array_merge($defaults, $assoc_args);
     if (!$assoc_args['user_id'] || !($user = get_userdata($assoc_args['user_id']))) {
         WP_CLI::error('Invalid User ID specified.');
     }
     // Get the progress for this user
     $achievement_ids = $wpdb->get_col($wpdb->prepare("SELECT post_parent FROM {$wpdb->posts} WHERE post_type = %s AND post_author = %d", dpa_get_progress_post_type(), $user->ID));
     if (empty($achievement_ids)) {
         WP_CLI::error(sprintf('User ID %d has not unlocked any achievements.', $user->ID));
     }
     $achievement_ids = wp_parse_id_list($achievement_ids);
     $achievement_count = count($achievement_ids);
     $achievement_ids = implode(',', $achievement_ids);
     // Get the achievements
     $posts = $wpdb->get_results($wpdb->prepare("SELECT ID, post_title FROM {$wpdb->posts} WHERE ID in ({$achievement_ids}) AND post_type = %s AND post_status = %s ORDER BY post_title ASC", dpa_get_achievement_post_type(), 'publish'));
     if (empty($posts)) {
         WP_CLI::error(sprintf("No achievements unlocked by User ID %d have been found. This shouldn't happen.", $user->ID));
     }
     WP_CLI::success(sprintf('%d achievements have been unlocked by User ID %d:', $achievement_count, $user->ID));
     \WP_CLI\utils\format_items($assoc_args['format'], $posts, $this->fields);
 }

/**
 * Retrieve a list of pages.
 *
 * The defaults that can be overridden are the following: 'child_of',
 * 'sort_order', 'sort_column', 'post_title', 'hierarchical', 'exclude',
 * 'include', 'meta_key', 'meta_value','authors', 'number', and 'offset'.
 *
 * @since 1.5.0
 * @uses $wpdb
 *
 * @param mixed $args Optional. Array or string of options that overrides defaults.
 * @return array List of pages matching defaults or $args
 */
function &get_pages($args = '')
{
    global $wpdb;
    $defaults = array('child_of' => 0, 'sort_order' => 'ASC', 'sort_column' => 'post_title', 'hierarchical' => 1, 'exclude' => array(), 'include' => array(), 'meta_key' => '', 'meta_value' => '', 'authors' => '', 'parent' => -1, 'exclude_tree' => '', 'number' => '', 'offset' => 0, 'post_type' => 'page', 'post_status' => 'publish');
    $r = wp_parse_args($args, $defaults);
    extract($r, EXTR_SKIP);
    $number = (int) $number;
    $offset = (int) $offset;
    // Make sure the post type is hierarchical
    $hierarchical_post_types = get_post_types(array('hierarchical' => true));
    if (!in_array($post_type, $hierarchical_post_types)) {
        return false;
    }
    // Make sure we have a valid post status
    if (!in_array($post_status, get_post_stati())) {
        return false;
    }
    $cache = array();
    $key = md5(serialize(compact(array_keys($defaults))));
    if ($cache = wp_cache_get('get_pages', 'posts')) {
        if (is_array($cache) && isset($cache[$key])) {
            $pages = apply_filters('get_pages', $cache[$key], $r);
            return $pages;
        }
    }
    if (!is_array($cache)) {
        $cache = array();
    }
    $inclusions = '';
    if (!empty($include)) {
        $child_of = 0;
        //ignore child_of, parent, exclude, meta_key, and meta_value params if using include
        $parent = -1;
        $exclude = '';
        $meta_key = '';
        $meta_value = '';
        $hierarchical = false;
        $incpages = wp_parse_id_list($include);
        if (!empty($incpages)) {
            foreach ($incpages as $incpage) {
                if (empty($inclusions)) {
                    $inclusions = $wpdb->prepare(' AND ( ID = %d ', $incpage);
                } else {
                    $inclusions .= $wpdb->prepare(' OR ID = %d ', $incpage);
                }
            }
        }
    }
    if (!empty($inclusions)) {
        $inclusions .= ')';
    }
    $exclusions = '';
    if (!empty($exclude)) {
        $expages = wp_parse_id_list($exclude);
        if (!empty($expages)) {
            foreach ($expages as $expage) {
                if (empty($exclusions)) {
                    $exclusions = $wpdb->prepare(' AND ( ID <> %d ', $expage);
                } else {
                    $exclusions .= $wpdb->prepare(' AND ID <> %d ', $expage);
                }
            }
        }
    }
    if (!empty($exclusions)) {
        $exclusions .= ')';
    }
    $author_query = '';
    if (!empty($authors)) {
        $post_authors = preg_split('/[\\s,]+/', $authors);
        if (!empty($post_authors)) {
            foreach ($post_authors as $post_author) {
                //Do we have an author id or an author login?
                if (0 == intval($post_author)) {
                    $post_author = get_userdatabylogin($post_author);
                    if (empty($post_author)) {
                        continue;
                    }
                    if (empty($post_author->ID)) {
                        continue;
                    }
                    $post_author = $post_author->ID;
                }
                if ('' == $author_query) {
                    $author_query = $wpdb->prepare(' post_author = %d ', $post_author);
                } else {
                    $author_query .= $wpdb->prepare(' OR post_author = %d ', $post_author);
//.........这里部分代码省略.........