Code Coverage
 
Classes and Traits
Functions and Methods
Lines
Total
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 9
CRAP
0.00% covered (danger)
0.00%
0 / 125
FullTextSimpleMatchQueryBuilder
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 9
1190
0.00% covered (danger)
0.00%
0 / 125
 __construct
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 9
 buildSearchTextQuery
0.00% covered (danger)
0.00%
0 / 1
12
0.00% covered (danger)
0.00%
0 / 15
 buildHighlightQuery
0.00% covered (danger)
0.00%
0 / 1
12
0.00% covered (danger)
0.00%
0 / 4
 buildPhraseRescoreQuery
0.00% covered (danger)
0.00%
0 / 1
12
0.00% covered (danger)
0.00%
0 / 11
 getMultiTermRewriteMethod
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 1
 buildExpQuery
0.00% covered (danger)
0.00%
0 / 1
156
0.00% covered (danger)
0.00%
0 / 45
 attachFilter
0.00% covered (danger)
0.00%
0 / 1
20
0.00% covered (danger)
0.00%
0 / 13
 buildSimpleAllFilter
0.00% covered (danger)
0.00%
0 / 1
20
0.00% covered (danger)
0.00%
0 / 13
 buildTitleFilter
0.00% covered (danger)
0.00%
0 / 1
12
0.00% covered (danger)
0.00%
0 / 14
<?php
namespace CirrusSearch\Query;
use CirrusSearch\Search\SearchContext;
use CirrusSearch\SearchConfig;
/**
 * Simple Match query builder, currently based on
 * FullTextQueryStringQueryBuilder to reuse its parsing logic.
 * It will only support queries that do not use the lucene QueryString syntax
 * and fallbacks to FullTextQueryStringQueryBuilder in such cases.
 * It generates only simple match/multi_match queries. It supports merging
 * multiple clauses into a dismax query with 'in_dismax'.
 */
