MatchBuilder::exact() - Code Metrics - Inspection of "Add support for PHP 8" - FoolCode/SphinxQL-Query-Builder - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#197)

unknown

created 2021-02-13 11:44 UTC

MatchBuilder::exact() A

↳ Parent: MatchBuilder

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	3
nc	1
nop	1
dl	0
loc	6
rs	10
c	0
b	0
f	0

<?php

namespace Foolz\SphinxQL;

use Closure;

/**
 * Query Builder class for MatchBuilder statements.
 */
class MatchBuilder
{
    /**
     * The last compiled query.
     *
     * @var string
     */
    protected $last_compiled;

    /**
     * List of match operations.
     *
     * @var array
     */
    protected $tokens = array();

    /**
     * The owning SphinxQL object; used for escaping text.
     *
     * @var SphinxQL
     */
    protected $sphinxql;

    /**
     * @param SphinxQL $sphinxql
     */
    public function __construct(SphinxQL $sphinxql)
    {
        $this->sphinxql = $sphinxql;
    }

    /**
     * Match text or sub expression.
     *
     * Examples:
     *    $match->match('test');
     *    // test
     *
     *    $match->match('test case');
     *    // (test case)
     *
     *    $match->match(function ($m) {
     *        $m->match('a')->orMatch('b');
     *    });
     *    // (a | b)
     *
     *    $sub = new MatchBuilder($sphinxql);
     *    $sub->match('a')->orMatch('b');
     *    $match->match($sub);
     *    // (a | b)
     *
     * @param string|MatchBuilder|\Closure $keywords The text or expression to match.
     *
     * @return $this
     */
    public function match($keywords = null): self
    {
        if ($keywords !== null) {
            $this->tokens[] = array('MATCH' => $keywords);
        }

        return $this;
    }

    /**
     * Provide an alternation match.
     *
     * Examples:
     *    $match->match('test')->orMatch();
     *    // test |
     *
     *    $match->match('test')->orMatch('case');
     *    // test | case
     *
     * @param string|MatchBuilder|\Closure $keywords The text or expression to alternatively match.
     *
     * @return $this
     */
    public function orMatch($keywords = null): self
    {
        $this->tokens[] = array('OPERATOR' => '| ');
        $this->match($keywords);

        return $this;
    }

    /**
     * Provide an optional match.
     *
     * Examples:
     *    $match->match('test')->maybe();
     *    // test MAYBE
     *
     *    $match->match('test')->maybe('case');
     *    // test MAYBE case
     *
     * @param string|MatchBuilder|\Closure $keywords The text or expression to optionally match.
     *
     * @return $this
     */
    public function maybe($keywords = null): self
    {
        $this->tokens[] = array('OPERATOR' => 'MAYBE ');
        $this->match($keywords);

        return $this;
    }

    /**
     * Do not match a keyword.
     *
     * Examples:
     *    $match->not()->match('test');
     *    // -test
     *
     *    $match->not('test');
     *    // -test
     *
     * @param string|MatchBuilder|\Closure $keyword The word not to match.
     *
     * @return $this
     */
    public function not($keyword = null): self
    {
        $this->tokens[] = array('OPERATOR' => '-');
        $this->match($keyword);

        return $this;
    }

    /**
     * Specify which field(s) to search.
     *
     * Examples:
     *    $match->field('*')->match('test');
     *    // @* test
     *
     *    $match->field('title')->match('test');
     *    // @title test
     *
     *    $match->field('body', 50)->match('test');
     *    // @body[50] test
     *
     *    $match->field('title', 'body')->match('test');
     *    // @(title,body) test
     *
     *    $match->field(['title', 'body'])->match('test');
     *    // @(title,body) test
     *
     *    $match->field('@relaxed')->field('nosuchfield')->match('test');
     *    // @@relaxed @nosuchfield test
     *
     * @param string|array $fields Field or fields to search.
     * @param int          $limit  Maximum position limit in field a match is allowed at.
     *
     * @return $this
     */
    public function field($fields, $limit = null): self
    {
        if (is_string($fields)) {
            $fields = func_get_args();
            $limit = null;
        }
        if (!is_string(end($fields))) {
            $limit = array_pop($fields);
        }
        $this->tokens[] = array(
            'FIELD'  => '@',
            'fields' => $fields,
            'limit'  => $limit,
        );

        return $this;
    }

