enmi-conf.org: comparison wp/wp-includes/class-wp-comment-query.php

equal deleted inserted replaced

-:c7c34916027a
+:177826044cd9
 	/**
 	 * Make private/protected methods readable for backward compatibility.
 	 *
 	 * @since 4.0.0
 	 *
-	 * @param callable $name      Method to call.
+	 * @param string   $name      Method to call.
 	 * @param array    $arguments Arguments to pass when calling.
 	 * @return mixed|false Return value of the callback, false otherwise.
 	 */
 	public function __call( $name, $arguments ) {
 		if ( 'get_search_sql' === $name ) {
 	 *                                                   Default empty.
 	 *     @type int          $post_parent               Post parent ID to retrieve affiliated comments for.
 	 *                                                   Default empty.
 	 *     @type string       $search                    Search term(s) to retrieve matching comments for.
 	 *                                                   Default empty.
-	 *     @type string       $status                    Comment status to limit results by. Accepts 'hold'
+	 *     @type string|array $status                    Comment stati to limit results by. Accepts an array
-	 *                                                   (`comment_status=0`), 'approve' (`comment_status=1`),
+	 *                                                   or space/comma-separated list of 'hold' (`comment_status=0`),
-	 *                                                   'all', or a custom comment status. Default 'all'.
+	 *                                                   'approve' (`comment_status=1`), 'all', or a custom
+	 *                                                   comment status. Default 'all'.
 	 *     @type string|array $type                      Include comments of a given type, or array of types.
 	 *                                                   Accepts 'comment', 'pings' (includes 'pingback' and
 	 *                                                   'trackback'), or anycustom type string. Default empty.
 	 *     @type array        $type__in                  Include comments from a given array of comment types.
 	 *                                                   Default empty.
 	 *                                                   object. 'flat' returns a flat array of found comments plus
 	 *                                                   their children. Pass `false` to leave out descendants.
 	 *                                                   The parameter is ignored (forced to `false`) when
 	 *                                                   `$fields` is 'ids' or 'counts'. Accepts 'threaded',
 	 *                                                   'flat', or false. Default: false.
 	 *     @type string       $cache_domain              Unique cache key to be produced when this query is stored in
 	 *                                                   an object cache. Default is 'core'.
 	 *     @type bool         $update_comment_meta_cache Whether to prime the metadata cache for found comments.
 	 *                                                   Default true.
 	 *     @type bool         $update_comment_post_cache Whether to prime the cache for comment posts.
 	 *                                                   Default false.
 	 * }
 	 */
 	public function __construct( $query = '' ) {
 		$this->query_var_defaults = array(
-			'author_email' => '',
+			'author_email'              => '',
-			'author_url' => '',
+			'author_url'                => '',
-			'author__in' => '',
+			'author__in'                => '',
-			'author__not_in' => '',
+			'author__not_in'            => '',
-			'include_unapproved' => '',
+			'include_unapproved'        => '',
-			'fields' => '',
+			'fields'                    => '',
-			'ID' => '',
+			'ID'                        => '',
-			'comment__in' => '',
+			'comment__in'               => '',
-			'comment__not_in' => '',
+			'comment__not_in'           => '',
-			'karma' => '',
+			'karma'                     => '',
-			'number' => '',
+			'number'                    => '',
-			'offset' => '',
+			'offset'                    => '',
-			'no_found_rows' => true,
+			'no_found_rows'             => true,
-			'orderby' => '',
+			'orderby'                   => '',
-			'order' => 'DESC',
+			'order'                     => 'DESC',
-			'paged' => 1,
+			'paged'                     => 1,
-			'parent' => '',
+			'parent'                    => '',
-			'parent__in' => '',
+			'parent__in'                => '',
-			'parent__not_in' => '',
+			'parent__not_in'            => '',
-			'post_author__in' => '',
+			'post_author__in'           => '',
-			'post_author__not_in' => '',
+			'post_author__not_in'       => '',
-			'post_ID' => '',
+			'post_ID'                   => '',
-			'post_id' => 0,
+			'post_id'                   => 0,
-			'post__in' => '',
+			'post__in'                  => '',
-			'post__not_in' => '',
+			'post__not_in'              => '',
-			'post_author' => '',
+			'post_author'               => '',
-			'post_name' => '',
+			'post_name'                 => '',
-			'post_parent' => '',
+			'post_parent'               => '',
-			'post_status' => '',
+			'post_status'               => '',
-			'post_type' => '',
+			'post_type'                 => '',
-			'status' => 'all',
+			'status'                    => 'all',
-			'type' => '',
+			'type'                      => '',
-			'type__in' => '',
+			'type__in'                  => '',
-			'type__not_in' => '',
+			'type__not_in'              => '',
-			'user_id' => '',
+			'user_id'                   => '',
-			'search' => '',
+			'search'                    => '',
-			'count' => false,
+			'count'                     => false,
-			'meta_key' => '',
+			'meta_key'                  => '',
-			'meta_value' => '',
+			'meta_value'                => '',
-			'meta_query' => '',
+			'meta_query'                => '',
-			'date_query' => null, // See WP_Date_Query
+			'date_query'                => null, // See WP_Date_Query
-			'hierarchical' => false,
+			'hierarchical'              => false,
-			'cache_domain' => 'core',
+			'cache_domain'              => 'core',
 			'update_comment_meta_cache' => true,
 			'update_comment_post_cache' => false,
 		);
 		if ( ! empty( $query ) ) {
 	/**
 	 * Parse arguments passed to the comment query with default query parameters.
 	 *
 	 * @since 4.2.0 Extracted from WP_Comment_Query::query().
-	 *
 	 *
 	 * @param string|array $query WP_Comment_Query arguments. See WP_Comment_Query::__construct()
 	 */
 	public function parse_query( $query = '' ) {
 		if ( empty( $query ) ) {
 		 * but ignore 'fields', which does not affect query results.
 		 */
 		$_args = wp_array_slice_assoc( $this->query_vars, array_keys( $this->query_var_defaults ) );
 		unset( $_args['fields'] );
-		$key = md5( serialize( $_args ) );
+		$key          = md5( serialize( $_args ) );
 		$last_changed = wp_cache_get_last_changed( 'comment' );
 		$cache_key   = "get_comments:$key:$last_changed";
 		$cache_value = wp_cache_get( $cache_key, 'comment' );
 		if ( false === $cache_value ) {
 		/**
 		 * Filters the comment query results.
 		 *
 		 * @since 3.1.0
 		 *
-		 * @param array            $_comments An array of comments.
+		 * @param WP_Comment[]     $_comments An array of comments.
-		 * @param WP_Comment_Query $this     Current instance of WP_Comment_Query (passed by reference).
+		 * @param WP_Comment_Query $this      Current instance of WP_Comment_Query (passed by reference).
 		 */
 		$_comments = apply_filters_ref_array( 'the_comments', array( $_comments, &$this ) );
 		// Convert to WP_Comment instances
 		$comments = array_map( 'get_comment', $_comments );
 	 * Used internally to get a list of comment IDs matching the query vars.
 	 *
 	 * @since 4.4.0
 	 *
 	 * @global wpdb $wpdb WordPress database abstraction object.
+	 *
+	 * @return int|array A single count of comment IDs if a count query. An array of comment IDs if a full query.
 	 */
 	protected function get_comment_ids() {
 		global $wpdb;
 		// 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'];
+		$statuses       = wp_parse_list( $this->query_vars['status'] );
-		if ( ! is_array( $statuses ) ) {
-			$statuses = preg_split( '/[\s,]+/', $statuses );
+		// Empty 'status' should be interpreted as 'all'.
+		if ( empty( $statuses ) ) {
+			$statuses = array( 'all' );
 		}
 		// 'any' overrides other statuses.
 		if ( ! in_array( 'any', $statuses ) ) {
 			foreach ( $statuses as $status ) {
 				switch ( $status ) {
-					case 'hold' :
+					case 'hold':
 						$status_clauses[] = "comment_approved = '0'";
 						break;
-					case 'approve' :
+					case 'approve':
 						$status_clauses[] = "comment_approved = '1'";
 						break;
-					case 'all' :
+					case 'all':
-					case '' :
+					case '':
 						$status_clauses[] = "( comment_approved = '0' OR comment_approved = '1' )";
 						break;
-					default :
+					default:
-						$status_clauses[] = $wpdb->prepare( "comment_approved = %s", $status );
+						$status_clauses[] = $wpdb->prepare( 'comment_approved = %s', $status );
 						break;
 				}
 			}
 			if ( ! empty( $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'];
+			$include_unapproved = wp_parse_list( $this->query_vars['include_unapproved'] );
-			// Accepts arrays or comma-separated strings.
+			$unapproved_ids    = array();
-			if ( ! is_array( $include_unapproved ) ) {
+			$unapproved_emails = array();
-				$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[] = $wpdb->prepare( "( user_id = %d AND comment_approved = '0' )", $unapproved_identifier );
-				// Otherwise we match against email addresses.
+					// Otherwise we match against email addresses.
 				} else {
 					$approved_clauses[] = $wpdb->prepare( "( comment_author_email = %s AND comment_approved = '0' )", $unapproved_identifier );
 				}
 			}
 		}
 		} 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();
+			$orderby_array            = array();
-			$found_orderby_comment_ID = false;
+			$found_orderby_comment_id = false;
 			foreach ( $ordersby as $_key => $_value ) {
 				if ( ! $_value ) {
 					continue;
 				}
 				if ( is_int( $_key ) ) {
 					$_orderby = $_value;
-					$_order = $order;
+					$_order   = $order;
 				} else {
 					$_orderby = $_key;
-					$_order = $_value;
+					$_order   = $_value;
 				}
-				if ( ! $found_orderby_comment_ID && in_array( $_orderby, array( 'comment_ID', 'comment__in' ) ) ) {
+				if ( ! $found_orderby_comment_id && in_array( $_orderby, array( 'comment_ID', 'comment__in' ) ) ) {
-					$found_orderby_comment_ID = true;
+					$found_orderby_comment_id = true;
 				}
 				$parsed = $this->parse_orderby( $_orderby );
 				if ( ! $parsed ) {
 			if ( empty( $orderby_array ) ) {
 				$orderby_array[] = "$wpdb->comments.comment_date_gmt $order";
 			}
 			// To ensure determinate sorting, always include a comment_ID clause.
-			if ( ! $found_orderby_comment_ID ) {
+			if ( ! $found_orderby_comment_id ) {
-				$comment_ID_order = '';
+				$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];
+						$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 ) {
+				if ( ! $comment_id_order ) {
 					foreach ( $orderby_array as $orderby_clause ) {
 						if ( false !== strpos( 'ASC', $orderby_clause ) ) {
-							$comment_ID_order = 'ASC';
+							$comment_id_order = 'ASC';
 						} else {
-							$comment_ID_order = 'DESC';
+							$comment_id_order = 'DESC';
 						}
 						break;
 					}
 				}
 				// Default to DESC.
-				if ( ! $comment_ID_order ) {
+				if ( ! $comment_id_order ) {
-					$comment_ID_order = 'DESC';
+					$comment_id_order = 'DESC';
 				}
-				$orderby_array[] = "$wpdb->comments.comment_ID $comment_ID_order";
+				$orderby_array[] = "$wpdb->comments.comment_ID $comment_id_order";
 			}
 			$orderby = implode( ', ', $orderby_array );
 		} else {
 			$orderby = "$wpdb->comments.comment_date_gmt $order";
 		}
 		$number = absint( $this->query_vars['number'] );
 		$offset = absint( $this->query_vars['offset'] );
-		$paged = absint( $this->query_vars['paged'] );
+		$paged  = absint( $this->query_vars['paged'] );
+		$limits = '';
 		if ( ! empty( $number ) ) {
 			if ( $offset ) {
 				$limits = 'LIMIT ' . $offset . ',' . $number;
 			} else {
 			$this->sql_clauses['where']['karma'] = $wpdb->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'] ),
+			'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 ) {
 			foreach ( $_raw_types as $type ) {
 				switch ( $type ) {
 					// An empty translates to 'all', for backward compatibility
 					case '':
-					case 'all' :
+					case 'all':
 						break;
 					case 'comment':
 					case 'comments':
 						$comment_types[ $operator ][] = "''";
 				}
 			}
 			if ( ! empty( $comment_types[ $operator ] ) ) {
 				$types_sql = implode( ', ', $comment_types[ $operator ] );
-				$this->sql_clauses['where']['comment_type__' . strtolower( str_replace( ' ', '_', $operator ) ) ] = "comment_type $operator ($types_sql)";
+				$this->sql_clauses['where'][ 'comment_type__' . strtolower( str_replace( ' ', '_', $operator ) ) ] = "comment_type $operator ($types_sql)";
 			}
 		}
 		$parent = $this->query_vars['parent'];
 		if ( $this->query_vars['hierarchical'] && ! $parent ) {
 			$this->sql_clauses['where']['search'] = preg_replace( '/^\s*AND\s*/', '', $search_sql );
 		}
 		// If any post-related query vars are passed, join the posts table.
 		$join_posts_table = false;
-		$plucked = wp_array_slice_assoc( $this->query_vars, array( 'post_author', 'post_name', 'post_parent' ) );
+		$plucked          = wp_array_slice_assoc( $this->query_vars, array( 'post_author', 'post_name', 'post_parent' ) );
-		$post_fields = array_filter( $plucked );
+		$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' );
+				$esses                                     = array_fill( 0, count( (array) $field_value ), '%s' );
 				$this->sql_clauses['where'][ $field_name ] = $wpdb->prepare( " {$wpdb->posts}.{$field_name} IN (" . implode( ',', $esses ) . ')', $field_value );
 			}
 		}
 		// 'post_status' and 'post_type' are handled separately, due to the specialized behavior of 'any'.
 					continue;
 				}
 				$join_posts_table = true;
-				$esses = array_fill( 0, count( $q_values ), '%s' );
+				$esses                                     = array_fill( 0, count( $q_values ), '%s' );
-				$this->sql_clauses['where'][ $field_name ] = $wpdb->prepare( " {$wpdb->posts}.{$field_name} IN (" . implode( ',', $esses ) . ")", $q_values );
+				$this->sql_clauses['where'][ $field_name ] = $wpdb->prepare( " {$wpdb->posts}.{$field_name} IN (" . implode( ',', $esses ) . ')', $q_values );
 			}
 		}
 		// Comment author IDs for an IN clause.
 		if ( ! empty( $this->query_vars['author__in'] ) ) {
 			$this->sql_clauses['where']['author__not_in'] = 'user_id NOT IN ( ' . implode( ',', wp_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;
+			$join_posts_table                              = true;
 			$this->sql_clauses['where']['post_author__in'] = 'post_author IN ( ' . implode( ',', wp_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;
+			$join_posts_table                                  = true;
 			$this->sql_clauses['where']['post_author__not_in'] = 'post_author NOT IN ( ' . implode( ',', wp_parse_id_list( $this->query_vars['post_author__not_in'] ) ) . ' )';
 		}
-		$join = '';
+		$join    = '';
+		$groupby = '';
 		if ( $join_posts_table ) {
 			$join .= "JOIN $wpdb->posts ON $wpdb->posts.ID = $wpdb->comments.comment_post_ID";
 		}
 				$groupby = "{$wpdb->comments}.comment_ID";
 			}
 		}
 		if ( ! empty( $this->query_vars['date_query'] ) && is_array( $this->query_vars['date_query'] ) ) {
-			$this->date_query = new WP_Date_Query( $this->query_vars['date_query'], 'comment_date' );
+			$this->date_query                         = new WP_Date_Query( $this->query_vars['date_query'], 'comment_date' );
 			$this->sql_clauses['where']['date_query'] = preg_replace( '/^\s*AND\s*/', '', $this->date_query->get_sql() );
 		}
 		$where = implode( ' AND ', $this->sql_clauses['where'] );
 		/**
 		 * Filters the comment query clauses.
 		 *
 		 * @since 3.1.0
 		 *
-		 * @param array            $pieces A compacted array of comment query clauses.
+		 * @param string[]         $pieces An associative array of comment query clauses.
-		 * @param WP_Comment_Query $this  Current instance of WP_Comment_Query (passed by reference).
+		 * @param WP_Comment_Query $this   Current instance of WP_Comment_Query (passed by reference).
 		 */
 		$clauses = apply_filters_ref_array( 'comments_clauses', array( compact( $pieces ), &$this ) );
-		$fields = isset( $clauses[ 'fields' ] ) ? $clauses[ 'fields' ] : '';
+		$fields  = isset( $clauses['fields'] ) ? $clauses['fields'] : '';
-		$join = isset( $clauses[ 'join' ] ) ? $clauses[ 'join' ] : '';
+		$join    = isset( $clauses['join'] ) ? $clauses['join'] : '';
-		$where = isset( $clauses[ 'where' ] ) ? $clauses[ 'where' ] : '';
+		$where   = isset( $clauses['where'] ) ? $clauses['where'] : '';
-		$orderby = isset( $clauses[ 'orderby' ] ) ? $clauses[ 'orderby' ] : '';
+		$orderby = isset( $clauses['orderby'] ) ? $clauses['orderby'] : '';
-		$limits = isset( $clauses[ 'limits' ] ) ? $clauses[ 'limits' ] : '';
+		$limits  = isset( $clauses['limits'] ) ? $clauses['limits'] : '';
-		$groupby = isset( $clauses[ 'groupby' ] ) ? $clauses[ 'groupby' ] : '';
+		$groupby = isset( $clauses['groupby'] ) ? $clauses['groupby'] : '';
 		$this->filtered_where_clause = $where;
 		if ( $where ) {
 			$where = 'WHERE ' . $where;
 	 *
 	 * @since 4.4.0
 	 *
 	 * @global wpdb $wpdb WordPress database abstraction object.
 	 *
-	 * @param array $comments Array of top-level comments whose descendants should be filled in.
+	 * @param WP_Comment[] $comments Array of top-level comments whose descendants should be filled in.
 	 * @return array
 	 */
 	protected function fill_descendants( $comments ) {
 		global $wpdb;
 		$levels = array(
 			0 => wp_list_pluck( $comments, 'comment_ID' ),
 		);
-		$key = md5( serialize( wp_array_slice_assoc( $this->query_vars, array_keys( $this->query_var_defaults ) ) ) );
+		$key          = md5( serialize( wp_array_slice_assoc( $this->query_vars, array_keys( $this->query_var_defaults ) ) ) );
 		$last_changed = wp_cache_get_last_changed( 'comment' );
 		// Fetch an entire level of the descendant tree at a time.
-		$level = 0;
+		$level        = 0;
 		$exclude_keys = array( 'parent', 'parent__in', 'parent__not_in' );
 		do {
 			// Parent-child relationships may be cached. Only query for those that are not.
-			$child_ids = $uncached_parent_ids = array();
+			$child_ids   = $uncached_parent_ids = array();
 			$_parent_ids = $levels[ $level ];
 			foreach ( $_parent_ids as $parent_id ) {
-				$cache_key = "get_comment_child_ids:$parent_id:$key:$last_changed";
+				$cache_key        = "get_comment_child_ids:$parent_id:$key:$last_changed";
 				$parent_child_ids = wp_cache_get( $cache_key, 'comment' );
 				if ( false !== $parent_child_ids ) {
 					$child_ids = array_merge( $child_ids, $parent_child_ids );
 				} else {
 					$uncached_parent_ids[] = $parent_id;
 				// Cache parent-child relationships.
 				$parent_map = array_fill_keys( $uncached_parent_ids, array() );
 				foreach ( $level_comments as $level_comment ) {
 					$parent_map[ $level_comment->comment_parent ][] = $level_comment->comment_ID;
-					$child_ids[] = $level_comment->comment_ID;
+					$child_ids[]                                    = $level_comment->comment_ID;
 				}
 				foreach ( $parent_map as $parent_id => $children ) {
 					$cache_key = "get_comment_child_ids:$parent_id:$key:$last_changed";
 					wp_cache_set( $cache_key, $children, 'comment' );
 				$_c = get_comment( $c->comment_ID );
 				// If the comment isn't in the reference array, it goes in the top level of the thread.
 				if ( ! isset( $ref[ $c->comment_parent ] ) ) {
 					$threaded_comments[ $_c->comment_ID ] = $_c;
-					$ref[ $_c->comment_ID ] = $threaded_comments[ $_c->comment_ID ];
+					$ref[ $_c->comment_ID ]               = $threaded_comments[ $_c->comment_ID ];
-				// Otherwise, set it as a child of its parent.
+					// Otherwise, set it as a child of its parent.
 				} else {
 					$ref[ $_c->comment_parent ]->add_child( $_c );
 					$ref[ $_c->comment_ID ] = $ref[ $_c->comment_parent ]->get_child( $_c->comment_ID );
 				}
 		$searches = array();
 		foreach ( $cols as $col ) {
 			$searches[] = $wpdb->prepare( "$col LIKE %s", $like );
 		}
-		return ' AND (' . implode(' OR ', $searches) . ')';
+		return ' AND (' . implode( ' OR ', $searches ) . ')';
 	}
 	/**
 	 * Parse and sanitize 'orderby' keys passed to the comment query.
 	 *
 			$parsed = "$wpdb->commentmeta.meta_value";
 		} elseif ( $orderby == 'meta_value_num' ) {
 			$parsed = "$wpdb->commentmeta.meta_value+0";
 		} elseif ( $orderby == 'comment__in' ) {
 			$comment__in = implode( ',', array_map( 'absint', $this->query_vars['comment__in'] ) );
-			$parsed = "FIELD( {$wpdb->comments}.comment_ID, $comment__in )";
+			$parsed      = "FIELD( {$wpdb->comments}.comment_ID, $comment__in )";
 		} elseif ( in_array( $orderby, $allowed_keys ) ) {
 			if ( isset( $meta_query_clauses[ $orderby ] ) ) {
 				$meta_clause = $meta_query_clauses[ $orderby ];
-				$parsed = sprintf( "CAST(%s.meta_value AS %s)", esc_sql( $meta_clause['alias'] ), esc_sql( $meta_clause['cast'] ) );
+				$parsed      = sprintf( 'CAST(%s.meta_value AS %s)', esc_sql( $meta_clause['alias'] ), esc_sql( $meta_clause['cast'] ) );
 			} else {
 				$parsed = "$wpdb->comments.$orderby";
 			}
 		}

changeset 9	177826044cd9
parent 7	cf61fcea0001
child 16	a86126ab1dd4