# automatorwp/6.0.2/libraries/ct/includes/class-ct-query.php AutomatorWP – No-Code Workflow Automation, Integration & Webhooks Plugin, now with AI, version 6.0.2. 1,105 lines. - Page: https://pluginprobe.com/plugins/automatorwp/6.0.2/code/libraries/ct/includes/class-ct-query.php - Raw: https://pluginprobe.com/plugins/automatorwp/6.0.2/raw/libraries/ct/includes/class-ct-query.php - Modified: 2026-09-14T10:29:36+00:00 Line numbers below start at 1. Link to a line or a range by appending a fragment to the page URL, for example `https://pluginprobe.com/plugins/automatorwp/6.0.2/code/libraries/ct/includes/class-ct-query.php#L10-L20`. ```php , Ruben Garcia * * @since 1.0.0 */ // Exit if accessed directly defined( 'ABSPATH' ) || exit; if ( ! class_exists( 'CT_Query' ) ) : class CT_Query { /** * Query vars set by the user * * @since 1.0.0 * @access public * @var array */ public $query; /** * Query vars, after parsing * * @since 1.0.0 * @access public * @var array */ public $query_vars = array(); /** * Holds the data for a single object that is queried. * * Holds the contents of a post, page, category, attachment. * * @since 1.0.0 * @access public * @var object|array */ public $queried_object; /** * The ID of the queried object. * * @since 1.0.0 * @access public * @var int */ public $queried_object_id; /** * Get post database query. * * @since 1.0.0 * @access public * @var string */ public $request; /** * List of posts. * * @since 1.0.0 * @access public * @var array */ public $results; /** * The amount of posts for the current query. * * @since 1.0.0 * @access public * @var int */ public $result_count = 0; /** * Index of the current item in the loop. * * @since 1.0.0 * @access public * @var int */ public $current_result = -1; /** * Whether the loop has started and the caller is in the loop. * * @since 1.0.0 * @access public * @var bool */ public $in_the_loop = false; /** * The current post. * * @since 1.0.0 * @access public * @var WP_Post */ public $result; /** * The amount of found posts for the current query. * * If limit clause was not used, equals $post_count. * * @since 1.0.0 * @access public * @var int */ public $found_results = 0; /** * The amount of pages. * * @since 1.0.0 * @access public * @var int */ public $max_num_pages = 0; /** * stopwords used when parsing search terms * * @since 1.0.0 * @access public * @var array */ public $stopwords = array(); public function __construct( $query = '' ) { $this->init(); $this->query = $this->query_vars = wp_parse_args( $query ); } public function init() { unset($this->results); unset($this->query); $this->query_vars = array(); unset($this->queried_object); unset($this->queried_object_id); $this->result_count = 0; $this->current_result = -1; $this->in_the_loop = false; unset( $this->request ); unset( $this->result ); $this->found_results = 0; $this->max_num_pages = 0; $this->stopwords = array(); } public function set( $query_var, $value ) { $this->query_vars[$query_var] = $value; } public function get_results() { global $wpdb, $ct_table; $this->parse_query(); /** * Fires after the query variable object is created, but before the actual query is run. * * Note: If using conditional tags, use the method versions within the passed instance * (e.g. $this->is_main_query() instead of is_main_query()). This is because the functions * like is_main_query() test against the global $wp_query instance, not the passed one. * * @since 1.0.0 * * @param CT_Query &$this The CT_Query instance (passed by reference). */ do_action_ref_array( 'ct_pre_get_results', array( &$this ) ); // Shorthand. $q = &$this->query_vars; // Fill again in case pre_get_posts unset some vars. $q = $this->fill_query_vars($q); // Suppress filters if ( ! isset($q['suppress_filters']) ) $q['suppress_filters'] = false; if ( empty( $q['items_per_page'] ) ) { $q['items_per_page'] = get_option( 'items_per_page', 20 ); } // Pagination if ( ! isset( $q['nopaging'] ) ) { if ( $q['items_per_page'] == -1 ) { $q['nopaging'] = true; } else { $q['nopaging'] = false; } } // Items per page $q['items_per_page'] = (int) $q['items_per_page']; if ( $q['items_per_page'] < -1 ) $q['items_per_page'] = abs($q['items_per_page']); elseif ( $q['items_per_page'] == 0 ) $q['items_per_page'] = 1; // page 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 = "{$ct_table->db->table_name}.{$ct_table->db->primary_key}"; break; default: $fields = "{$ct_table->db->table_name}.*"; } // First let's clear some variables $distinct = ''; $where = ''; $limits = ''; $join = ''; $search = ''; $groupby = ''; $orderby = ''; $page = 1; // If a search pattern is specified, load the posts that match. if ( strlen( $q['s'] ) ) { $search = $this->parse_search( $q ); } if ( ! $q['suppress_filters'] ) { /** * Filters the search SQL that is used in the WHERE clause of WP_Query. * * @since 1.0.0 * * @param string $search Search SQL for WHERE clause. * @param WP_Query $this The current WP_Query object. */ $search = apply_filters_ref_array( 'ct_query_search', array( $search, &$this ) ); } $where .= $search; // Rand order by $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 { // Default order by primary key $orderby = "{$ct_table->db->table_name}.{$ct_table->db->primary_key} " . $q['order']; } } elseif ( 'none' == $q['orderby'] ) { $orderby = ''; } else { $orderby_array = array(); if ( is_array( $q['orderby'] ) ) { foreach ( $q['orderby'] as $_orderby => $order ) { $orderby = wp_slash( urldecode( $_orderby ) ); $parsed = $this->parse_orderby( $orderby ); // Only allow certain values for safety. if ( ! $parsed ) { continue; } $orderby_array[] = $parsed . ' ' . $this->parse_order( $order ); } $orderby = implode( ', ', $orderby_array ); } else { $q['orderby'] = wp_slash( urldecode( $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 = "{$ct_table->db->table_name}.{$ct_table->db->primary_key} " . $q['order']; } elseif ( ! empty( $q['order'] ) ) { $orderby .= " {$q['order']}"; } } } /* * Apply filters on where and join prior to paging so that any * manipulations to them are reflected in the paging by day queries. */ if ( !$q['suppress_filters'] ) { /** * Filters the WHERE clause of the query. * * @since 1.0.0 * * @param string $where The WHERE clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $where = apply_filters_ref_array( 'ct_query_where', array( $where, &$this ) ); /** * Filters the JOIN clause of the query. * * @since 1.0.0 * * @param string $where The JOIN clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $join = apply_filters_ref_array( 'ct_query_join', array( $join, &$this ) ); } // Paging if ( empty($q['nopaging']) ) { $page = absint($q['paged']); if ( !$page ) $page = 1; // If 'offset' is provided, it takes precedence over 'paged'. if ( isset( $q['offset'] ) && is_numeric( $q['offset'] ) ) { $q['offset'] = absint( $q['offset'] ); $pgstrt = $q['offset'] . ', '; } else { $pgstrt = absint( ( $page - 1 ) * $q['items_per_page'] ) . ', '; } $limits = 'LIMIT ' . $pgstrt . $q['items_per_page']; } $pieces = array( 'where', 'groupby', 'join', 'orderby', 'distinct', 'fields', 'limits' ); /* * Apply post-paging filters on where and join. Only plugins that * manipulate paging queries should use these hooks. */ if ( !$q['suppress_filters'] ) { /** * Filters the WHERE clause of the query. * * Specifically for manipulating paging queries. * * @since 1.0.0 * * @param string $where The WHERE clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $where = apply_filters_ref_array( 'ct_query_where_paged', array( $where, &$this ) ); /** * Filters the GROUP BY clause of the query. * * @since 1.0.0 * * @param string $groupby The GROUP BY clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $groupby = apply_filters_ref_array( 'ct_query_groupby', array( $groupby, &$this ) ); /** * Filters the JOIN clause of the query. * * Specifically for manipulating paging queries. * * @since 1.0.0 * * @param string $join The JOIN clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $join = apply_filters_ref_array( 'ct_query_join_paged', array( $join, &$this ) ); /** * Filters the ORDER BY clause of the query. * * @since 1.0.0 * * @param string $orderby The ORDER BY clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $orderby = apply_filters_ref_array( 'ct_query_orderby', array( $orderby, &$this ) ); /** * Filters the DISTINCT clause of the query. * * @since 1.0.0 * * @param string $distinct The DISTINCT clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $distinct = apply_filters_ref_array( 'ct_query_distinct', array( $distinct, &$this ) ); /** * Filters the LIMIT clause of the query. * * @since 1.0.0 * * @param string $limits The LIMIT clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $limits = apply_filters_ref_array( 'ct_querylimits', array( $limits, &$this ) ); /** * Filters the SELECT clause of the query. * * @since 1.0.0 * * @param string $fields The SELECT clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $fields = apply_filters_ref_array( 'ct_query_fields', array( $fields, &$this ) ); /** * Filters all query clauses at once, for convenience. * * Covers the WHERE, GROUP BY, JOIN, ORDER BY, DISTINCT, * fields (SELECT), and LIMITS clauses. * * @since 1.0.0 * * @param array $clauses The list of clauses for the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $clauses = (array) apply_filters_ref_array( 'ct_query_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 1.0.0 * * @param string $selection The assembled selection query. */ do_action( 'ct_query_selection', $where . $groupby . $orderby . $limits . $join ); /* * Filters again for the benefit of caching plugins. * Regular plugins should use the hooks above. */ if ( !$q['suppress_filters'] ) { /** * Filters the WHERE clause of the query. * * For use by caching plugins. * * @since 1.0.0 * * @param string $where The WHERE clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $where = apply_filters_ref_array( 'ct_query_where_request', array( $where, &$this ) ); /** * Filters the GROUP BY clause of the query. * * For use by caching plugins. * * @since 1.0.0 * * @param string $groupby The GROUP BY clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $groupby = apply_filters_ref_array( 'ct_query_groupby_request', array( $groupby, &$this ) ); /** * Filters the JOIN clause of the query. * * For use by caching plugins. * * @since 1.0.0 * * @param string $join The JOIN clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $join = apply_filters_ref_array( 'ct_query_join_request', array( $join, &$this ) ); /** * Filters the ORDER BY clause of the query. * * For use by caching plugins. * * @since 1.0.0 * * @param string $orderby The ORDER BY clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $orderby = apply_filters_ref_array( 'ct_query_orderby_request', array( $orderby, &$this ) ); /** * Filters the DISTINCT clause of the query. * * For use by caching plugins. * * @since 1.0.0 * * @param string $distinct The DISTINCT clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $distinct = apply_filters_ref_array( 'ct_query_distinct_request', array( $distinct, &$this ) ); /** * Filters the SELECT clause of the query. * * For use by caching plugins. * * @since 1.0.0 * * @param string $fields The SELECT clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $fields = apply_filters_ref_array( 'ct_query_fields_request', array( $fields, &$this ) ); /** * Filters the LIMIT clause of the query. * * For use by caching plugins. * * @since 1.0.0 * * @param string $limits The LIMIT clause of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $limits = apply_filters_ref_array( 'ct_query_limits_request', array( $limits, &$this ) ); /** * Filters all query clauses at once, for convenience. * * For use by caching plugins. * * Covers the WHERE, GROUP BY, JOIN, ORDER BY, DISTINCT, * fields (SELECT), and LIMITS clauses. * * @since 1.0.0 * * @param array $pieces The pieces of the query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $clauses = (array) apply_filters_ref_array( 'ct_query_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 {$ct_table->db->table_name} $join WHERE 1=1 $where $groupby $orderby $limits"; if ( !$q['suppress_filters'] ) { /** * Filters the completed SQL query before sending. * * @since 1.0.0 * * @param string $request The complete SQL query. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $this->request = apply_filters_ref_array( 'ct_query_request', array( $this->request, &$this ) ); } /** * Filters the posts array before the query takes place. * * Return a non-null value to bypass WordPress's default post queries. * * Filtering functions that require pagination information are encouraged to set * the `found_posts` and `max_num_pages` properties of the WP_Query object, * passed to the filter by reference. If WP_Query does not perform a database * query, it will not have enough information to generate these values itself. * * @since 1.0.0 * * @param array|null $posts Return an array of post data to short-circuit WP's query, * or null to allow WP to run its normal queries. * @param WP_Query $this The WP_Query instance, passed by reference. */ $this->results = apply_filters_ref_array( 'ct_results_pre_query', array( null, &$this ) ); if ( 'ids' == $q['fields'] ) { if ( null === $this->results ) { $this->results = $wpdb->get_col( $this->request ); } $this->results = array_map( 'intval', $this->results ); $this->result_count = count( $this->results ); $this->set_found_results( $q, $limits ); return $this->results; } if ( null === $this->results ) { $split_the_query = ( $old_request == $this->request && "{$ct_table->db->table_name}.*" == $fields && !empty( $limits ) && $q['items_per_page'] < 500 ); /** * Filters whether to split the query. * * Splitting the query will cause it to fetch just the IDs of the found posts * (and then individually fetch each post by ID), rather than fetching every * complete row at once. One massive result vs. many small results. * * @since 1.0.0 * * @param bool $split_the_query Whether or not to split the query. * @param WP_Query $this The WP_Query instance. */ $split_the_query = apply_filters( 'split_the_query', $split_the_query, $this ); if ( $split_the_query ) { // First get the IDs and then fill in the objects $this->request = "SELECT $found_rows $distinct {$ct_table->db->table_name}.{$ct_table->db->primary_key} FROM {$ct_table->db->table_name} $join WHERE 1=1 $where $groupby $orderby $limits"; /** * Filters the Post IDs SQL request before sending. * * @since 1.0.0 * * @param string $request The post ID request. * @param WP_Query $this The WP_Query instance. */ $this->request = apply_filters( 'ct_query_request_ids', $this->request, $this ); $ids = $wpdb->get_col( $this->request ); if ( $ids ) { $this->results = $ids; $this->set_found_results( $q, $limits ); // TODO: Add caching utility //_prime_post_caches( $ids, $q['update_post_term_cache'], $q['update_post_meta_cache'] ); } else { $this->results = array(); } } else { $this->results = $wpdb->get_results( $this->request ); $this->set_found_results( $q, $limits ); } } // Convert to objects. if ( $this->results ) { $this->results = array_map( 'ct_get_object', $this->results ); } if ( ! $q['suppress_filters'] ) { /** * Filters the raw post results array, prior to status checks. * * @since 1.0.0 * * @param array $posts The post results array. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $this->results = apply_filters_ref_array( 'ct_query_results', array( $this->results, &$this ) ); } if ( ! $q['suppress_filters'] ) { /** * Filters the array of retrieved posts after they've been fetched and * internally processed. * * @since 1.0.0 * * @param array $posts The array of retrieved posts. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $this->results = apply_filters_ref_array( 'ct_the_results', array( $this->results, &$this ) ); } // Ensure that any posts added/modified via one of the filters above are // of the type WP_Post and are filtered. if ( $this->results ) { $this->result_count = count( $this->results ); $this->results = array_map( 'ct_get_object', $this->results ); //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->result_count = 0; $this->results = array(); } return $this->results; } public function parse_query( $query = '' ) { if ( ! empty( $query ) ) { $this->init(); $this->query = $this->query_vars = wp_parse_args( $query ); } elseif ( ! isset( $this->query ) ) { $this->query = $this->query_vars; } $this->query_vars = $this->fill_query_vars($this->query_vars); $qv = &$this->query_vars; $qv['paged'] = absint($qv['paged']); // Fairly insane upper bound for search string lengths. if ( ! is_scalar( $qv['s'] ) || ( ! empty( $qv['s'] ) && strlen( $qv['s'] ) > 1600 ) ) { $qv['s'] = ''; } /** * Fires after the main query vars have been parsed. * * @since 1.0.0 * * @param WP_Query &$this The WP_Query instance (passed by reference). */ do_action_ref_array( 'ct_parse_query', array( &$this ) ); } /** * Fills in the query variables, which do not exist within the parameter. * * @since 1.0.0 * @access public * * @param array $array Defined query variables. * @return array Complete query variables with undefined ones filled in empty. */ public function fill_query_vars($array) { $keys = array( 'paged' , 's' , 'sentence' , 'fields' ); foreach ( $keys as $key ) { if ( ! isset($array[$key]) ) $array[$key] = ''; } return $array; } /** * Generate SQL for the WHERE clause based on passed search terms. * * @since 1.0.0 * * @param array $q Query variables. * @return string WHERE clause. */ protected function parse_search( &$q ) { global $wpdb, $ct_table; $search = ''; $search_fields = apply_filters( "ct_query_{$ct_table->name}_search_fields", array() ); if( empty( $search_fields ) ) { return $search; } // added slashes screw with quote grouping when done early, so done later $q['s'] = stripslashes( $q['s'] ); if ( empty( $_GET['s'] ) ) $q['s'] = urldecode( $q['s'] ); // there are no line breaks in fields $q['s'] = str_replace( array( "\r", "\n" ), '', $q['s'] ); $q['search_terms_count'] = 1; if ( ! empty( $q['sentence'] ) ) { $q['search_terms'] = array( $q['s'] ); } else { if ( preg_match_all( '/".*?("|$)|((?<=[\t ",+])|^)[^\t ",+]+/', $q['s'], $matches ) ) { $q['search_terms_count'] = count( $matches[0] ); $q['search_terms'] = $this->parse_search_terms( $matches[0] ); // if the search string has only short terms or stopwords, or is 10+ terms long, match it as sentence if ( empty( $q['search_terms'] ) || count( $q['search_terms'] ) > 9 ) $q['search_terms'] = array( $q['s'] ); } else { $q['search_terms'] = array( $q['s'] ); } } $n = ! empty( $q['exact'] ) ? '' : '%'; $searchand = ''; $q['search_orderby_title'] = array(); /** * Filters the prefix that indicates that a search term should be excluded from results. * * @since 1.0.0 * * @param string $exclusion_prefix The prefix. Default '-'. Returning * an empty value disables exclusions. */ $exclusion_prefix = apply_filters( 'ct_query_search_exclusion_prefix', '-' ); foreach ( $q['search_terms'] as $term ) { // If there is an $exclusion_prefix, terms prefixed with it should be excluded. $exclude = $exclusion_prefix && ( $exclusion_prefix === substr( $term, 0, 1 ) ); if ( $exclude ) { $like_op = 'NOT LIKE'; $andor_op = 'AND'; $term = substr( $term, 1 ); } else { $like_op = 'LIKE'; $andor_op = 'OR'; } if ( $n && ! $exclude ) { $like = '%' . $wpdb->esc_like( $term ) . '%'; //$q['search_orderby_title'][] = $wpdb->prepare( "{$wpdb->posts}.post_title LIKE %s", $like ); } $like = $n . $wpdb->esc_like( $term ) . $n; $search_fields_where = array(); $search_fields_args = array(); foreach( $search_fields as $search_field ) { $search_fields_where[] = "{$ct_table->db->table_name}.$search_field $like_op %s"; $search_fields_args[] = $like; } $search_where = "(" . implode( ") $andor_op (", $search_fields_where ) . ")"; $search .= $wpdb->prepare( "{$searchand}($search_where)", $search_fields_args ); //$search .= $wpdb->prepare( "{$searchand}(({$wpdb->posts}.post_title $like_op %s) $andor_op ({$wpdb->posts}.post_excerpt $like_op %s) $andor_op ({$wpdb->posts}.post_content $like_op %s))", $like, $like, $like ); $searchand = ' AND '; } if ( ! empty( $search ) ) { $search = " AND ({$search}) "; } return $search; } /** * Check if the terms are suitable for searching. * * Uses an array of stopwords (terms) that are excluded from the separate * term matching when searching for posts. The list of English stopwords is * the approximate search engines list, and is translatable. * * @since 1.0.0 * * @param array $terms Terms to check. * @return array Terms that are not stopwords. */ protected function parse_search_terms( $terms ) { $strtolower = function_exists( 'mb_strtolower' ) ? 'mb_strtolower' : 'strtolower'; $checked = array(); $stopwords = $this->get_search_stopwords(); foreach ( $terms as $term ) { // keep before/after spaces when term is for exact match if ( preg_match( '/^".+"$/', $term ) ) $term = trim( $term, "\"'" ); else $term = trim( $term, "\"' " ); // Avoid single A-Z and single dashes. if ( ! $term || ( 1 === strlen( $term ) && preg_match( '/^[a-z\-]$/i', $term ) ) ) continue; if ( in_array( call_user_func( $strtolower, $term ), $stopwords, true ) ) continue; $checked[] = $term; } return $checked; } /** * Retrieve stopwords used when parsing search terms. * * @since 1.0.0 * * @return array Stopwords. */ protected function get_search_stopwords() { if ( isset( $this->stopwords ) ) return $this->stopwords; /* translators: This is a comma-separated list of very common words that should be excluded from a search, * like a, an, and the. These are usually called "stopwords". You should not simply translate these individual * words into your language. Instead, look for and provide commonly accepted stopwords in your language. */ $words = explode( ',', _x( 'about,an,are,as,at,be,by,com,for,from,how,in,is,it,of,on,or,that,the,this,to,was,what,when,where,who,will,with,www', 'Comma-separated list of search stopwords in your language' ) ); $stopwords = array(); foreach ( $words as $word ) { $word = trim( $word, "\r\n\t " ); if ( $word ) $stopwords[] = $word; } /** * Filters stopwords used when parsing search terms. * * @since 1.0.0 * * @param array $stopwords Stopwords. */ $this->stopwords = apply_filters( 'ct_search_stopwords', $stopwords ); return $this->stopwords; } /** * Converts the given orderby alias (if allowed) to a properly-prefixed value. * * @since 4.0.0 * * @global wpdb $wpdb WordPress database abstraction object. * * @param string $orderby Alias for the field to order by. * @return string|false Table-prefixed value to used in the ORDER clause. False otherwise. */ protected function parse_orderby( $orderby ) { global $wpdb, $ct_table; $allowed_keys = array( 'rand' => 'RAND()', ); foreach ($ct_table->db->schema->fields as $key => $value) { $allowed_keys[$key] = "{$ct_table->db->table_name}.{$key}"; } $allowed_keys = apply_filters( "ct_query_{$ct_table->name}_orderby_allowed_keys", $allowed_keys, $orderby ); // If RAND() contains a seed value, sanitize and add to allowed keys. if ( preg_match( '/RAND\(([0-9]+)\)/i', $orderby, $matches ) ) { $orderby = 'rand_with_seed'; $allowed_keys['rand_with_seed'] = sprintf( 'RAND(%s)', (int) $matches[1] ); } if ( ! isset( $allowed_keys[$orderby] ) ) return ''; $orderby_clause = $allowed_keys[$orderby]; return apply_filters( "ct_query_{$ct_table->name}_parse_orderby", $orderby_clause, $orderby ); } /** * Parse an 'order' query variable and cast it to ASC or DESC as necessary. * * @since 1.0.0 * @access protected * * @param string $order The 'order' query variable. * @return string The sanitized 'order' query variable. */ protected function parse_order( $order ) { if ( ! is_string( $order ) || empty( $order ) ) { return 'DESC'; } if ( 'ASC' === strtoupper( $order ) ) { return 'ASC'; } else { return 'DESC'; } } /** * Set up the amount of found posts and the number of pages (if limit clause was used) * for the current query. * * @since 1.0.0 * @access private * * @param array $q Query variables. * @param string $limits LIMIT clauses of the query. */ private function set_found_results( $q, $limits ) { global $wpdb; // Bail if posts is an empty array. Continue if posts is an empty string, // null, or false to accommodate caching plugins that fill posts later. if ( $q['no_found_rows'] || ( is_array( $this->results ) && ! $this->results ) ) return; if ( ! empty( $limits ) ) { /** * Filters the query to run for retrieving the found posts. * * @since 1.0.0 * * @param string $found_posts The query to run to find the found posts. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $this->found_results = $wpdb->get_var( apply_filters_ref_array( 'ct_found_results_query', array( 'SELECT FOUND_ROWS()', &$this ) ) ); } else { $this->found_results = count( $this->results ); } /** * Filters the number of found posts for the query. * * @since 1.0.0 * * @param int $found_posts The number of posts found. * @param WP_Query &$this The WP_Query instance (passed by reference). */ $this->found_results = apply_filters_ref_array( 'ct_found_results', array( $this->found_results, &$this ) ); if ( ! empty( $limits ) ) $this->max_num_pages = ceil( $this->found_results / $q['items_per_page'] ); } /** * Sets up the query by parsing query string. * * @since 1.0.0 * * @param string|array $query URL query string or array of query arguments. * @return array List of results. */ public function query( $query ) { $this->init(); $this->query = $this->query_vars = wp_parse_args( $query ); return $this->get_results(); } } endif; ```