    /**
     * Specify which field(s) not to search.
     *
     * Examples:
     *    $match->ignoreField('title')->match('test');
     *    // @!title test
     *
     *    $match->ignoreField('title', 'body')->match('test');
     *    // @!(title,body) test
     *
     *    $match->ignoreField(['title', 'body'])->match('test');
     *    // @!(title,body) test
     *
     * @param string|array $fields Field or fields to ignore during search.
     *
     * @return $this
     */
    public function ignoreField($fields): self
    {
        if (is_string($fields)) {
            $fields = func_get_args();
        }
        $this->tokens[] = array(
            'FIELD'  => '@!',
            'fields' => $fields,
            'limit'  => null,
        );

        return $this;
    }

    /**
     * Match an exact phrase.
     *
     * Example:
     *    $match->phrase('test case');
     *    // "test case"
     *
     * @param string $keywords The phrase to match.
     *
     * @return $this
     */
    public function phrase($keywords): self
    {
        $this->tokens[] = array('PHRASE' => $keywords);

        return $this;
    }

    /**
     * Provide an optional phrase.
     *
     * Example:
     *    $match->phrase('test case')->orPhrase('another case');
     *    // "test case" | "another case"
     *
     * @param string $keywords The phrase to match.
     *
     * @return $this
     */
    public function orPhrase($keywords): self
    {
        $this->tokens[] = array('OPERATOR' => '| ');
        $this->phrase($keywords);

        return $this;
    }

    /**
     * Match if keywords are close enough.
     *
     * Example:
     *    $match->proximity('test case', 5);
     *    // "test case"~5
     *
     * @param string $keywords The words to match.
     * @param int    $distance The upper limit on separation between words.
     *
     * @return $this
     */
    public function proximity($keywords, $distance): self
    {
        $this->tokens[] = array(
            'PROXIMITY' => $distance,
            'keywords'  => $keywords,
        );

        return $this;
    }

    /**
     * Match if enough keywords are present.
     *
     * Examples:
     *    $match->quorum('this is a test case', 3);
     *    // "this is a test case"/3
     *
     *    $match->quorum('this is a test case', 0.5);
     *    // "this is a test case"/0.5
     *
     * @param string    $keywords  The words to match.
     * @param int|float $threshold The minimum number or percent of words that must match.
     *
     * @return $this
     */
    public function quorum($keywords, $threshold): self
    {
        $this->tokens[] = array(
            'QUORUM'   => $threshold,
            'keywords' => $keywords,
        );

        return $this;
    }

    /**
     * Assert keywords or expressions must be matched in order.
     *
     * Examples:
     *    $match->match('test')->before();
     *    // test <<
     *
     *    $match->match('test')->before('case');
     *    // test << case
     *
     * @param string|MatchBuilder|\Closure $keywords The text or expression that must come after.
     *
     * @return $this
     */
    public function before($keywords = null): self
    {
        $this->tokens[] = array('OPERATOR' => '<< ');
        $this->match($keywords);

        return $this;
    }

    /**
     * Assert a keyword must be matched exactly as written.
     *
     * Examples:
     *    $match->match('test')->exact('cases');
     *    // test =cases
     *
     *    $match->match('test')->exact()->phrase('specific cases');
     *    // test ="specific cases"
     *
     * @param string $keyword The word that must be matched exactly.
     *
     * @return $this
     */
    public function exact($keyword = null): self
    {
        $this->tokens[] = array('OPERATOR' => '=');
        $this->match($keyword);

        return $this;
    }

    /**
     * Boost the IDF score of a keyword.
     *
     * Examples:
     *    $match->match('test')->boost(1.2);
     *    // test^1.2
     *
     *    $match->match('test')->boost('case', 1.2);
     *    // test case^1.2
     *
     * @param string $keyword The word to modify the score of.
     * @param float  $amount  The amount to boost the score.
     *
     * @return $this
     */
    public function boost($keyword, $amount = null): self
    {
        if ($amount === null) {
            $amount = $keyword;
        } else {
            $this->match($keyword);
        }
        $this->tokens[] = array('BOOST' => $amount);

        return $this;
    }