class FullTextSimpleMatchQueryBuilder extends FullTextQueryStringQueryBuilder {
    /**
     * @var bool true is the main used the experimental query
     */
    private $usedExpQuery = false;
    /**
     * @var float[]|array[] mixed array of field settings used for the main query
     */
    private $fields;
    /**
     * @var float[]|array[] mixed array of field settings used for the phrase rescore query
     */
    private $phraseFields;
    /**
     * @var float default weight to use for stems
     */
    private $defaultStemWeight;
    /**
     * @var string default multimatch query type
     */
    private $defaultQueryType;
    /**
     * @var string default multimatch min should match
     */
    private $defaultMinShouldMatch;
    /**
     * @var array[] dismax query settings
     */
    private $dismaxSettings;
    /**
     * @var array filter settings
     */
    private $filter;
    public function __construct( SearchConfig $config, array $feature, array $settings ) {
        parent::__construct( $config, $feature );
        $this->fields = $settings['fields'];
        $this->filter = $settings['filter'] ?? [ 'type' => 'default' ];
        $this->phraseFields = $settings['phrase_rescore_fields'];
        $this->defaultStemWeight = $settings['default_stem_weight'];
        $this->defaultQueryType = $settings['default_query_type'];
        $this->defaultMinShouldMatch = $settings['default_min_should_match'];
        $this->dismaxSettings = $settings['dismax_settings'] ?? [];
    }
    /**
     * Build the primary query used for full text search.
     * If query_string syntax is not used the experimental query is built.
     * We fallback to parent implementation otherwise.
     *
     * @param SearchContext $context
     * @param string[] $fields
     * @param string[] $nearMatchFields
     * @param string $queryString
     * @param string $nearMatchQuery
     * @return \Elastica\Query\AbstractQuery
     */
    protected function buildSearchTextQuery(
        SearchContext $context,
        array $fields,
        array $nearMatchFields,
        $queryString,
        $nearMatchQuery
    ) {
        if ( $context->isSyntaxUsed( 'query_string' ) ) {
            return parent::buildSearchTextQuery( $context, $fields,
                $nearMatchFields, $queryString, $nearMatchQuery );
        }
        $context->addSyntaxUsed( 'full_text_simple_match', 5 );
        $this->usedExpQuery = true;
        $queryForMostFields = $this->buildExpQuery( $queryString );
        if ( !$nearMatchQuery ) {
            return $queryForMostFields;
        }
        // Build one query for the full text fields and one for the near match fields so that
        // the near match can run unescaped.
        $bool = new \Elastica\Query\BoolQuery();
        $bool->setMinimumShouldMatch( 1 );
        $bool->addShould( $queryForMostFields );
        $nearMatch = new \Elastica\Query\MultiMatch();
        $nearMatch->setFields( $nearMatchFields );
        $nearMatch->setQuery( $nearMatchQuery );
        $bool->addShould( $nearMatch );
        return $bool;
    }
    /**
     * Builds the highlight query
     * @param SearchContext $context
     * @param string[] $fields
     * @param string $queryText
     * @param int $slop
     * @return \Elastica\Query\AbstractQuery
     */
    protected function buildHighlightQuery( SearchContext $context, array $fields, $queryText, $slop ) {
        $query = parent::buildHighlightQuery( $context, $fields, $queryText, $slop );
        if ( $this->usedExpQuery && $query instanceof \Elastica\Query\QueryString ) {
            // the exp query accepts more docs (stopwords in query are not required)
            $query->setDefaultOperator( 'OR' );
        }
        return $query;
    }
    /**
     * Builds the phrase rescore query
     * @param SearchContext $context
     * @param string[] $fields
     * @param string $queryText
     * @param int $slop
     * @return \Elastica\Query\AbstractQuery
     */
    protected function buildPhraseRescoreQuery( SearchContext $context, array $fields, $queryText, $slop ) {
        if ( $this->usedExpQuery ) {
            $phrase = new \Elastica\Query\MultiMatch();
            $phrase->setParam( 'type', 'phrase' );
            $phrase->setParam( 'slop', $slop );
            $fields = [];
            foreach ( $this->phraseFields as $f => $b ) {
                $fields[] = "$f^$b";
            }
            $phrase->setFields( $fields );
            $phrase->setQuery( $queryText );
            return $this->maybeWrapWithTokenCountRouter( $queryText, $phrase );
        } else {
            return parent::buildPhraseRescoreQuery( $context, $fields, $queryText, $slop );
        }
    }
    /**
     * @inheritDoc
     */
    protected function getMultiTermRewriteMethod() {
        // Use blended freq as a rewrite method. The
        // top_terms_boost_1024 method used by the parent is not well
        // suited for a weighted sum and for some reasons uses the
        // queryNorms which depends on the number of terms found by the
        // wildcard. Using this one we'll use the similarity configured
        // for this field instead of a constant score and in the case
        // of BM25 queryNorm is ignored (removed in lucene 7)
        return 'top_terms_blended_freqs_1024';
    }
    /**
     * Generate an elasticsearch query by reading profile settings
     * @param string $queryString the query text
     * @return \Elastica\Query\AbstractQuery
     */
    private function buildExpQuery( $queryString ) {
        $query = new \Elastica\Query\BoolQuery();
        $query->setMinimumShouldMatch( 0 );
        $this->attachFilter( $this->filter, $queryString, $query );
        $dismaxQueries = [];
        foreach ( $this->fields as $f => $settings ) {
            $mmatch = new \Elastica\Query\MultiMatch();
            $mmatch->setQuery( $queryString );
            $queryType = $this->defaultQueryType;
            $minShouldMatch = $this->defaultMinShouldMatch;
            $stemWeight = $this->defaultStemWeight;
            $boost = 1;
            $fields = [ "$f.plain^1", "$f^$stemWeight" ];
            $in_dismax = null;
            if ( is_array( $settings ) ) {
                $boost = $settings['boost'] ?? $boost;
                $queryType = $settings['query_type'] ?? $queryType;
                $minShouldMatch = $settings['min_should_match'] ?? $minShouldMatch;
                if ( isset( $settings['is_plain'] ) && $settings['is_plain'] ) {
                    $fields = [ $f ];
                } else {
                    $fields = [ "$f.plain^1", "$f^$stemWeight" ];
                }
                $in_dismax = $settings['in_dismax'] ?? null;
            } else {
                $boost = $settings;
            }
            if ( $boost === 0 ) {
                continue;
            }
            $mmatch->setParam( 'boost', $boost );
            $mmatch->setMinimumShouldMatch( $minShouldMatch );
            $mmatch->setType( $queryType );
            $mmatch->setFields( $fields );
            $mmatch->setParam( 'boost', $boost );
            $mmatch->setQuery( $queryString );
            if ( $in_dismax ) {
                $dismaxQueries[$in_dismax][] = $mmatch;
            } else {
                $query->addShould( $mmatch );
            }
        }
        foreach ( $dismaxQueries as $name => $queries ) {
            $dismax = new \Elastica\Query\DisMax();
            if ( isset( $this->dismaxSettings[$name] ) ) {
                $settings = $this->dismaxSettings[$name];
                if ( isset( $settings['tie_breaker'] ) ) {
                    $dismax->setTieBreaker( $settings['tie_breaker'] );
                }
                if ( isset( $settings['boost'] ) ) {
                    $dismax->setBoost( $settings['boost'] );
                }
            }
            foreach ( $queries as $q ) {
                $dismax->addQuery( $q );
            }
            $query->addShould( $dismax );
        }
        return $query;
    }
    /**
     * Attach the query filter to $boolQuery
     *
     * @param array $filterDef filter definition
     * @param string $query query text
     * @param \Elastica\Query\BoolQuery $boolQuery the query to attach the filter to
     */
    private function attachFilter( array $filterDef, $query, \Elastica\Query\BoolQuery $boolQuery ) {
        if ( !isset( $filterDef['type'] ) ) {
            throw new \RuntimeException( "Cannot configure the filter clause, 'type' must be defined." );
        }
        $type = $filterDef['type'];
        $filter = null;
        switch ( $type ) {
        case 'default':
            $filter = $this->buildSimpleAllFilter( $filterDef, $query );
            break;
        case 'constrain_title':
            $filter = $this->buildTitleFilter( $filterDef, $query );
            break;
        default:
            throw new \RuntimeException( "Cannot build the filter clause: unknown filter type $type" );
        }
        $boolQuery->addFilter( $filter );
    }
    /**
     * Builds a simple filter on all and all.plain when all terms must match
     *
     * @param array[] $options array containing filter options
     * @param string $query
     * @return \Elastica\Query\AbstractQuery
     */
    private function buildSimpleAllFilter( $options, $query ) {
        $filter = new \Elastica\Query\BoolQuery();
        $filter->setMinimumShouldMatch( 1 );
        // FIXME: We can't use solely the stem field here
        // - Depending on languages it may lack stopwords,
        // A dedicated field used for filtering would be nice
        foreach ( [ 'all', 'all.plain' ] as $field ) {
            $m = new \Elastica\Query\MatchQuery();
            $m->setFieldQuery( $field, $query );
            $minShouldMatch = '100%';
            if ( isset( $options['settings'][$field]['minimum_should_match'] ) ) {
                $minShouldMatch = $options['settings'][$field]['minimum_should_match'];
            }
            if ( $minShouldMatch === '100%' ) {
                $m->setFieldOperator( $field, 'AND' );
            } else {
                $m->setFieldMinimumShouldMatch( $field, $minShouldMatch );
            }
            $filter->addShould( $m );
        }
        return $filter;
    }
    /**
     * Builds a simple filter based on buildSimpleAllFilter + a constraint
     * on title/redirect :
     * (all:query OR all.plain:query) AND (title:query OR redirect:query)
     * where the filter on title/redirect can be controlled by setting
     * minimum_should_match to relax the constraint on title.
     * (defaults to '3<80%')
     *
     * @param array[] $options array containing filter options
     * @param string $query the user query
     * @return \Elastica\Query\AbstractQuery
     */
    private function buildTitleFilter( $options, $query ) {
        $filter = new \Elastica\Query\BoolQuery();
        $filter->addMust( $this->buildSimpleAllFilter( $options, $query ) );
        $minShouldMatch = '3<80%';
        if ( isset( $options['settings']['minimum_should_match'] ) ) {
            $minShouldMatch = $options['settings']['minimum_should_match'];
        }
        $titleFilter = new \Elastica\Query\BoolQuery();
        $titleFilter->setMinimumShouldMatch( 1 );
        foreach ( [ 'title', 'redirect.title' ] as $field ) {
            $m = new \Elastica\Query\MatchQuery();
            $m->setFieldQuery( $field, $query );
            $m->setFieldMinimumShouldMatch( $field, $minShouldMatch );
            $titleFilter->addShould( $m );
        }
        $filter->addMust( $titleFilter );
        return $filter;
    }
}