mirror of
https://git.sindominio.net/estibadores/wordpress.git
synced 2024-09-20 15:24:00 +02:00
1545 lines
51 KiB
PHP
1545 lines
51 KiB
PHP
<?php
|
|
/**
|
|
* /lib/search.php
|
|
*
|
|
* @package Relevanssi
|
|
* @author Mikko Saari
|
|
* @license https://wordpress.org/about/gpl/ GNU General Public License
|
|
* @see https://www.relevanssi.com/
|
|
*/
|
|
|
|
/**
|
|
* Triggers the Relevanssi search query.
|
|
*
|
|
* Attaches to 'the_posts' filter hook, checks to see if there's a place for a
|
|
* search and runs relevanssi_do_query() if there is. Do not call directly; for
|
|
* direct Relevanssi access, use relevanssi_do_query().
|
|
*
|
|
* @global boolean $relevanssi_active True, if Relevanssi is already running.
|
|
*
|
|
* @param array $posts An array of post objects.
|
|
* @param WP_Query $query The WP_Query object, default false.
|
|
*/
|
|
function relevanssi_query( $posts, $query = false ) {
|
|
global $relevanssi_active;
|
|
|
|
if ( ! $query ) {
|
|
return $posts;
|
|
}
|
|
|
|
$search_ok = true; // We will search!
|
|
if ( ! $query->is_search() ) {
|
|
$search_ok = false; // No, we can't, not a search.
|
|
}
|
|
if ( ! $query->is_main_query() ) {
|
|
$search_ok = false; // No, we can't, not the main query.
|
|
}
|
|
|
|
// Uses $wp_query->is_admin instead of is_admin() to help with Ajax queries that
|
|
// use 'admin_ajax' hook (which sets is_admin() to true whether it's an admin search
|
|
// or not.
|
|
if ( $query->is_search() && $query->is_admin ) {
|
|
$search_ok = false; // But if this is an admin search, reconsider.
|
|
$admin_search_option = get_option( 'relevanssi_admin_search' );
|
|
if ( 'on' === $admin_search_option ) {
|
|
$search_ok = true; // Yes, we can search!
|
|
}
|
|
}
|
|
|
|
if ( $query->is_admin && empty( $query->query_vars['s'] ) ) {
|
|
$search_ok = false; // No search term.
|
|
}
|
|
|
|
$indexed_post_types = array_flip(
|
|
get_option( 'relevanssi_index_post_types', array() )
|
|
);
|
|
$images_indexed = get_option( 'relevanssi_index_image_files', 'off' );
|
|
if ( $search_ok && ( false === isset( $indexed_post_types['attachment'] ) || 'off' === $images_indexed ) ) {
|
|
if ( 'attachment' === $query->query_vars['post_type'] && 'inherit,private' === $query->query_vars['post_status'] ) {
|
|
$search_ok = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Filters whether Relevanssi search can be run or not.
|
|
*
|
|
* This can be used to for example activate Relevanssi in cases where there is
|
|
* no search term available.
|
|
*
|
|
* @param boolean True, if Relevanssi can be allowed to run.
|
|
* @param WP_Query The current query object.
|
|
*/
|
|
$search_ok = apply_filters( 'relevanssi_search_ok', $search_ok, $query );
|
|
|
|
if ( $relevanssi_active ) {
|
|
$search_ok = false; // Relevanssi is already in action.
|
|
}
|
|
|
|
if ( $search_ok ) {
|
|
/**
|
|
* Filters the WP_Query object before Relevanssi.
|
|
*
|
|
* Can be used to modify the WP_Query object before Relevanssi sees it.
|
|
* Fairly close to pre_get_posts, but is often the better idea, because this
|
|
* only affects Relevanssi searches, and nothing else. Do note that this is
|
|
* a filter and needs to return the modified query object.
|
|
*
|
|
* @param WP_Query The WP_Query object.
|
|
*/
|
|
$query = apply_filters( 'relevanssi_modify_wp_query', $query );
|
|
$posts = relevanssi_do_query( $query );
|
|
}
|
|
|
|
return $posts;
|
|
}
|
|
|
|
/**
|
|
* Does the actual searching.
|
|
*
|
|
* This function gets the search arguments, finds posts and returns all the results
|
|
* it finds. If you wish to access Relevanssi directly, use relevanssi_do_query(),
|
|
* which takes a WP_Query object as a parameter, formats the arguments nicely and
|
|
* returns a specified subset of posts. This is for internal use.
|
|
*
|
|
* @global object $wpdb The WordPress database interface.
|
|
* @global array $relevanssi_variables The global Relevanssi variables array.
|
|
* @global WP_Query $wp_query The WP_Query object.
|
|
* @global array $relevanssi_post_types Cache array for post type values.
|
|
*
|
|
* @param array $args Array of arguments.
|
|
*
|
|
* @return array An array of return values.
|
|
*/
|
|
function relevanssi_search( $args ) {
|
|
global $wpdb, $relevanssi_variables;
|
|
$relevanssi_table = $relevanssi_variables['relevanssi_table'];
|
|
|
|
/**
|
|
* Filters the search parameters.
|
|
*
|
|
* @param array The search parameters.
|
|
*/
|
|
$filtered_args = apply_filters( 'relevanssi_search_filters', $args );
|
|
$meta_query = $filtered_args['meta_query'];
|
|
$operator = $filtered_args['operator'];
|
|
$orderby = $filtered_args['orderby'];
|
|
$order = $filtered_args['order'];
|
|
$fields = $filtered_args['fields'];
|
|
|
|
$hits = array();
|
|
|
|
$query_data = relevanssi_process_query_args( $filtered_args );
|
|
$query_restrictions = $query_data['query_restrictions'];
|
|
$query_join = $query_data['query_join'];
|
|
$q = $query_data['query_query'];
|
|
$q_no_synonyms = $query_data['query_no_synonyms'];
|
|
$phrase_queries = $query_data['phrase_queries'];
|
|
|
|
$min_length = get_option( 'relevanssi_min_word_length' );
|
|
|
|
/**
|
|
* Filters whether stopwords are removed from titles.
|
|
*
|
|
* @param boolean If true, remove stopwords from titles.
|
|
*/
|
|
$remove_stopwords = apply_filters( 'relevanssi_remove_stopwords_in_titles', true );
|
|
|
|
$terms = relevanssi_tokenize( $q, $remove_stopwords, $min_length );
|
|
$terms = array_keys( $terms ); // Don't care about tf in query.
|
|
|
|
if ( function_exists( 'relevanssi_process_terms' ) ) {
|
|
$process_terms_results = relevanssi_process_terms( $terms, $q );
|
|
$query_restrictions .= $process_terms_results['query_restrictions'];
|
|
$terms = $process_terms_results['terms'];
|
|
}
|
|
|
|
$no_terms = false;
|
|
if ( count( $terms ) < 1 && empty( $q ) ) {
|
|
$no_terms = true;
|
|
$terms[] = 'term';
|
|
}
|
|
|
|
/**
|
|
* Filters the query restrictions for the Relevanssi query.
|
|
*
|
|
* Equivalent to the 'posts_where' filter.
|
|
*
|
|
* @author Charles St-Pierre
|
|
*
|
|
* @param string The MySQL code that restricts the query.
|
|
*/
|
|
$query_restrictions = apply_filters( 'relevanssi_where', $query_restrictions );
|
|
|
|
/**
|
|
* Filters the meta query JOIN for the Relevanssi search query.
|
|
*
|
|
* Somewhat equivalent to the 'posts_join' filter.
|
|
*
|
|
* @param string The JOINed query.
|
|
*/
|
|
$query_join = apply_filters( 'relevanssi_join', $query_join );
|
|
|
|
// Go get the count from the options, but run the full query if it's not available.
|
|
$doc_count = get_option( 'relevanssi_doc_count' );
|
|
if ( ! $doc_count || $doc_count < 1 ) {
|
|
$doc_count = relevanssi_update_doc_count();
|
|
}
|
|
|
|
$total_hits = 0;
|
|
|
|
$title_matches = array();
|
|
$tag_matches = array();
|
|
$comment_matches = array();
|
|
$link_matches = array();
|
|
$body_matches = array();
|
|
$category_matches = array();
|
|
$taxonomy_matches = array();
|
|
$customfield_matches = array();
|
|
$mysqlcolumn_matches = array();
|
|
$author_matches = array();
|
|
$excerpt_matches = array();
|
|
$term_hits = array();
|
|
|
|
$fuzzy = get_option( 'relevanssi_fuzzy' );
|
|
|
|
$no_matches = true;
|
|
|
|
$post_type_weights = get_option( 'relevanssi_post_type_weights' );
|
|
|
|
$recency_bonus = false;
|
|
$recency_cutoff_date = false;
|
|
if ( function_exists( 'relevanssi_get_recency_bonus' ) ) {
|
|
$recency_details = relevanssi_get_recency_bonus();
|
|
$recency_bonus = $recency_details['bonus'];
|
|
$recency_cutoff_date = $recency_details['cutoff'];
|
|
}
|
|
|
|
$exact_match_bonus = false;
|
|
if ( 'on' === get_option( 'relevanssi_exact_match_bonus' ) ) {
|
|
$exact_match_bonus = true;
|
|
/**
|
|
* Filters the exact match bonus.
|
|
*
|
|
* @param array The title bonus under 'title' (default 5) and the content
|
|
* bonus under 'content' (default 2).
|
|
*/
|
|
$exact_match_boost = apply_filters(
|
|
'relevanssi_exact_match_bonus',
|
|
array(
|
|
'title' => 5,
|
|
'content' => 2,
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
$search_again = false;
|
|
|
|
$content_boost = floatval( get_option( 'relevanssi_content_boost', 1 ) ); // Default value, because this option was added late.
|
|
$title_boost = floatval( get_option( 'relevanssi_title_boost' ) );
|
|
$link_boost = floatval( get_option( 'relevanssi_link_boost' ) );
|
|
$comment_boost = floatval( get_option( 'relevanssi_comment_boost' ) );
|
|
|
|
$tag = $relevanssi_variables['post_type_weight_defaults']['post_tag'];
|
|
$cat = $relevanssi_variables['post_type_weight_defaults']['category'];
|
|
|
|
if ( ! empty( $post_type_weights['post_tagged_with_post_tag'] ) ) {
|
|
$tag = $post_type_weights['post_tagged_with_post_tag'];
|
|
}
|
|
if ( ! empty( $post_type_weights['post_tagged_with_category'] ) ) {
|
|
$cat = $post_type_weights['post_tagged_with_category'];
|
|
}
|
|
|
|
// Legacy code, improvement introduced in 2.1.8, remove at some point.
|
|
// phpcs:ignore Squiz.Commenting.InlineComment
|
|
// @codeCoverageIgnoreStart
|
|
if ( ! empty( $post_type_weights['post_tag'] ) ) {
|
|
$tag = $post_type_weights['post_tag'];
|
|
}
|
|
if ( ! empty( $post_type_weights['category'] ) ) {
|
|
$cat = $post_type_weights['category'];
|
|
}
|
|
// @codeCoverageIgnoreEnd
|
|
/* End legacy code. */
|
|
|
|
$include_these_posts = array();
|
|
$include_these_items = array();
|
|
$df_counts = array();
|
|
$doc_weight = array();
|
|
|
|
do {
|
|
foreach ( $terms as $term ) {
|
|
$term_cond = relevanssi_generate_term_where( $term, $search_again, $no_terms );
|
|
if ( null === $term_cond ) {
|
|
continue;
|
|
}
|
|
|
|
$this_query_restrictions = relevanssi_add_phrase_restrictions(
|
|
$query_restrictions,
|
|
$phrase_queries,
|
|
$term,
|
|
$operator
|
|
);
|
|
|
|
$query = "SELECT COUNT(DISTINCT(relevanssi.doc)) FROM $relevanssi_table AS relevanssi
|
|
$query_join WHERE $term_cond $this_query_restrictions";
|
|
// Clean: $this_query_restrictions is escaped, $term_cond is escaped.
|
|
/**
|
|
* Filters the DF query.
|
|
*
|
|
* This query is used to calculate the df for the tf * idf calculations.
|
|
*
|
|
* @param string MySQL query to filter.
|
|
*/
|
|
$query = apply_filters( 'relevanssi_df_query_filter', $query );
|
|
|
|
$df = $wpdb->get_var( $query ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared,WordPress.DB.PreparedSQL.InterpolatedNotPrepared
|
|
|
|
if ( $df < 1 && 'sometimes' === $fuzzy ) {
|
|
$term_cond = relevanssi_generate_term_where( $term, true, $no_terms );
|
|
$query = "
|
|
SELECT COUNT(DISTINCT(relevanssi.doc))
|
|
FROM $relevanssi_table AS relevanssi
|
|
$query_join WHERE $term_cond $query_restrictions";
|
|
// Clean: $query_restrictions is escaped, $term is escaped.
|
|
/** Documented in lib/search.php. */
|
|
$query = apply_filters( 'relevanssi_df_query_filter', $query );
|
|
$df = $wpdb->get_var( $query ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared,WordPress.DB.PreparedSQL.InterpolatedNotPrepared
|
|
}
|
|
|
|
$df_counts[ $term ] = $df;
|
|
}
|
|
|
|
// Sort the terms in ascending DF order, so that rarest terms are searched
|
|
// for first. This is to make sure the throttle doesn't cut off posts with
|
|
// rare search terms.
|
|
asort( $df_counts );
|
|
|
|
foreach ( $df_counts as $term => $df ) {
|
|
$term_cond = relevanssi_generate_term_where( $term, $search_again, $no_terms );
|
|
|
|
$this_query_restrictions = relevanssi_add_phrase_restrictions(
|
|
$query_restrictions,
|
|
$phrase_queries,
|
|
$term,
|
|
$operator
|
|
);
|
|
|
|
$query = "SELECT DISTINCT(relevanssi.doc), relevanssi.*, relevanssi.title * $title_boost +
|
|
relevanssi.content * $content_boost + relevanssi.comment * $comment_boost +
|
|
relevanssi.tag * $tag + relevanssi.link * $link_boost +
|
|
relevanssi.author + relevanssi.category * $cat + relevanssi.excerpt +
|
|
relevanssi.taxonomy + relevanssi.customfield + relevanssi.mysqlcolumn AS tf
|
|
FROM $relevanssi_table AS relevanssi $query_join WHERE $term_cond $this_query_restrictions";
|
|
/** Clean: $this_query_restrictions is escaped, $term_cond is escaped. */
|
|
|
|
/**
|
|
* Filters the Relevanssi MySQL query.
|
|
*
|
|
* The last chance to filter the MySQL query before it is run.
|
|
*
|
|
* @param string MySQL query for the Relevanssi search.
|
|
*/
|
|
$query = apply_filters( 'relevanssi_query_filter', $query );
|
|
$matches = $wpdb->get_results( $query ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared,WordPress.DB.PreparedSQL.InterpolatedNotPrepared
|
|
if ( count( $matches ) < 1 ) {
|
|
continue;
|
|
} else {
|
|
$no_matches = false;
|
|
if ( count( $include_these_posts ) > 0 ) {
|
|
$existing_ids = array();
|
|
foreach ( $matches as $match ) {
|
|
$existing_ids[] = $match->doc;
|
|
}
|
|
$existing_ids = array_keys( array_flip( $existing_ids ) );
|
|
$added_post_ids = array_diff( array_keys( $include_these_posts ), $existing_ids );
|
|
if ( count( $added_post_ids ) > 0 ) {
|
|
$offset = 0;
|
|
$slice_length = 20;
|
|
$total_ids = count( $added_post_ids );
|
|
do {
|
|
$current_slice = array_slice( $added_post_ids, $offset, $slice_length );
|
|
$post_ids_to_add = implode( ',', $current_slice );
|
|
if ( ! empty( $post_ids_to_add ) ) {
|
|
$query = "SELECT relevanssi.*, relevanssi.title * $title_boost +
|
|
relevanssi.content * $content_boost + relevanssi.comment * $comment_boost +
|
|
relevanssi.tag * $tag + relevanssi.link * $link_boost +
|
|
relevanssi.author + relevanssi.category * $cat + relevanssi.excerpt +
|
|
relevanssi.taxonomy + relevanssi.customfield + relevanssi.mysqlcolumn AS tf
|
|
FROM $relevanssi_table AS relevanssi WHERE relevanssi.doc IN ($post_ids_to_add)
|
|
AND $term_cond";
|
|
|
|
// Clean: no unescaped user inputs.
|
|
$matches_to_add = $wpdb->get_results( $query ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared,WordPress.DB.PreparedSQL.InterpolatedNotPrepared
|
|
$matches = array_merge( $matches, $matches_to_add );
|
|
}
|
|
$offset += $slice_length;
|
|
} while ( $offset <= $total_ids );
|
|
}
|
|
}
|
|
if ( count( $include_these_items ) > 0 ) {
|
|
$existing_items = array();
|
|
foreach ( $matches as $match ) {
|
|
if ( 0 !== intval( $match->item ) ) {
|
|
$existing_items[] = $match->item;
|
|
}
|
|
}
|
|
$existing_items = array_keys( array_flip( $existing_items ) );
|
|
$items_to_add = implode( ',', array_diff( array_keys( $include_these_items ), $existing_items ) );
|
|
|
|
if ( ! empty( $items_to_add ) ) {
|
|
$query = "SELECT relevanssi.*, relevanssi.title * $title_boost +
|
|
relevanssi.content * $content_boost + relevanssi.comment * $comment_boost +
|
|
relevanssi.tag * $tag + relevanssi.link * $link_boost +
|
|
relevanssi.author + relevanssi.category * $cat + relevanssi.excerpt +
|
|
relevanssi.taxonomy + relevanssi.customfield + relevanssi.mysqlcolumn AS tf
|
|
FROM $relevanssi_table AS relevanssi WHERE relevanssi.item IN ($items_to_add)
|
|
AND $term_cond";
|
|
|
|
// Clean: no unescaped user inputs.
|
|
$matches_to_add = $wpdb->get_results( $query ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared,WordPress.DB.PreparedSQL.InterpolatedNotPrepared
|
|
$matches = array_merge( $matches, $matches_to_add );
|
|
}
|
|
}
|
|
}
|
|
|
|
relevanssi_populate_array( $matches );
|
|
global $relevanssi_post_types;
|
|
|
|
$total_hits += count( $matches );
|
|
|
|
$idf = log( $doc_count + 1 / ( 1 + $df ) );
|
|
$idf = $idf * $idf; // Adjustment to increase the value of IDF.
|
|
if ( $idf < 1 ) {
|
|
$idf = 1;
|
|
}
|
|
|
|
foreach ( $matches as $match ) {
|
|
if ( 'user' === $match->type ) {
|
|
$match->doc = 'u_' . $match->item;
|
|
} elseif ( 'post_type' === $match->type ) {
|
|
$match->doc = 'p_' . $match->item;
|
|
} elseif ( ! in_array( $match->type, array( 'post', 'attachment' ), true ) ) {
|
|
$match->doc = '**' . $match->type . '**' . $match->item;
|
|
}
|
|
|
|
if ( ! empty( $match->taxonomy_detail ) ) {
|
|
relevanssi_taxonomy_score( $match, $post_type_weights );
|
|
} else {
|
|
$tag_weight = 1;
|
|
if ( isset( $post_type_weights['post_tagged_with_post_tag'] ) && is_numeric( $post_type_weights['post_tagged_with_post_tag'] ) ) {
|
|
$tag_weight = $post_type_weights['post_tagged_with_post_tag'];
|
|
}
|
|
|
|
$category_weight = 1;
|
|
if ( isset( $post_type_weights['post_tagged_with_category'] ) && is_numeric( $post_type_weights['post_tagged_with_category'] ) ) {
|
|
$category_weight = $post_type_weights['post_tagged_with_category'];
|
|
}
|
|
|
|
// Legacy code from 2.1.8. Remove at some point.
|
|
// phpcs:ignore Squiz.Commenting.InlineComment
|
|
// @codeCoverageIgnoreStart
|
|
if ( isset( $post_type_weights['post_tag'] ) && is_numeric( $post_type_weights['post_tag'] ) ) {
|
|
$tag_weight = $post_type_weights['post_tag'];
|
|
}
|
|
|
|
$category_weight = 1;
|
|
if ( isset( $post_type_weights['category'] ) && is_numeric( $post_type_weights['category'] ) ) {
|
|
$category_weight = $post_type_weights['category'];
|
|
}
|
|
// @codeCoverageIgnoreEnd
|
|
/* End legacy code. */
|
|
|
|
$taxonomy_weight = 1;
|
|
|
|
$match->taxonomy_score =
|
|
$match->tag * $tag_weight +
|
|
$match->category * $category_weight +
|
|
$match->taxonomy * $taxonomy_weight;
|
|
}
|
|
|
|
$match->tf =
|
|
$match->title * $title_boost +
|
|
$match->content * $content_boost +
|
|
$match->comment * $comment_boost +
|
|
$match->link * $link_boost +
|
|
$match->author +
|
|
$match->excerpt +
|
|
$match->taxonomy_score +
|
|
$match->customfield +
|
|
$match->mysqlcolumn;
|
|
|
|
$term_hits[ $match->doc ][ $term ] =
|
|
$match->title +
|
|
$match->content +
|
|
$match->comment +
|
|
$match->tag +
|
|
$match->link +
|
|
$match->author +
|
|
$match->category +
|
|
$match->excerpt +
|
|
$match->taxonomy +
|
|
$match->customfield +
|
|
$match->mysqlcolumn;
|
|
|
|
$match->weight = $match->tf * $idf;
|
|
|
|
if ( $recency_bonus ) {
|
|
$post = relevanssi_get_post( $match->doc );
|
|
if ( strtotime( $post->post_date ) > $recency_cutoff_date ) {
|
|
$match->weight = $match->weight * $recency_bonus;
|
|
}
|
|
}
|
|
|
|
if ( $exact_match_bonus ) {
|
|
$post = relevanssi_get_post( $match->doc );
|
|
$clean_q = str_replace( array( '"', '”', '“' ), '', $q_no_synonyms );
|
|
if ( $post && $clean_q ) {
|
|
if ( stristr( $post->post_title, $clean_q ) !== false ) {
|
|
$match->weight *= $exact_match_boost['title'];
|
|
}
|
|
if ( stristr( $post->post_content, $clean_q ) !== false ) {
|
|
$match->weight *= $exact_match_boost['content'];
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( ! isset( $body_matches[ $match->doc ] ) ) {
|
|
$body_matches[ $match->doc ] = 0;
|
|
}
|
|
if ( ! isset( $title_matches[ $match->doc ] ) ) {
|
|
$title_matches[ $match->doc ] = 0;
|
|
}
|
|
if ( ! isset( $link_matches[ $match->doc ] ) ) {
|
|
$link_matches[ $match->doc ] = 0;
|
|
}
|
|
if ( ! isset( $tag_matches[ $match->doc ] ) ) {
|
|
$tag_matches[ $match->doc ] = 0;
|
|
}
|
|
if ( ! isset( $category_matches[ $match->doc ] ) ) {
|
|
$category_matches[ $match->doc ] = 0;
|
|
}
|
|
if ( ! isset( $taxonomy_matches[ $match->doc ] ) ) {
|
|
$taxonomy_matches[ $match->doc ] = 0;
|
|
}
|
|
if ( ! isset( $comment_matches[ $match->doc ] ) ) {
|
|
$comment_matches[ $match->doc ] = 0;
|
|
}
|
|
if ( ! isset( $customfield_matches[ $match->doc ] ) ) {
|
|
$customfield_matches[ $match->doc ] = 0;
|
|
}
|
|
if ( ! isset( $author_matches[ $match->doc ] ) ) {
|
|
$author_matches[ $match->doc ] = 0;
|
|
}
|
|
if ( ! isset( $excerpt_matches[ $match->doc ] ) ) {
|
|
$excerpt_matches[ $match->doc ] = 0;
|
|
}
|
|
if ( ! isset( $mysqlcolumn_matches[ $match->doc ] ) ) {
|
|
$mysqlcolumn_matches[ $match->doc ] = 0;
|
|
}
|
|
$body_matches[ $match->doc ] += $match->content;
|
|
$title_matches[ $match->doc ] += $match->title;
|
|
$link_matches[ $match->doc ] += $match->link;
|
|
$tag_matches[ $match->doc ] += $match->tag;
|
|
$category_matches[ $match->doc ] += $match->category;
|
|
$taxonomy_matches[ $match->doc ] += $match->taxonomy;
|
|
$comment_matches[ $match->doc ] += $match->comment;
|
|
$customfield_matches[ $match->doc ] += $match->customfield;
|
|
$author_matches[ $match->doc ] += $match->author;
|
|
$excerpt_matches[ $match->doc ] += $match->excerpt;
|
|
$mysqlcolumn_matches[ $match->doc ] += $match->mysqlcolumn;
|
|
|
|
/* Post type weights. */
|
|
$type = null;
|
|
if ( isset( $relevanssi_post_types[ $match->doc ] ) ) {
|
|
$type = $relevanssi_post_types[ $match->doc ];
|
|
}
|
|
if ( ! empty( $post_type_weights[ $type ] ) ) {
|
|
$match->weight = $match->weight * $post_type_weights[ $type ];
|
|
}
|
|
|
|
/* Weight boost for taxonomy terms based on taxonomy. */
|
|
if ( ! empty( $post_type_weights[ 'taxonomy_term_' . $match->type ] ) ) {
|
|
$match->weight = $match->weight * $post_type_weights[ 'taxonomy_term_' . $match->type ];
|
|
}
|
|
|
|
/**
|
|
* Filters the hit.
|
|
*
|
|
* This filter hook can be used to adjust the weights of found hits.
|
|
* Calculate the new weight and set the $match->weight to the new
|
|
* value.
|
|
*
|
|
* @param object $match The match object.
|
|
* @param int $idf The IDF value, if you want to recalculate
|
|
* TF * IDF values (TF is in $match->tf).
|
|
* @param string $term The current search term.
|
|
*/
|
|
$match = apply_filters( 'relevanssi_match', $match, $idf, $term );
|
|
if ( $match->weight <= 0 ) {
|
|
continue; // The filters killed the match.
|
|
}
|
|
|
|
$post_ok = true;
|
|
/**
|
|
* Filters whether the post can be shown to the user.
|
|
*
|
|
* This filter hook is used for 'relevanssi_default_post_ok' filter
|
|
* function which handles private posts and some membership plugins.
|
|
* If you want to add support for more membership plugins, this is
|
|
* the filter hook to use.
|
|
*
|
|
* @param boolean True, if the post can be shown to the current user.
|
|
* @param int The post ID.
|
|
*/
|
|
$post_ok = apply_filters( 'relevanssi_post_ok', $post_ok, $match->doc );
|
|
if ( $post_ok ) {
|
|
$doc_terms[ $match->doc ][ $term ] = true; // Count how many terms are matched to a doc.
|
|
if ( ! isset( $doc_weight[ $match->doc ] ) ) {
|
|
$doc_weight[ $match->doc ] = 0;
|
|
}
|
|
$doc_weight[ $match->doc ] += $match->weight;
|
|
// For AND searches, add the posts to the $include_these lists, so that
|
|
// nothing is missed.
|
|
if ( is_numeric( $match->doc ) && 'AND' === $operator ) {
|
|
// This is to weed out taxonomies and users (t_XXX, u_XXX).
|
|
$include_these_posts[ $match->doc ] = true;
|
|
} elseif ( 0 !== intval( $match->item ) && 'AND' === $operator ) {
|
|
$include_these_items[ $match->item ] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( $no_matches ) {
|
|
if ( $search_again ) {
|
|
// No hits even with fuzzy search!
|
|
$search_again = false;
|
|
} else {
|
|
if ( 'sometimes' === $fuzzy ) {
|
|
$search_again = true;
|
|
}
|
|
}
|
|
} else {
|
|
$search_again = false;
|
|
}
|
|
$params = array(
|
|
'no_matches' => $no_matches,
|
|
'doc_weight' => $doc_weight,
|
|
'terms' => $terms,
|
|
'search_again' => $search_again,
|
|
);
|
|
/**
|
|
* Filters the parameters for fallback search.
|
|
*
|
|
* If you want to make Relevanssi search again with different parameters, you
|
|
* can use this filter hook to adjust the parameters. Set
|
|
* $params['search_again'] to true to make Relevanssi do a new search.
|
|
*
|
|
* @param array The search parameters.
|
|
*/
|
|
$params = apply_filters( 'relevanssi_search_again', $params );
|
|
$search_again = $params['search_again'];
|
|
$terms = $params['terms'];
|
|
$doc_weight = $params['doc_weight'];
|
|
$no_matches = $params['no_matches'];
|
|
} while ( $search_again );
|
|
|
|
$strip_stops = true;
|
|
$temp_terms_without_stops = array_keys( relevanssi_tokenize( implode( ' ', $terms ), $strip_stops ) );
|
|
$terms_without_stops = array();
|
|
foreach ( $temp_terms_without_stops as $temp_term ) {
|
|
if ( relevanssi_strlen( $temp_term ) >= $min_length ) {
|
|
array_push( $terms_without_stops, $temp_term );
|
|
}
|
|
}
|
|
$total_terms = count( $terms_without_stops );
|
|
|
|
if ( isset( $doc_weight ) ) {
|
|
/**
|
|
* Filters the results Relevanssi finds.
|
|
*
|
|
* Often you'll find 'relevanssi_hits_filter' more useful than this, but
|
|
* sometimes this is the right tool for filtering the results.
|
|
*
|
|
* @param array $doc_weight An array of (post ID, weight) pairs.
|
|
*/
|
|
$doc_weight = apply_filters( 'relevanssi_results', $doc_weight );
|
|
}
|
|
|
|
if ( isset( $doc_weight ) && count( $doc_weight ) > 0 ) {
|
|
arsort( $doc_weight );
|
|
$i = 0;
|
|
foreach ( $doc_weight as $doc => $weight ) {
|
|
if ( count( $doc_terms[ $doc ] ) < $total_terms && 'AND' === $operator ) {
|
|
// AND operator in action:
|
|
// doc didn't match all terms, so it's discarded.
|
|
continue;
|
|
}
|
|
|
|
if ( ! empty( $fields ) ) {
|
|
if ( 'ids' === $fields ) {
|
|
$hits[ intval( $i ) ] = $doc;
|
|
}
|
|
if ( 'id=>parent' === $fields ) {
|
|
$object = new StdClass();
|
|
$object->ID = $doc;
|
|
$object->post_parent = wp_get_post_parent_id( $doc );
|
|
|
|
$hits[ intval( $i ) ] = $object;
|
|
}
|
|
} else {
|
|
$hits[ intval( $i ) ] = relevanssi_get_post( $doc );
|
|
$hits[ intval( $i ) ]->relevance_score = round( $weight, 2 );
|
|
}
|
|
$i++;
|
|
}
|
|
}
|
|
|
|
if ( count( $hits ) < 1 ) {
|
|
if ( 'AND' === $operator && 'on' !== get_option( 'relevanssi_disable_or_fallback' ) ) {
|
|
$or_args = $args;
|
|
$or_args['operator'] = 'OR';
|
|
global $wp_query;
|
|
$wp_query->set( 'operator', 'OR' );
|
|
|
|
$or_args['q_no_synonyms'] = $q;
|
|
$or_args['q'] = relevanssi_add_synonyms( $q );
|
|
$return = relevanssi_search( $or_args );
|
|
|
|
$hits = $return['hits'];
|
|
$body_matches = $return['body_matches'];
|
|
$title_matches = $return['title_matches'];
|
|
$tag_matches = $return['tag_matches'];
|
|
$category_matches = $return['category_matches'];
|
|
$taxonomy_matches = $return['taxonomy_matches'];
|
|
$comment_matches = $return['comment_matches'];
|
|
$link_matches = $return['link_matches'];
|
|
$author_matches = $return['author_matches'];
|
|
$customfield_matches = $return['customfield_matches'];
|
|
$mysqlcolumn_matches = $return['mysqlcolumn_matches'];
|
|
$excerpt_matches = $return['excerpt_matches'];
|
|
$term_hits = $return['term_hits'];
|
|
$doc_weight = $return['doc_weights'];
|
|
$q = $return['query'];
|
|
}
|
|
$params = array( 'args' => $args );
|
|
/**
|
|
* Filters the fallback search parameters.
|
|
*
|
|
* This filter can be used to implement a fallback search. Take the
|
|
* parameters, do something with them, then return a proper return value
|
|
* array in $param['return'].
|
|
*
|
|
* @param array Search parameters.
|
|
*/
|
|
$params = apply_filters( 'relevanssi_fallback', $params );
|
|
$args = $params['args'];
|
|
if ( isset( $params['return'] ) ) {
|
|
$return = $params['return'];
|
|
$hits = $return['hits'];
|
|
$body_matches = $return['body_matches'];
|
|
$title_matches = $return['title_matches'];
|
|
$tag_matches = $return['tag_matches'];
|
|
$category_matches = $return['category_matches'];
|
|
$taxonomy_matches = $return['taxonomy_matches'];
|
|
$comment_matches = $return['comment_matches'];
|
|
$link_matches = $return['link_matches'];
|
|
$author_matches = $return['author_matches'];
|
|
$customfield_matches = $return['customfield_matches'];
|
|
$mysqlcolumn_matches = $return['mysqlcolumn_matches'];
|
|
$excerpt_matches = $return['excerpt_matches'];
|
|
$term_hits = $return['term_hits'];
|
|
$doc_weight = $return['doc_weights'];
|
|
$q = $return['query'];
|
|
}
|
|
}
|
|
|
|
$default_order = get_option( 'relevanssi_default_orderby', 'relevance' );
|
|
if ( empty( $orderby ) ) {
|
|
$orderby = $default_order;
|
|
}
|
|
if ( is_array( $orderby ) ) {
|
|
/**
|
|
* Filters the 'orderby' value just before sorting.
|
|
*
|
|
* Relevanssi can use both array orderby ie. array( orderby => order )
|
|
* with multiple orderby parameters, or a single pair of orderby and
|
|
* order parameters. To avoid problems, try sticking to one and don't
|
|
* use this filter to make surprising changes between different formats.
|
|
*
|
|
* @param string The 'orderby' parameter.
|
|
*/
|
|
$orderby = apply_filters( 'relevanssi_orderby', $orderby );
|
|
relevanssi_object_sort( $hits, $orderby, $meta_query );
|
|
} else {
|
|
if ( empty( $order ) ) {
|
|
$order = 'desc';
|
|
}
|
|
$order = strtolower( $order );
|
|
|
|
$order_accepted_values = array( 'asc', 'desc' );
|
|
if ( ! in_array( $order, $order_accepted_values, true ) ) {
|
|
$order = 'desc';
|
|
}
|
|
|
|
/** Documented in lib/search.php. */
|
|
$orderby = apply_filters( 'relevanssi_orderby', $orderby );
|
|
/**
|
|
* Filters the 'order' value just before sorting.
|
|
*
|
|
* @param string The 'order' parameter.
|
|
*/
|
|
$order = apply_filters( 'relevanssi_order', $order );
|
|
|
|
if ( 'relevance' !== $orderby ) {
|
|
$orderby_array = array( $orderby => $order );
|
|
relevanssi_object_sort( $hits, $orderby_array, $meta_query );
|
|
}
|
|
}
|
|
$return = array(
|
|
'hits' => $hits,
|
|
'body_matches' => $body_matches,
|
|
'title_matches' => $title_matches,
|
|
'tag_matches' => $tag_matches,
|
|
'category_matches' => $category_matches,
|
|
'comment_matches' => $comment_matches,
|
|
'taxonomy_matches' => $taxonomy_matches,
|
|
'link_matches' => $link_matches,
|
|
'customfield_matches' => $customfield_matches,
|
|
'mysqlcolumn_matches' => $mysqlcolumn_matches,
|
|
'author_matches' => $author_matches,
|
|
'excerpt_matches' => $excerpt_matches,
|
|
'term_hits' => $term_hits,
|
|
'query' => $q,
|
|
'doc_weights' => $doc_weight,
|
|
);
|
|
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Takes a WP_Query object and runs the search query based on that
|
|
*
|
|
* This function can be used to run Relevanssi searches anywhere. Just create an
|
|
* empty WP_Query object, give it some parameters, make sure 's' is set and contains
|
|
* the search query, then run relevanssi_do_query() on the query object.
|
|
*
|
|
* This function is strongly influenced by Kenny Katzgrau's wpSearch plugin.
|
|
*
|
|
* @global boolean $relevanssi_active If true, Relevanssi is currently
|
|
* doing a search.
|
|
* @global boolean $relevanssi_test_admin If true, assume this is an admin
|
|
* search (because we can't adjust WP_ADMIN constant).
|
|
*
|
|
* @param WP_Query $query A WP_Query object, passed as a reference. Relevanssi will
|
|
* put the posts found in $query->posts, and also sets $query->post_count.
|
|
*
|
|
* @return array The found posts, an array of post objects.
|
|
*/
|
|
function relevanssi_do_query( &$query ) {
|
|
global $relevanssi_active, $relevanssi_test_admin;
|
|
$relevanssi_active = true;
|
|
|
|
$posts = array();
|
|
|
|
$q = trim( stripslashes( relevanssi_strtolower( $query->query_vars['s'] ) ) );
|
|
|
|
$did_multisite_search = false;
|
|
if ( is_multisite() ) {
|
|
if ( function_exists( 'relevanssi_is_multisite_search' ) ) {
|
|
$searchblogs = relevanssi_is_multisite_search( $query );
|
|
if ( $searchblogs ) {
|
|
if ( function_exists( 'relevanssi_compile_multi_args' )
|
|
&& function_exists( 'relevanssi_search_multi' ) ) {
|
|
$multi_args = relevanssi_compile_multi_args( $query, $searchblogs, $q );
|
|
$return = relevanssi_search_multi( $multi_args );
|
|
}
|
|
$did_multisite_search = true;
|
|
}
|
|
}
|
|
}
|
|
$search_params = array();
|
|
if ( ! $did_multisite_search ) {
|
|
$search_params = relevanssi_compile_search_args( $query, $q );
|
|
$return = relevanssi_search( $search_params );
|
|
}
|
|
|
|
$hits = array();
|
|
if ( isset( $return['hits'] ) ) {
|
|
$hits = $return['hits'];
|
|
}
|
|
$q = '';
|
|
if ( isset( $return['query'] ) ) {
|
|
$q = $return['query'];
|
|
}
|
|
|
|
$filter_data = array( $hits, $q );
|
|
/**
|
|
* Filters the founds results.
|
|
*
|
|
* One of the key filters for Relevanssi. If you want to modify the results
|
|
* Relevanssi finds, use this filter.
|
|
*
|
|
* @param array $filter_data The index 0 has an array of post objects found in
|
|
* the search, index 1 has the search query string.
|
|
*
|
|
* @return array The return array composition is the same as the parameter array,
|
|
* but Relevanssi only uses the index 0.
|
|
*/
|
|
$hits_filters_applied = apply_filters( 'relevanssi_hits_filter', $filter_data );
|
|
// array_values() to make sure the $hits array is indexed in numerical order
|
|
// Manipulating the array with array_unique() for example may mess with that.
|
|
$hits = array_values( $hits_filters_applied[0] );
|
|
|
|
$hits_count = count( $hits );
|
|
$query->found_posts = $hits_count;
|
|
if ( ! isset( $query->query_vars['posts_per_page'] ) || 0 === $query->query_vars['posts_per_page'] ) {
|
|
// Assume something sensible to prevent "division by zero error".
|
|
$query->query_vars['posts_per_page'] = -1;
|
|
}
|
|
if ( -1 === $query->query_vars['posts_per_page'] ) {
|
|
$query->max_num_pages = $hits_count;
|
|
} else {
|
|
$query->max_num_pages = ceil( $hits_count / $query->query_vars['posts_per_page'] );
|
|
}
|
|
|
|
$update_log = get_option( 'relevanssi_log_queries' );
|
|
if ( 'on' === $update_log ) {
|
|
relevanssi_update_log( $q, $hits_count );
|
|
}
|
|
|
|
$make_excerpts = get_option( 'relevanssi_excerpts' );
|
|
if ( $relevanssi_test_admin || ( $query->is_admin && ! defined( 'DOING_AJAX' ) ) ) {
|
|
$make_excerpts = false;
|
|
}
|
|
|
|
if ( isset( $query->query_vars['paged'] ) && $query->query_vars['paged'] > 0 ) {
|
|
$search_low_boundary = ( $query->query_vars['paged'] - 1 ) * $query->query_vars['posts_per_page'];
|
|
} else {
|
|
$search_low_boundary = 0;
|
|
}
|
|
|
|
if ( ! isset( $query->query_vars['posts_per_page'] ) || -1 === $query->query_vars['posts_per_page'] ) {
|
|
$search_high_boundary = $hits_count;
|
|
} else {
|
|
$search_high_boundary = $search_low_boundary + $query->query_vars['posts_per_page'] - 1;
|
|
}
|
|
|
|
if ( isset( $query->query_vars['offset'] ) && $query->query_vars['offset'] > 0 ) {
|
|
$search_high_boundary += $query->query_vars['offset'];
|
|
$search_low_boundary += $query->query_vars['offset'];
|
|
}
|
|
|
|
if ( $search_high_boundary > $hits_count ) {
|
|
$search_high_boundary = $hits_count;
|
|
}
|
|
|
|
for ( $i = $search_low_boundary; $i <= $search_high_boundary; $i++ ) {
|
|
if ( isset( $hits[ intval( $i ) ] ) ) {
|
|
$post = $hits[ intval( $i ) ];
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
if ( null === $post ) {
|
|
// @codeCoverageIgnoreStart
|
|
// Sometimes you can get a null object.
|
|
continue;
|
|
// @codeCoverageIgnoreEnd
|
|
}
|
|
|
|
if ( 'on' === get_option( 'relevanssi_hilite_title' ) && empty( $search_params['fields'] ) ) {
|
|
$post->post_highlighted_title = wp_strip_all_tags( $post->post_title );
|
|
$highlight = get_option( 'relevanssi_highlight' );
|
|
if ( 'none' !== $highlight ) {
|
|
if ( ! is_admin() || ( defined( 'DOING_AJAX' ) && DOING_AJAX ) ) {
|
|
$post->post_highlighted_title = relevanssi_highlight_terms(
|
|
$post->post_highlighted_title,
|
|
$q
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If you need to modify these on the go, use
|
|
* 'pre_option_relevanssi_excerpt_length' and
|
|
* pre_option_relevanssi_excerpt_type' filters.
|
|
*/
|
|
$excerpt_length = get_option( 'relevanssi_excerpt_length' );
|
|
$excerpt_type = get_option( 'relevanssi_excerpt_type' );
|
|
|
|
if ( 'on' === $make_excerpts && empty( $search_params['fields'] ) ) {
|
|
if ( isset( $post->blog_id ) ) {
|
|
switch_to_blog( $post->blog_id );
|
|
}
|
|
$post->original_excerpt = $post->post_excerpt;
|
|
$post->post_excerpt = relevanssi_do_excerpt(
|
|
$post,
|
|
$q,
|
|
$excerpt_length,
|
|
$excerpt_type
|
|
);
|
|
|
|
if ( isset( $post->blog_id ) ) {
|
|
restore_current_blog();
|
|
}
|
|
}
|
|
if ( empty( $search_params['fields'] ) ) {
|
|
relevanssi_add_matches( $post, $return );
|
|
}
|
|
if ( 'on' === get_option( 'relevanssi_show_matches' ) && empty( $search_params['fields'] ) ) {
|
|
$post->post_excerpt .= relevanssi_show_matches( $post );
|
|
}
|
|
|
|
$posts[] = $post;
|
|
}
|
|
|
|
$query->posts = $posts;
|
|
$query->post_count = count( $posts );
|
|
|
|
return $posts;
|
|
}
|
|
|
|
/**
|
|
* Limits the search queries to restrict the number of posts handled.
|
|
*
|
|
* Tested.
|
|
*
|
|
* @param string $query The MySQL query.
|
|
*
|
|
* @return string The query with the LIMIT parameter added, if necessary.
|
|
*/
|
|
function relevanssi_limit_filter( $query ) {
|
|
$termless_search = strstr( $query, 'relevanssi.term = relevanssi.term' );
|
|
|
|
if ( $termless_search || 'on' === get_option( 'relevanssi_throttle', 'on' ) ) {
|
|
$limit = get_option( 'relevanssi_throttle_limit', 500 );
|
|
if ( ! is_numeric( $limit ) ) {
|
|
$limit = 500;
|
|
}
|
|
if ( $limit < 0 ) {
|
|
$limit = 500;
|
|
}
|
|
return $query . " ORDER BY tf DESC LIMIT $limit";
|
|
} else {
|
|
return $query;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fetches the list of post types that are excluded from the search.
|
|
*
|
|
* Figures out the post types that are not included in the search.
|
|
*
|
|
* Tested.
|
|
*
|
|
* @param string $include_attachments Whether to include attachments or not.
|
|
*
|
|
* @return string SQL escaped list of excluded post types.
|
|
*/
|
|
function relevanssi_get_negative_post_type( $include_attachments ) {
|
|
$negative_post_type = null;
|
|
$negative_post_type_list = array();
|
|
|
|
if ( isset( $include_attachments ) && in_array( $include_attachments, array( '0', 'off', 'false', false ), true ) ) {
|
|
$negative_post_type_list[] = 'attachment';
|
|
}
|
|
|
|
$front_end = true;
|
|
if ( is_admin() && ( ! defined( 'DOING_AJAX' ) || ! DOING_AJAX ) ) {
|
|
$front_end = false;
|
|
}
|
|
if ( 'on' === get_option( 'relevanssi_respect_exclude' ) && $front_end ) {
|
|
// If Relevanssi is set to respect exclude_from_search, find out which
|
|
// post types should be excluded from search.
|
|
$pt_1 = get_post_types( array( 'exclude_from_search' => '1' ) );
|
|
$pt_2 = get_post_types( array( 'exclude_from_search' => true ) );
|
|
|
|
$negative_post_type_list = array_merge( $negative_post_type_list, $pt_1, $pt_2 );
|
|
}
|
|
|
|
// Post types to exclude.
|
|
if ( count( $negative_post_type_list ) > 0 ) {
|
|
$negative_post_types = esc_sql( array_unique( $negative_post_type_list ) );
|
|
$negative_post_type = null;
|
|
if ( count( $negative_post_types ) ) {
|
|
$negative_post_type = "'" . implode( "', '", $negative_post_types ) . "'";
|
|
}
|
|
}
|
|
|
|
return $negative_post_type;
|
|
}
|
|
|
|
/**
|
|
* Generates the WHERE condition for terms.
|
|
*
|
|
* Trims the term, escapes it and places it in the template.
|
|
*
|
|
* Tested.
|
|
*
|
|
* @param string $term The search term.
|
|
* @param boolean $force_fuzzy If true, force fuzzy search. Default false.
|
|
* @param boolean $no_terms If true, no search term is used. Default false.
|
|
* @param string $option_override If set, won't read the value from the
|
|
* 'relevanssi_fuzzy' option but will use this instead. Used in multisite searching.
|
|
* Default null.
|
|
*
|
|
* @return string The template with the term in place.
|
|
*/
|
|
function relevanssi_generate_term_where( $term, $force_fuzzy = false, $no_terms = false, $option_override = null ) {
|
|
global $wpdb;
|
|
|
|
$fuzzy = get_option( 'relevanssi_fuzzy' );
|
|
if ( $option_override &&
|
|
in_array( $option_override, array( 'always', 'sometimes', 'never' ), true ) ) {
|
|
$fuzzy = $option_override;
|
|
}
|
|
|
|
/**
|
|
* Filters the partial matching search query.
|
|
*
|
|
* By default partial matching matches the beginnings and the ends of the
|
|
* words. If you want it to match inside words, add a function to this
|
|
* hook that returns '(relevanssi.term LIKE '%#term#%')'.
|
|
*
|
|
* @param string The partial matching query.
|
|
*/
|
|
$fuzzy_query = apply_filters(
|
|
'relevanssi_fuzzy_query',
|
|
"(relevanssi.term LIKE '#term#%' OR relevanssi.term_reverse LIKE CONCAT(REVERSE('#term#'), '%')) "
|
|
);
|
|
$basic_query = " relevanssi.term = '#term#' ";
|
|
|
|
if ( 'always' === $fuzzy || $force_fuzzy ) {
|
|
$term_where_template = $fuzzy_query;
|
|
} else {
|
|
$term_where_template = $basic_query;
|
|
}
|
|
if ( $no_terms ) {
|
|
$term_where_template = ' relevanssi.term = relevanssi.term ';
|
|
}
|
|
|
|
$term = trim( $term ); // Numeric search terms will start with a space.
|
|
|
|
if ( relevanssi_strlen( $term ) < 2 ) {
|
|
/**
|
|
* Allows the use of one letter search terms.
|
|
*
|
|
* Return false to allow one letter searches.
|
|
*
|
|
* @param boolean True, if search term is one letter long and will be blocked.
|
|
*/
|
|
if ( apply_filters( 'relevanssi_block_one_letter_searches', true ) ) {
|
|
return null;
|
|
}
|
|
// No fuzzy matching for one-letter search terms.
|
|
$term_where_template = $basic_query;
|
|
}
|
|
|
|
$term = esc_sql( $term );
|
|
|
|
if ( false !== strpos( $term_where_template, 'LIKE' ) ) {
|
|
$term = $wpdb->esc_like( $term );
|
|
}
|
|
|
|
$term_where = str_replace( '#term#', $term, $term_where_template );
|
|
|
|
return $term_where;
|
|
}
|
|
|
|
/**
|
|
* Counts the taxonomy score for a match.
|
|
*
|
|
* Uses the taxonomy_detail object to count the taxonomy score for a match.
|
|
* If there's a taxonomy weight in $post_type_weights, that is used, otherwise
|
|
* assume weight 1.
|
|
*
|
|
* Tested.
|
|
*
|
|
* @since 2.1.5
|
|
*
|
|
* @param object $match The match object, used as a reference.
|
|
* @param array $post_type_weights The post type and taxonomy weights array.
|
|
*/
|
|
function relevanssi_taxonomy_score( &$match, $post_type_weights ) {
|
|
$match->taxonomy_score = 0;
|
|
$match->taxonomy_detail = json_decode( $match->taxonomy_detail );
|
|
if ( is_object( $match->taxonomy_detail ) ) {
|
|
foreach ( $match->taxonomy_detail as $tax => $count ) {
|
|
if ( empty( $post_type_weights[ 'post_tagged_with_' . $tax ] ) ) {
|
|
if ( ! empty( $post_type_weights[ $tax ] ) ) { // Legacy code, needed for 2.1.8, remove later.
|
|
// phpcs:ignore Squiz.Commenting.InlineComment
|
|
// @codeCoverageIgnoreStart
|
|
$match->taxonomy_score += $count * $post_type_weights[ $tax ];
|
|
// @codeCoverageIgnoreEnd
|
|
} else {
|
|
$match->taxonomy_score += $count * 1;
|
|
}
|
|
} else {
|
|
$match->taxonomy_score += $count * $post_type_weights[ 'post_tagged_with_' . $tax ];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Collects the search parameters from the WP_Query object.
|
|
*
|
|
* @global boolean $relevanssi_test_admin If true, assume this is an admin
|
|
* search.
|
|
*
|
|
* @param object $query The WP Query object used as a source.
|
|
* @param string $q The search query.
|
|
*
|
|
* @return array The search parameters.
|
|
*/
|
|
function relevanssi_compile_search_args( $query, $q ) {
|
|
global $relevanssi_test_admin;
|
|
|
|
$tax_query = array();
|
|
/**
|
|
* Filters the default tax_query relation.
|
|
*
|
|
* @param string The default relation, default 'AND'.
|
|
*/
|
|
$tax_query_relation = apply_filters( 'relevanssi_default_tax_query_relation', 'AND' );
|
|
if ( isset( $query->tax_query ) && empty( $query->tax_query->queries ) ) {
|
|
// Tax query is empty, let's get rid of it.
|
|
$query->tax_query = null;
|
|
}
|
|
if ( isset( $query->query_vars['tax_query'] ) ) {
|
|
// This is user-created tax_query array as described in WP Codex.
|
|
foreach ( $query->query_vars['tax_query'] as $type => $item ) {
|
|
if ( is_string( $type ) && 'relation' === $type ) {
|
|
$tax_query_relation = $item;
|
|
} else {
|
|
$tax_query[] = $item;
|
|
}
|
|
}
|
|
} elseif ( isset( $query->tax_query ) ) {
|
|
// This is the WP-created Tax_Query object, which is different from above.
|
|
foreach ( $query->tax_query as $type => $item ) {
|
|
if ( is_string( $type ) && 'relation' === $type ) {
|
|
$tax_query_relation = $item;
|
|
}
|
|
if ( is_string( $type ) && 'queries' === $type ) {
|
|
foreach ( $item as $tax_query_row ) {
|
|
$tax_query[] = $tax_query_row;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
$cat = false;
|
|
if ( isset( $query->query_vars['cats'] ) ) {
|
|
$cat = $query->query_vars['cats'];
|
|
}
|
|
if ( empty( $cat ) ) {
|
|
$cat = get_option( 'relevanssi_cat' );
|
|
}
|
|
if ( $cat ) {
|
|
$cat = explode( ',', $cat );
|
|
$tax_query[] = array(
|
|
'taxonomy' => 'category',
|
|
'field' => 'id',
|
|
'terms' => $cat,
|
|
);
|
|
}
|
|
$excat = get_option( 'relevanssi_excat' );
|
|
|
|
if ( $relevanssi_test_admin || ( is_admin() && ( ! defined( 'DOING_AJAX' ) || ! DOING_AJAX ) ) ) {
|
|
$excat = null;
|
|
}
|
|
|
|
if ( ! empty( $excat ) ) {
|
|
$tax_query[] = array(
|
|
'taxonomy' => 'category',
|
|
'field' => 'id',
|
|
'terms' => $excat,
|
|
'operator' => 'NOT IN',
|
|
);
|
|
}
|
|
|
|
$tag = false;
|
|
if ( ! empty( $query->query_vars['tags'] ) ) {
|
|
$tag = $query->query_vars['tags'];
|
|
if ( false !== strpos( $tag, '+' ) ) {
|
|
$tag = explode( '+', $tag );
|
|
$operator = 'AND';
|
|
} else {
|
|
$tag = explode( ',', $tag );
|
|
$operator = 'OR';
|
|
}
|
|
$tax_query[] = array(
|
|
'taxonomy' => 'post_tag',
|
|
'field' => 'id',
|
|
'terms' => $tag,
|
|
'operator' => $operator,
|
|
);
|
|
}
|
|
if ( ! empty( $query->query_vars['tag_slug__not_in'] ) ) {
|
|
$tax_query[] = array(
|
|
'taxonomy' => 'post_tag',
|
|
'field' => 'slug',
|
|
'terms' => $query->query_vars['tag_slug__not_in'],
|
|
'operator' => 'NOT IN',
|
|
);
|
|
}
|
|
$extag = get_option( 'relevanssi_extag' );
|
|
if ( ! empty( $extag ) && '0' !== $extag ) {
|
|
$tax_query[] = array(
|
|
'taxonomy' => 'post_tag',
|
|
'field' => 'id',
|
|
'terms' => $extag,
|
|
'operator' => 'NOT IN',
|
|
);
|
|
}
|
|
}
|
|
|
|
$author = false;
|
|
if ( ! empty( $query->query_vars['author'] ) ) {
|
|
$author = explode( ',', $query->query_vars['author'] );
|
|
}
|
|
if ( ! empty( $query->query_vars['author_name'] ) ) {
|
|
$author_object = get_user_by( 'slug', $query->query_vars['author_name'] );
|
|
$author[] = $author_object->ID;
|
|
}
|
|
|
|
$post_query = array();
|
|
if ( isset( $query->query_vars['p'] ) && $query->query_vars['p'] ) {
|
|
$post_query = array( 'in' => array( $query->query_vars['p'] ) );
|
|
}
|
|
if ( isset( $query->query_vars['page_id'] ) && $query->query_vars['page_id'] ) {
|
|
$post_query = array( 'in' => array( $query->query_vars['page_id'] ) );
|
|
}
|
|
if ( isset( $query->query_vars['post__in'] ) && is_array( $query->query_vars['post__in'] ) && ! empty( $query->query_vars['post__in'] ) ) {
|
|
$post_query = array( 'in' => $query->query_vars['post__in'] );
|
|
}
|
|
if ( isset( $query->query_vars['post__not_in'] ) && is_array( $query->query_vars['post__not_in'] ) && ! empty( $query->query_vars['post__not_in'] ) ) {
|
|
$post_query = array( 'not in' => $query->query_vars['post__not_in'] );
|
|
}
|
|
|
|
$parent_query = array();
|
|
if ( isset( $query->query_vars['post_parent'] ) && '' !== $query->query_vars['post_parent'] ) {
|
|
$parent_query = array( 'parent in' => array( (int) $query->query_vars['post_parent'] ) );
|
|
}
|
|
if ( isset( $query->query_vars['post_parent__in'] ) && is_array( $query->query_vars['post_parent__in'] ) && ! empty( $query->query_vars['post_parent__in'] ) ) {
|
|
$parent_query = array( 'parent in' => $query->query_vars['post_parent__in'] );
|
|
}
|
|
if ( isset( $query->query_vars['post_parent__not_in'] ) && is_array( $query->query_vars['post_parent__not_in'] ) && ! empty( $query->query_vars['post_parent__not_in'] ) ) {
|
|
$parent_query = array( 'parent not in' => $query->query_vars['post_parent__not_in'] );
|
|
}
|
|
|
|
$meta_query = array();
|
|
if ( ! empty( $query->query_vars['meta_query'] ) ) {
|
|
$meta_query = $query->query_vars['meta_query'];
|
|
}
|
|
|
|
if ( isset( $query->query_vars['customfield_key'] ) ) {
|
|
$build_meta_query = array();
|
|
|
|
// Use meta key.
|
|
$build_meta_query['key'] = $query->query_vars['customfield_key'];
|
|
|
|
/**
|
|
* Check the value is not empty for ordering purpose,
|
|
* set it or not for the current meta query.
|
|
*/
|
|
if ( ! empty( $query->query_vars['customfield_value'] ) ) {
|
|
$build_meta_query['value'] = $query->query_vars['customfield_value'];
|
|
}
|
|
|
|
// Set the compare.
|
|
$build_meta_query['compare'] = '=';
|
|
$meta_query[] = $build_meta_query;
|
|
}
|
|
|
|
if ( ! empty( $query->query_vars['meta_key'] ) || ! empty( $query->query_vars['meta_value'] ) || ! empty( $query->query_vars['meta_value_num'] ) ) {
|
|
$build_meta_query = array();
|
|
|
|
// Use meta key.
|
|
$build_meta_query['key'] = $query->query_vars['meta_key'];
|
|
|
|
$value = null;
|
|
if ( ! empty( $query->query_vars['meta_value'] ) ) {
|
|
$value = $query->query_vars['meta_value'];
|
|
} elseif ( ! empty( $query->query_vars['meta_value_num'] ) ) {
|
|
$value = $query->query_vars['meta_value_num'];
|
|
}
|
|
|
|
/**
|
|
* Check the meta value, as it could be not set for ordering purpose.
|
|
* Set it or not for the current meta query.
|
|
*/
|
|
if ( ! empty( $value ) ) {
|
|
$build_meta_query['value'] = $value;
|
|
}
|
|
|
|
// Set meta compare.
|
|
$build_meta_query['compare'] = '=';
|
|
if ( ! empty( $query->query_vars['meta_compare'] ) ) {
|
|
$build_meta_query['compare'] = $query->query_vars['meta_compare'];
|
|
}
|
|
|
|
$meta_query[] = $build_meta_query;
|
|
}
|
|
|
|
$date_query = false;
|
|
if ( ! empty( $query->date_query ) ) {
|
|
if ( is_object( $query->date_query ) && 'WP_Date_Query' === get_class( $query->date_query ) ) {
|
|
$date_query = $query->date_query;
|
|
} else {
|
|
$date_query = new WP_Date_Query( $query->date_query );
|
|
}
|
|
} elseif ( ! empty( $query->query_vars['date_query'] ) ) {
|
|
// The official date query is in $query->date_query, but this allows
|
|
// users to set the date query from query variables.
|
|
$date_query = new WP_Date_Query( $query->query_vars['date_query'] );
|
|
}
|
|
|
|
if ( ! $date_query ) {
|
|
$date_query = array();
|
|
if ( ! empty( $query->query_vars['year'] ) ) {
|
|
$date_query['year'] = intval( $query->query_vars['year'] );
|
|
}
|
|
if ( ! empty( $query->query_vars['monthnum'] ) ) {
|
|
$date_query['month'] = intval( $query->query_vars['monthnum'] );
|
|
}
|
|
if ( ! empty( $query->query_vars['w'] ) ) {
|
|
$date_query['week'] = intval( $query->query_vars['w'] );
|
|
}
|
|
if ( ! empty( $query->query_vars['day'] ) ) {
|
|
$date_query['day'] = intval( $query->query_vars['day'] );
|
|
}
|
|
if ( ! empty( $query->query_vars['hour'] ) ) {
|
|
$date_query['hour'] = intval( $query->query_vars['hour'] );
|
|
}
|
|
if ( ! empty( $query->query_vars['minute'] ) ) {
|
|
$date_query['minute'] = intval( $query->query_vars['minute'] );
|
|
}
|
|
if ( ! empty( $query->query_vars['second'] ) ) {
|
|
$date_query['second'] = intval( $query->query_vars['second'] );
|
|
}
|
|
if ( ! empty( $query->query_vars['m'] ) ) {
|
|
if ( 6 === strlen( $query->query_vars['m'] ) ) {
|
|
$date_query['year'] = intval( substr( $query->query_vars['m'], 0, 4 ) );
|
|
$date_query['month'] = intval( substr( $query->query_vars['m'], -2, 2 ) );
|
|
}
|
|
}
|
|
if ( ! empty( $date_query ) ) {
|
|
$date_query = new WP_Date_Query( $date_query );
|
|
} else {
|
|
$date_query = false;
|
|
}
|
|
}
|
|
|
|
$post_type = false;
|
|
if ( isset( $query->query_vars['post_type'] ) && 'any' !== $query->query_vars['post_type'] ) {
|
|
$post_type = $query->query_vars['post_type'];
|
|
}
|
|
if ( isset( $query->query_vars['post_types'] ) && 'any' !== $query->query_vars['post_types'] ) {
|
|
$post_type = $query->query_vars['post_types'];
|
|
}
|
|
|
|
$post_status = false;
|
|
if ( isset( $query->query_vars['post_status'] ) && 'any' !== $query->query_vars['post_status'] ) {
|
|
$post_status = $query->query_vars['post_status'];
|
|
}
|
|
|
|
$expost = get_option( 'relevanssi_exclude_posts' );
|
|
if ( $relevanssi_test_admin || ( is_admin() && ( ! defined( 'DOING_AJAX' ) || ! DOING_AJAX ) ) ) {
|
|
$expost = null;
|
|
}
|
|
|
|
$sentence = false;
|
|
if ( isset( $query->query_vars['sentence'] ) && ! empty( $query->query_vars['sentence'] ) ) {
|
|
$sentence = true;
|
|
}
|
|
|
|
$operator = '';
|
|
if ( function_exists( 'relevanssi_set_operator' ) ) {
|
|
$operator = relevanssi_set_operator( $query );
|
|
$operator = strtoupper( $operator );
|
|
}
|
|
if ( ! in_array( $operator, array( 'OR', 'AND' ), true ) ) {
|
|
$operator = get_option( 'relevanssi_implicit_operator' );
|
|
}
|
|
$query->query_vars['operator'] = $operator;
|
|
|
|
$orderby = null;
|
|
$order = null;
|
|
if ( isset( $query->query_vars['orderby'] ) ) {
|
|
$orderby = $query->query_vars['orderby'];
|
|
}
|
|
if ( isset( $query->query_vars['order'] ) ) {
|
|
$order = $query->query_vars['order'];
|
|
}
|
|
|
|
$fields = '';
|
|
if ( ! empty( $query->query_vars['fields'] ) ) {
|
|
if ( 'ids' === $query->query_vars['fields'] ) {
|
|
$fields = 'ids';
|
|
}
|
|
if ( 'id=>parent' === $query->query_vars['fields'] ) {
|
|
$fields = 'id=>parent';
|
|
}
|
|
}
|
|
|
|
$by_date = '';
|
|
if ( ! empty( $query->query_vars['by_date'] ) ) {
|
|
if ( preg_match( '/\d+[hdmyw]/', $query->query_vars['by_date'] ) ) {
|
|
// Accepted format is digits followed by h, d, m, y, or w.
|
|
$by_date = $query->query_vars['by_date'];
|
|
}
|
|
}
|
|
|
|
$admin_search = false;
|
|
if ( isset( $query->query_vars['relevanssi_admin_search'] ) ) {
|
|
$admin_search = true;
|
|
}
|
|
|
|
$include_attachments = '';
|
|
if ( isset( $query->query_vars['include_attachments'] ) ) {
|
|
$include_attachments = $query->query_vars['include_attachments'];
|
|
}
|
|
|
|
if ( function_exists( 'relevanssi_extract_specifier' ) ) {
|
|
$q = relevanssi_extract_specifier( $q );
|
|
}
|
|
|
|
// Add synonyms.
|
|
// This is done here so the new terms will get highlighting.
|
|
$q_no_synonyms = $q;
|
|
if ( 'OR' === $operator ) {
|
|
// Synonyms are only used in OR queries.
|
|
$q = relevanssi_add_synonyms( $q );
|
|
}
|
|
|
|
$search_params = array(
|
|
'q' => $q,
|
|
'q_no_synonyms' => $q_no_synonyms,
|
|
'tax_query' => $tax_query,
|
|
'tax_query_relation' => $tax_query_relation,
|
|
'post_query' => $post_query,
|
|
'parent_query' => $parent_query,
|
|
'meta_query' => $meta_query,
|
|
'date_query' => $date_query,
|
|
'expost' => $expost,
|
|
'post_type' => $post_type,
|
|
'post_status' => $post_status,
|
|
'operator' => $operator,
|
|
'author' => $author,
|
|
'orderby' => $orderby,
|
|
'order' => $order,
|
|
'fields' => $fields,
|
|
'sentence' => $sentence,
|
|
'by_date' => $by_date,
|
|
'admin_search' => $admin_search,
|
|
'include_attachments' => $include_attachments,
|
|
'meta_query' => $meta_query,
|
|
);
|
|
|
|
return $search_params;
|
|
}
|