    /**
     * Assert keywords or expressions must be matched close to each other.
     *
     * Examples:
     *    $match->match('test')->near(3);
     *    // test NEAR/3
     *
     *    $match->match('test')->near('case', 3);
     *    // test NEAR/3 case
     *
     * @param string|MatchBuilder|\Closure $keywords The text or expression to match nearby.
     * @param int                   $distance Maximum distance to the match.
     *
     * @return $this
     */
    public function near($keywords, $distance = null): self
    {
        $this->tokens[] = array('NEAR' => $distance ?: $keywords);
        if ($distance !== null) {
            $this->match($keywords);
        }

        return $this;
    }

    /**
     * Assert matches must be in the same sentence.
     *
     * Examples:
     *    $match->match('test')->sentence();
     *    // test SENTENCE
     *
     *    $match->match('test')->sentence('case');
     *    // test SENTENCE case
     *
     * @param string|MatchBuilder|\Closure $keywords The text or expression that must be in the sentence.
     *
     * @return $this
     */
    public function sentence($keywords = null): self
    {
        $this->tokens[] = array('OPERATOR' => 'SENTENCE ');
        $this->match($keywords);

        return $this;
    }

    /**
     * Assert matches must be in the same paragraph.
     *
     * Examples:
     *    $match->match('test')->paragraph();
     *    // test PARAGRAPH
     *
     *    $match->match('test')->paragraph('case');
     *    // test PARAGRAPH case
     *
     * @param string|MatchBuilder|\Closure $keywords The text or expression that must be in the paragraph.
     *
     * @return $this
     */
    public function paragraph($keywords = null): self
    {
        $this->tokens[] = array('OPERATOR' => 'PARAGRAPH ');
        $this->match($keywords);

        return $this;
    }

    /**
     * Assert matches must be in the specified zone(s).
     *
     * Examples:
     *    $match->zone('th');
     *    // ZONE:(th)
     *
     *    $match->zone(['h3', 'h4']);
     *    // ZONE:(h3,h4)
     *
     *    $match->zone('th', 'test');
     *    // ZONE:(th) test
     *
     * @param string|array          $zones    The zone or zones to search.
     * @param string|MatchBuilder|\Closure $keywords The text or expression that must be in these zones.
     *
     * @return $this
     */
    public function zone($zones, $keywords = null): self
    {
        if (is_string($zones)) {
            $zones = array($zones);
        }
        $this->tokens[] = array('ZONE' => $zones);
        $this->match($keywords);

        return $this;
    }


    /**
     * Assert matches must be in the same instance of the specified zone.
     *
     * Examples:
     *    $match->zonespan('th');
     *    // ZONESPAN:(th)
     *
     *    $match->zonespan('th', 'test');
     *    // ZONESPAN:(th) test
     *
     * @param string                $zone     The zone to search.
     * @param string|MatchBuilder|\Closure $keywords The text or expression that must be in this zone.
     *
     * @return $this
     */
    public function zonespan($zone, $keywords = null): self
    {
        $this->tokens[] = array('ZONESPAN' => $zone);
        $this->match($keywords);

        return $this;
    }

    /**
     * Build the match expression.
     * @return $this
     */
    public function compile(): self
    {
        $query = '';

        foreach ($this->tokens as $token) {
            $tokenKey = key($token);

            switch ($tokenKey) {
                case 'MATCH':{
                    $query .= $this->compileMatch($token['MATCH']);
                    break;
                }
                case 'OPERATOR':{
                    $query .= $token['OPERATOR'];
                    break;
                }
                case 'FIELD':{
                    $query .= $this->compileField($token['FIELD'], $token['fields'], $token['limit']);
                    break;
                }
                case 'PHRASE':{
                    $query .= '"'.$this->sphinxql->escapeMatch($token['PHRASE']).'" ';
                    break;
                }
                case 'PROXIMITY':{
                    $query .= '"'.$this->sphinxql->escapeMatch($token['keywords']).'"~';
                    $query .= $token['PROXIMITY'].' ';
                    break;
                }
                case 'QUORUM':{
                    $query .= '"'.$this->sphinxql->escapeMatch($token['keywords']).'"/';
                    $query .= $token['QUORUM'].' ';
                    break;
                }
                case 'BOOST':{
                    $query = rtrim($query).'^'.$token['BOOST'].' ';
                    break;
                }
                case 'NEAR':{
                    $query .= 'NEAR/'.$token['NEAR'].' ';
                    break;
                }
                case 'ZONE':{
                    $query .= 'ZONE:('.implode(',', $token['ZONE']).') ';
                    break;
                }
                case 'ZONESPAN':{
                    $query .= 'ZONESPAN:('.$token['ZONESPAN'].') ';
                    break;
                }
            }
        }

        $this->last_compiled = trim($query);

        return $this;
    }

    private function compileMatch($token): string
    {
        if ($token instanceof Expression) {
            return $token->value().' ';
        }
        if ($token instanceof self) {
            return '('.$token->compile()->getCompiled().') ';
        }
        if ($token instanceof Closure) {
            $sub = new static($this->sphinxql);
            $token($sub);
            return '('.$sub->compile()->getCompiled().') ';
        }
        if (strpos($token, ' ') === false) {
            return $this->sphinxql->escapeMatch($token).' ';
        }
        return '('.$this->sphinxql->escapeMatch($token).') ';
    }

    private function compileField($token, $fields, $limit): string
    {
        $query = $token;

        if (count($fields) === 1) {
            $query .= $fields[0];
        } else {
            $query .= '('.implode(',', $fields).')';
        }
        if ($limit) {
            $query .= '['.$limit.']';
        }
        $query .= ' ';

        return $query;
    }

    /**
     * Returns the latest compiled match expression.
     *
     * @return string The last compiled match expression.
     */
    public function getCompiled(): string
    {
        return $this->last_compiled;
    }
}


1			<?php
2
3			namespace Foolz\SphinxQL;
4
5			use Closure;
6
7			/**
8			* Query Builder class for MatchBuilder statements.
9			*/
10			class MatchBuilder
11			{
12			/**
13			* The last compiled query.
14			*
15			* @var string
16			*/
17			protected $last_compiled;
18
19			/**
20			* List of match operations.
21			*
22			* @var array
23			*/
24			protected $tokens = array();
25
26			/**
27			* The owning SphinxQL object; used for escaping text.
28			*
29			* @var SphinxQL
30			*/
31			protected $sphinxql;
32
33			/**
34			* @param SphinxQL $sphinxql
35			*/
36			public function __construct(SphinxQL $sphinxql)
37			{
38			$this->sphinxql = $sphinxql;
39			}
40
41			/**
42			* Match text or sub expression.
43			*
44			* Examples:
45			* $match->match('test');
46			* // test
47			*
48			* $match->match('test case');
49			* // (test case)
50			*
51			* $match->match(function ($m) {
52			* $m->match('a')->orMatch('b');
53			* });
54			* // (a \| b)
55			*
56			* $sub = new MatchBuilder($sphinxql);
57			* $sub->match('a')->orMatch('b');
58			* $match->match($sub);
59			* // (a \| b)
60			*
61			* @param string\|MatchBuilder\|\Closure $keywords The text or expression to match.
62			*
63			* @return $this
64			*/
65			public function match($keywords = null): self
66			{
67			if ($keywords !== null) {
68			$this->tokens[] = array('MATCH' => $keywords);
69			}
70
71			return $this;
72			}
73
74			/**
75			* Provide an alternation match.
76			*
77			* Examples:
78			* $match->match('test')->orMatch();
79			* // test \|
80			*
81			* $match->match('test')->orMatch('case');
82			* // test \| case
83			*
84			* @param string\|MatchBuilder\|\Closure $keywords The text or expression to alternatively match.
85			*
86			* @return $this
87			*/
88			public function orMatch($keywords = null): self
89			{
90			$this->tokens[] = array('OPERATOR' => '\| ');
91			$this->match($keywords);
92
93			return $this;
94			}
95
96			/**
97			* Provide an optional match.
98			*
99			* Examples:
100			* $match->match('test')->maybe();
101			* // test MAYBE
102			*
103			* $match->match('test')->maybe('case');
104			* // test MAYBE case
105			*
106			* @param string\|MatchBuilder\|\Closure $keywords The text or expression to optionally match.
107			*
108			* @return $this
109			*/
110			public function maybe($keywords = null): self
111			{
112			$this->tokens[] = array('OPERATOR' => 'MAYBE ');
113			$this->match($keywords);
114
115			return $this;
116			}
117
118			/**
119			* Do not match a keyword.
120			*
121			* Examples:
122			* $match->not()->match('test');
123			* // -test
124			*
125			* $match->not('test');
126			* // -test
127			*
128			* @param string\|MatchBuilder\|\Closure $keyword The word not to match.
129			*
130			* @return $this
131			*/
132			public function not($keyword = null): self
133			{
134			$this->tokens[] = array('OPERATOR' => '-');
135			$this->match($keyword);
136
137			return $this;
138			}
139
140			/**
141			* Specify which field(s) to search.
142			*
143			* Examples:
144			* $match->field('*')->match('test');
145			* // @* test
146			*
147			* $match->field('title')->match('test');
148			* // @title test
149			*
150			* $match->field('body', 50)->match('test');
151			* // @body[50] test
152			*
153			* $match->field('title', 'body')->match('test');
154			* // @(title,body) test
155			*
156			* $match->field(['title', 'body'])->match('test');
157			* // @(title,body) test
158			*
159			* $match->field('@relaxed')->field('nosuchfield')->match('test');
160			* // @@relaxed @nosuchfield test
161			*
162			* @param string\|array $fields Field or fields to search.
163			* @param int $limit Maximum position limit in field a match is allowed at.
164			*
165			* @return $this
166			*/
167			public function field($fields, $limit = null): self
168			{
169			if (is_string($fields)) {
170			$fields = func_get_args();
171			$limit = null;
172			}
173			if (!is_string(end($fields))) {
174			$limit = array_pop($fields);
175			}
176			$this->tokens[] = array(
177			'FIELD' => '@',
178			'fields' => $fields,
179			'limit' => $limit,
180			);
181
182			return $this;
183			}
184
185			/**
186			* Specify which field(s) not to search.
187			*
188			* Examples:
189			* $match->ignoreField('title')->match('test');
190			* // @!title test
191			*
192			* $match->ignoreField('title', 'body')->match('test');
193			* // @!(title,body) test
194			*
195			* $match->ignoreField(['title', 'body'])->match('test');
196			* // @!(title,body) test
197			*
198			* @param string\|array $fields Field or fields to ignore during search.
199			*
200			* @return $this
201			*/
202			public function ignoreField($fields): self
203			{
204			if (is_string($fields)) {
205			$fields = func_get_args();
206			}
207			$this->tokens[] = array(
208			'FIELD' => '@!',
209			'fields' => $fields,
210			'limit' => null,
211			);
212
213			return $this;
214			}
215
216			/**
217			* Match an exact phrase.
218			*
219			* Example:
220			* $match->phrase('test case');
221			* // "test case"
222			*
223			* @param string $keywords The phrase to match.
224			*
225			* @return $this
226			*/
227			public function phrase($keywords): self
228			{
229			$this->tokens[] = array('PHRASE' => $keywords);
230
231			return $this;
232			}
233
234			/**
235			* Provide an optional phrase.
236			*
237			* Example:
238			* $match->phrase('test case')->orPhrase('another case');
239			* // "test case" \| "another case"
240			*
241			* @param string $keywords The phrase to match.
242			*
243			* @return $this
244			*/
245			public function orPhrase($keywords): self
246			{
247			$this->tokens[] = array('OPERATOR' => '\| ');
248			$this->phrase($keywords);
249
250			return $this;
251			}
252
253			/**
254			* Match if keywords are close enough.
255			*
256			* Example:
257			* $match->proximity('test case', 5);
258			* // "test case"~5
259			*
260			* @param string $keywords The words to match.
261			* @param int $distance The upper limit on separation between words.
262			*
263			* @return $this
264			*/
265			public function proximity($keywords, $distance): self
266			{
267			$this->tokens[] = array(
268			'PROXIMITY' => $distance,
269			'keywords' => $keywords,
270			);
271
272			return $this;
273			}
274
275			/**
276			* Match if enough keywords are present.
277			*
278			* Examples:
279			* $match->quorum('this is a test case', 3);
280			* // "this is a test case"/3
281			*
282			* $match->quorum('this is a test case', 0.5);
283			* // "this is a test case"/0.5
284			*
285			* @param string $keywords The words to match.
286			* @param int\|float $threshold The minimum number or percent of words that must match.
287			*
288			* @return $this
289			*/
290			public function quorum($keywords, $threshold): self
291			{
292			$this->tokens[] = array(
293			'QUORUM' => $threshold,
294			'keywords' => $keywords,
295			);
296
297			return $this;
298			}
299
300			/**
301			* Assert keywords or expressions must be matched in order.
302			*
303			* Examples:
304			* $match->match('test')->before();
305			* // test <<
306			*
307			* $match->match('test')->before('case');
308			* // test << case
309			*
310			* @param string\|MatchBuilder\|\Closure $keywords The text or expression that must come after.
311			*
312			* @return $this
313			*/
314			public function before($keywords = null): self
315			{
316			$this->tokens[] = array('OPERATOR' => '<< ');
317			$this->match($keywords);
318
319			return $this;
320			}
321
322			/**
323			* Assert a keyword must be matched exactly as written.
324			*
325			* Examples:
326			* $match->match('test')->exact('cases');
327			* // test =cases
328			*
329			* $match->match('test')->exact()->phrase('specific cases');
330			* // test ="specific cases"
331			*
332			* @param string $keyword The word that must be matched exactly.
333			*
334			* @return $this
335			*/
336			public function exact($keyword = null): self
337			{
338			$this->tokens[] = array('OPERATOR' => '=');
339			$this->match($keyword);
340
341			return $this;
342			}
343
344			/**
345			* Boost the IDF score of a keyword.
346			*
347			* Examples:
348			* $match->match('test')->boost(1.2);
349			* // test^1.2
350			*
351			* $match->match('test')->boost('case', 1.2);
352			* // test case^1.2
353			*
354			* @param string $keyword The word to modify the score of.
355			* @param float $amount The amount to boost the score.
356			*
357			* @return $this
358			*/
359			public function boost($keyword, $amount = null): self
360			{
361			if ($amount === null) {
362			$amount = $keyword;
363			} else {
364			$this->match($keyword);
365			}
366			$this->tokens[] = array('BOOST' => $amount);
367
368			return $this;
369			}
370
371			/**
372			* Assert keywords or expressions must be matched close to each other.
373			*
374			* Examples:
375			* $match->match('test')->near(3);
376			* // test NEAR/3
377			*
378			* $match->match('test')->near('case', 3);
379			* // test NEAR/3 case
380			*
381			* @param string\|MatchBuilder\|\Closure $keywords The text or expression to match nearby.
382			* @param int $distance Maximum distance to the match.
383			*
384			* @return $this
385			*/
386			public function near($keywords, $distance = null): self
387			{
388			$this->tokens[] = array('NEAR' => $distance ?: $keywords);
389			if ($distance !== null) {
390			$this->match($keywords);
391			}
392
393			return $this;
394			}
395
396			/**
397			* Assert matches must be in the same sentence.
398			*
399			* Examples:
400			* $match->match('test')->sentence();
401			* // test SENTENCE
402			*
403			* $match->match('test')->sentence('case');
404			* // test SENTENCE case
405			*
406			* @param string\|MatchBuilder\|\Closure $keywords The text or expression that must be in the sentence.
407			*
408			* @return $this
409			*/
410			public function sentence($keywords = null): self
411			{
412			$this->tokens[] = array('OPERATOR' => 'SENTENCE ');
413			$this->match($keywords);
414
415			return $this;
416			}
417
418			/**
419			* Assert matches must be in the same paragraph.
420			*
421			* Examples:
422			* $match->match('test')->paragraph();
423			* // test PARAGRAPH
424			*
425			* $match->match('test')->paragraph('case');
426			* // test PARAGRAPH case
427			*
428			* @param string\|MatchBuilder\|\Closure $keywords The text or expression that must be in the paragraph.
429			*
430			* @return $this
431			*/
432			public function paragraph($keywords = null): self
433			{
434			$this->tokens[] = array('OPERATOR' => 'PARAGRAPH ');
435			$this->match($keywords);
436
437			return $this;
438			}
439
440			/**
441			* Assert matches must be in the specified zone(s).
442			*
443			* Examples:
444			* $match->zone('th');
445			* // ZONE:(th)
446			*
447			* $match->zone(['h3', 'h4']);
448			* // ZONE:(h3,h4)
449			*
450			* $match->zone('th', 'test');
451			* // ZONE:(th) test
452			*
453			* @param string\|array $zones The zone or zones to search.
454			* @param string\|MatchBuilder\|\Closure $keywords The text or expression that must be in these zones.
455			*
456			* @return $this
457			*/
458			public function zone($zones, $keywords = null): self
459			{
460			if (is_string($zones)) {
461			$zones = array($zones);
462			}
463			$this->tokens[] = array('ZONE' => $zones);
464			$this->match($keywords);
465
466			return $this;
467			}
468
469
470			/**
471			* Assert matches must be in the same instance of the specified zone.
472			*
473			* Examples:
474			* $match->zonespan('th');
475			* // ZONESPAN:(th)
476			*
477			* $match->zonespan('th', 'test');
478			* // ZONESPAN:(th) test
479			*
480			* @param string $zone The zone to search.
481			* @param string\|MatchBuilder\|\Closure $keywords The text or expression that must be in this zone.
482			*
483			* @return $this
484			*/
485			public function zonespan($zone, $keywords = null): self
486			{
487			$this->tokens[] = array('ZONESPAN' => $zone);
488			$this->match($keywords);
489
490			return $this;
491			}
492
493			/**
494			* Build the match expression.
495			* @return $this
496			*/
497			public function compile(): self
498			{
499			$query = '';
500
501			foreach ($this->tokens as $token) {
502			$tokenKey = key($token);
503
504			switch ($tokenKey) {
505			case 'MATCH':{
506			$query .= $this->compileMatch($token['MATCH']);
507			break;
508			}
509			case 'OPERATOR':{
510			$query .= $token['OPERATOR'];
511			break;
512			}
513			case 'FIELD':{
514			$query .= $this->compileField($token['FIELD'], $token['fields'], $token['limit']);
515			break;
516			}
517			case 'PHRASE':{
518			$query .= '"'.$this->sphinxql->escapeMatch($token['PHRASE']).'" ';
519			break;
520			}
521			case 'PROXIMITY':{
522			$query .= '"'.$this->sphinxql->escapeMatch($token['keywords']).'"~';
523			$query .= $token['PROXIMITY'].' ';
524			break;
525			}
526			case 'QUORUM':{
527			$query .= '"'.$this->sphinxql->escapeMatch($token['keywords']).'"/';
528			$query .= $token['QUORUM'].' ';
529			break;
530			}
531			case 'BOOST':{
532			$query = rtrim($query).'^'.$token['BOOST'].' ';
533			break;
534			}
535			case 'NEAR':{
536			$query .= 'NEAR/'.$token['NEAR'].' ';
537			break;
538			}
539			case 'ZONE':{
540			$query .= 'ZONE:('.implode(',', $token['ZONE']).') ';
541			break;
542			}
543			case 'ZONESPAN':{
544			$query .= 'ZONESPAN:('.$token['ZONESPAN'].') ';
545			break;
546			}
547			}
548			}
549
550			$this->last_compiled = trim($query);
551
552			return $this;
553			}
554
555			private function compileMatch($token): string
556			{
557			if ($token instanceof Expression) {
558			return $token->value().' ';
559			}
560			if ($token instanceof self) {
561			return '('.$token->compile()->getCompiled().') ';
562			}
563			if ($token instanceof Closure) {
564			$sub = new static($this->sphinxql);
565			$token($sub);
566			return '('.$sub->compile()->getCompiled().') ';
567			}
568			if (strpos($token, ' ') === false) {
569			return $this->sphinxql->escapeMatch($token).' ';
570			}
571			return '('.$this->sphinxql->escapeMatch($token).') ';
572			}
573
574			private function compileField($token, $fields, $limit): string
575			{
576			$query = $token;
577
578			if (count($fields) === 1) {
579			$query .= $fields[0];
580			} else {
581			$query .= '('.implode(',', $fields).')';
582			}
583			if ($limit) {
584			$query .= '['.$limit.']';
585			}
586			$query .= ' ';
587
588			return $query;
589			}
590
591			/**
592			* Returns the latest compiled match expression.
593			*
594			* @return string The last compiled match expression.
595			*/
596			public function getCompiled(): string
597			{
598			return $this->last_compiled;
599			}
600			}
601

FoolCode / SphinxQL-Query-Builder

Pull Request — master (#197)

MatchBuilder::exact() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like