PageRenderTime 46ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 0ms

/src/application/libraries/Zend/Search/Lucene/Search/QueryParser.php

https://bitbucket.org/masnug/grc276-blog-laravel
PHP | 635 lines | 333 code | 85 blank | 217 comment | 37 complexity | 147ee3053c7931762ca45b5dd4379ec8 MD5 | raw file
  1. <?php
  2. /**
  3. * Zend Framework
  4. *
  5. * LICENSE
  6. *
  7. * This source file is subject to the new BSD license that is bundled
  8. * with this package in the file LICENSE.txt.
  9. * It is also available through the world-wide-web at this URL:
  10. * http://framework.zend.com/license/new-bsd
  11. * If you did not receive a copy of the license and are unable to
  12. * obtain it through the world-wide-web, please send an email
  13. * to license@zend.com so we can send you a copy immediately.
  14. *
  15. * @category Zend
  16. * @package Zend_Search_Lucene
  17. * @subpackage Search
  18. * @copyright Copyright (c) 2005-2011 Zend Technologies USA Inc. (http://www.zend.com)
  19. * @license http://framework.zend.com/license/new-bsd New BSD License
  20. * @version $Id: QueryParser.php 23775 2011-03-01 17:25:24Z ralph $
  21. */
  22. /** Internally used classes */
  23. /** Zend_Search_Lucene_Analysis_Analyzer */
  24. require_once 'Zend/Search/Lucene/Analysis/Analyzer.php';
  25. /** Zend_Search_Lucene_Search_QueryToken */
  26. require_once 'Zend/Search/Lucene/Search/QueryToken.php';
  27. /** Zend_Search_Lucene_FSM */
  28. require_once 'Zend/Search/Lucene/FSM.php';
  29. /**
  30. * @category Zend
  31. * @package Zend_Search_Lucene
  32. * @subpackage Search
  33. * @copyright Copyright (c) 2005-2011 Zend Technologies USA Inc. (http://www.zend.com)
  34. * @license http://framework.zend.com/license/new-bsd New BSD License
  35. */
  36. class Zend_Search_Lucene_Search_QueryParser extends Zend_Search_Lucene_FSM
  37. {
  38. /**
  39. * Parser instance
  40. *
  41. * @var Zend_Search_Lucene_Search_QueryParser
  42. */
  43. private static $_instance = null;
  44. /**
  45. * Query lexer
  46. *
  47. * @var Zend_Search_Lucene_Search_QueryLexer
  48. */
  49. private $_lexer;
  50. /**
  51. * Tokens list
  52. * Array of Zend_Search_Lucene_Search_QueryToken objects
  53. *
  54. * @var array
  55. */
  56. private $_tokens;
  57. /**
  58. * Current token
  59. *
  60. * @var integer|string
  61. */
  62. private $_currentToken;
  63. /**
  64. * Last token
  65. *
  66. * It can be processed within FSM states, but this addirional state simplifies FSM
  67. *
  68. * @var Zend_Search_Lucene_Search_QueryToken
  69. */
  70. private $_lastToken = null;
  71. /**
  72. * Range query first term
  73. *
  74. * @var string
  75. */
  76. private $_rqFirstTerm = null;
  77. /**
  78. * Current query parser context
  79. *
  80. * @var Zend_Search_Lucene_Search_QueryParserContext
  81. */
  82. private $_context;
  83. /**
  84. * Context stack
  85. *
  86. * @var array
  87. */
  88. private $_contextStack;
  89. /**
  90. * Query string encoding
  91. *
  92. * @var string
  93. */
  94. private $_encoding;
  95. /**
  96. * Query string default encoding
  97. *
  98. * @var string
  99. */
  100. private $_defaultEncoding = '';
  101. /**
  102. * Defines query parsing mode.
  103. *
  104. * If this option is turned on, then query parser suppress query parser exceptions
  105. * and constructs multi-term query using all words from a query.
  106. *
  107. * That helps to avoid exceptions caused by queries, which don't conform to query language,
  108. * but limits possibilities to check, that query entered by user has some inconsistencies.
  109. *
  110. *
  111. * Default is true.
  112. *
  113. * Use {@link Zend_Search_Lucene::suppressQueryParsingExceptions()},
  114. * {@link Zend_Search_Lucene::dontSuppressQueryParsingExceptions()} and
  115. * {@link Zend_Search_Lucene::checkQueryParsingExceptionsSuppressMode()} to operate
  116. * with this setting.
  117. *
  118. * @var boolean
  119. */
  120. private $_suppressQueryParsingExceptions = true;
  121. /**
  122. * Boolean operators constants
  123. */
  124. const B_OR = 0;
  125. const B_AND = 1;
  126. /**
  127. * Default boolean queries operator
  128. *
  129. * @var integer
  130. */
  131. private $_defaultOperator = self::B_OR;
  132. /** Query parser State Machine states */
  133. const ST_COMMON_QUERY_ELEMENT = 0; // Terms, phrases, operators
  134. const ST_CLOSEDINT_RQ_START = 1; // Range query start (closed interval) - '['
  135. const ST_CLOSEDINT_RQ_FIRST_TERM = 2; // First term in '[term1 to term2]' construction
  136. const ST_CLOSEDINT_RQ_TO_TERM = 3; // 'TO' lexeme in '[term1 to term2]' construction
  137. const ST_CLOSEDINT_RQ_LAST_TERM = 4; // Second term in '[term1 to term2]' construction
  138. const ST_CLOSEDINT_RQ_END = 5; // Range query end (closed interval) - ']'
  139. const ST_OPENEDINT_RQ_START = 6; // Range query start (opened interval) - '{'
  140. const ST_OPENEDINT_RQ_FIRST_TERM = 7; // First term in '{term1 to term2}' construction
  141. const ST_OPENEDINT_RQ_TO_TERM = 8; // 'TO' lexeme in '{term1 to term2}' construction
  142. const ST_OPENEDINT_RQ_LAST_TERM = 9; // Second term in '{term1 to term2}' construction
  143. const ST_OPENEDINT_RQ_END = 10; // Range query end (opened interval) - '}'
  144. /**
  145. * Parser constructor
  146. */
  147. public function __construct()
  148. {
  149. parent::__construct(array(self::ST_COMMON_QUERY_ELEMENT,
  150. self::ST_CLOSEDINT_RQ_START,
  151. self::ST_CLOSEDINT_RQ_FIRST_TERM,
  152. self::ST_CLOSEDINT_RQ_TO_TERM,
  153. self::ST_CLOSEDINT_RQ_LAST_TERM,
  154. self::ST_CLOSEDINT_RQ_END,
  155. self::ST_OPENEDINT_RQ_START,
  156. self::ST_OPENEDINT_RQ_FIRST_TERM,
  157. self::ST_OPENEDINT_RQ_TO_TERM,
  158. self::ST_OPENEDINT_RQ_LAST_TERM,
  159. self::ST_OPENEDINT_RQ_END
  160. ),
  161. Zend_Search_Lucene_Search_QueryToken::getTypes());
  162. $this->addRules(
  163. array(array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_WORD, self::ST_COMMON_QUERY_ELEMENT),
  164. array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_PHRASE, self::ST_COMMON_QUERY_ELEMENT),
  165. array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_FIELD, self::ST_COMMON_QUERY_ELEMENT),
  166. array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_REQUIRED, self::ST_COMMON_QUERY_ELEMENT),
  167. array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_PROHIBITED, self::ST_COMMON_QUERY_ELEMENT),
  168. array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_FUZZY_PROX_MARK, self::ST_COMMON_QUERY_ELEMENT),
  169. array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_BOOSTING_MARK, self::ST_COMMON_QUERY_ELEMENT),
  170. array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_RANGE_INCL_START, self::ST_CLOSEDINT_RQ_START),
  171. array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_RANGE_EXCL_START, self::ST_OPENEDINT_RQ_START),
  172. array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_SUBQUERY_START, self::ST_COMMON_QUERY_ELEMENT),
  173. array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_SUBQUERY_END, self::ST_COMMON_QUERY_ELEMENT),
  174. array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_AND_LEXEME, self::ST_COMMON_QUERY_ELEMENT),
  175. array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_OR_LEXEME, self::ST_COMMON_QUERY_ELEMENT),
  176. array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_NOT_LEXEME, self::ST_COMMON_QUERY_ELEMENT),
  177. array(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_NUMBER, self::ST_COMMON_QUERY_ELEMENT)
  178. ));
  179. $this->addRules(
  180. array(array(self::ST_CLOSEDINT_RQ_START, Zend_Search_Lucene_Search_QueryToken::TT_WORD, self::ST_CLOSEDINT_RQ_FIRST_TERM),
  181. array(self::ST_CLOSEDINT_RQ_FIRST_TERM, Zend_Search_Lucene_Search_QueryToken::TT_TO_LEXEME, self::ST_CLOSEDINT_RQ_TO_TERM),
  182. array(self::ST_CLOSEDINT_RQ_TO_TERM, Zend_Search_Lucene_Search_QueryToken::TT_WORD, self::ST_CLOSEDINT_RQ_LAST_TERM),
  183. array(self::ST_CLOSEDINT_RQ_LAST_TERM, Zend_Search_Lucene_Search_QueryToken::TT_RANGE_INCL_END, self::ST_COMMON_QUERY_ELEMENT)
  184. ));
  185. $this->addRules(
  186. array(array(self::ST_OPENEDINT_RQ_START, Zend_Search_Lucene_Search_QueryToken::TT_WORD, self::ST_OPENEDINT_RQ_FIRST_TERM),
  187. array(self::ST_OPENEDINT_RQ_FIRST_TERM, Zend_Search_Lucene_Search_QueryToken::TT_TO_LEXEME, self::ST_OPENEDINT_RQ_TO_TERM),
  188. array(self::ST_OPENEDINT_RQ_TO_TERM, Zend_Search_Lucene_Search_QueryToken::TT_WORD, self::ST_OPENEDINT_RQ_LAST_TERM),
  189. array(self::ST_OPENEDINT_RQ_LAST_TERM, Zend_Search_Lucene_Search_QueryToken::TT_RANGE_EXCL_END, self::ST_COMMON_QUERY_ELEMENT)
  190. ));
  191. $addTermEntryAction = new Zend_Search_Lucene_FSMAction($this, 'addTermEntry');
  192. $addPhraseEntryAction = new Zend_Search_Lucene_FSMAction($this, 'addPhraseEntry');
  193. $setFieldAction = new Zend_Search_Lucene_FSMAction($this, 'setField');
  194. $setSignAction = new Zend_Search_Lucene_FSMAction($this, 'setSign');
  195. $setFuzzyProxAction = new Zend_Search_Lucene_FSMAction($this, 'processFuzzyProximityModifier');
  196. $processModifierParameterAction = new Zend_Search_Lucene_FSMAction($this, 'processModifierParameter');
  197. $subqueryStartAction = new Zend_Search_Lucene_FSMAction($this, 'subqueryStart');
  198. $subqueryEndAction = new Zend_Search_Lucene_FSMAction($this, 'subqueryEnd');
  199. $logicalOperatorAction = new Zend_Search_Lucene_FSMAction($this, 'logicalOperator');
  200. $openedRQFirstTermAction = new Zend_Search_Lucene_FSMAction($this, 'openedRQFirstTerm');
  201. $openedRQLastTermAction = new Zend_Search_Lucene_FSMAction($this, 'openedRQLastTerm');
  202. $closedRQFirstTermAction = new Zend_Search_Lucene_FSMAction($this, 'closedRQFirstTerm');
  203. $closedRQLastTermAction = new Zend_Search_Lucene_FSMAction($this, 'closedRQLastTerm');
  204. $this->addInputAction(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_WORD, $addTermEntryAction);
  205. $this->addInputAction(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_PHRASE, $addPhraseEntryAction);
  206. $this->addInputAction(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_FIELD, $setFieldAction);
  207. $this->addInputAction(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_REQUIRED, $setSignAction);
  208. $this->addInputAction(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_PROHIBITED, $setSignAction);
  209. $this->addInputAction(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_FUZZY_PROX_MARK, $setFuzzyProxAction);
  210. $this->addInputAction(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_NUMBER, $processModifierParameterAction);
  211. $this->addInputAction(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_SUBQUERY_START, $subqueryStartAction);
  212. $this->addInputAction(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_SUBQUERY_END, $subqueryEndAction);
  213. $this->addInputAction(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_AND_LEXEME, $logicalOperatorAction);
  214. $this->addInputAction(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_OR_LEXEME, $logicalOperatorAction);
  215. $this->addInputAction(self::ST_COMMON_QUERY_ELEMENT, Zend_Search_Lucene_Search_QueryToken::TT_NOT_LEXEME, $logicalOperatorAction);
  216. $this->addEntryAction(self::ST_OPENEDINT_RQ_FIRST_TERM, $openedRQFirstTermAction);
  217. $this->addEntryAction(self::ST_OPENEDINT_RQ_LAST_TERM, $openedRQLastTermAction);
  218. $this->addEntryAction(self::ST_CLOSEDINT_RQ_FIRST_TERM, $closedRQFirstTermAction);
  219. $this->addEntryAction(self::ST_CLOSEDINT_RQ_LAST_TERM, $closedRQLastTermAction);
  220. require_once 'Zend/Search/Lucene/Search/QueryLexer.php';
  221. $this->_lexer = new Zend_Search_Lucene_Search_QueryLexer();
  222. }
  223. /**
  224. * Get query parser instance
  225. *
  226. * @return Zend_Search_Lucene_Search_QueryParser
  227. */
  228. private static function _getInstance()
  229. {
  230. if (self::$_instance === null) {
  231. self::$_instance = new self();
  232. }
  233. return self::$_instance;
  234. }
  235. /**
  236. * Set query string default encoding
  237. *
  238. * @param string $encoding
  239. */
  240. public static function setDefaultEncoding($encoding)
  241. {
  242. self::_getInstance()->_defaultEncoding = $encoding;
  243. }
  244. /**
  245. * Get query string default encoding
  246. *
  247. * @return string
  248. */
  249. public static function getDefaultEncoding()
  250. {
  251. return self::_getInstance()->_defaultEncoding;
  252. }
  253. /**
  254. * Set default boolean operator
  255. *
  256. * @param integer $operator
  257. */
  258. public static function setDefaultOperator($operator)
  259. {
  260. self::_getInstance()->_defaultOperator = $operator;
  261. }
  262. /**
  263. * Get default boolean operator
  264. *
  265. * @return integer
  266. */
  267. public static function getDefaultOperator()
  268. {
  269. return self::_getInstance()->_defaultOperator;
  270. }
  271. /**
  272. * Turn on 'suppress query parser exceptions' mode.
  273. */
  274. public static function suppressQueryParsingExceptions()
  275. {
  276. self::_getInstance()->_suppressQueryParsingExceptions = true;
  277. }
  278. /**
  279. * Turn off 'suppress query parser exceptions' mode.
  280. */
  281. public static function dontSuppressQueryParsingExceptions()
  282. {
  283. self::_getInstance()->_suppressQueryParsingExceptions = false;
  284. }
  285. /**
  286. * Check 'suppress query parser exceptions' mode.
  287. * @return boolean
  288. */
  289. public static function queryParsingExceptionsSuppressed()
  290. {
  291. return self::_getInstance()->_suppressQueryParsingExceptions;
  292. }
  293. /**
  294. * Escape keyword to force it to be parsed as one term
  295. *
  296. * @param string $keyword
  297. * @return string
  298. */
  299. public static function escape($keyword)
  300. {
  301. return '\\' . implode('\\', str_split($keyword));
  302. }
  303. /**
  304. * Parses a query string
  305. *
  306. * @param string $strQuery
  307. * @param string $encoding
  308. * @return Zend_Search_Lucene_Search_Query
  309. * @throws Zend_Search_Lucene_Search_QueryParserException
  310. */
  311. public static function parse($strQuery, $encoding = null)
  312. {
  313. self::_getInstance();
  314. // Reset FSM if previous parse operation didn't return it into a correct state
  315. self::$_instance->reset();
  316. require_once 'Zend/Search/Lucene/Search/QueryParserException.php';
  317. try {
  318. require_once 'Zend/Search/Lucene/Search/QueryParserContext.php';
  319. self::$_instance->_encoding = ($encoding !== null) ? $encoding : self::$_instance->_defaultEncoding;
  320. self::$_instance->_lastToken = null;
  321. self::$_instance->_context = new Zend_Search_Lucene_Search_QueryParserContext(self::$_instance->_encoding);
  322. self::$_instance->_contextStack = array();
  323. self::$_instance->_tokens = self::$_instance->_lexer->tokenize($strQuery, self::$_instance->_encoding);
  324. // Empty query
  325. if (count(self::$_instance->_tokens) == 0) {
  326. require_once 'Zend/Search/Lucene/Search/Query/Insignificant.php';
  327. return new Zend_Search_Lucene_Search_Query_Insignificant();
  328. }
  329. foreach (self::$_instance->_tokens as $token) {
  330. try {
  331. self::$_instance->_currentToken = $token;
  332. self::$_instance->process($token->type);
  333. self::$_instance->_lastToken = $token;
  334. } catch (Exception $e) {
  335. if (strpos($e->getMessage(), 'There is no any rule for') !== false) {
  336. throw new Zend_Search_Lucene_Search_QueryParserException( 'Syntax error at char position ' . $token->position . '.', 0, $e);
  337. }
  338. require_once 'Zend/Search/Lucene/Exception.php';
  339. throw new Zend_Search_Lucene_Exception($e->getMessage(), $e->getCode(), $e);
  340. }
  341. }
  342. if (count(self::$_instance->_contextStack) != 0) {
  343. throw new Zend_Search_Lucene_Search_QueryParserException('Syntax Error: mismatched parentheses, every opening must have closing.' );
  344. }
  345. return self::$_instance->_context->getQuery();
  346. } catch (Zend_Search_Lucene_Search_QueryParserException $e) {
  347. if (self::$_instance->_suppressQueryParsingExceptions) {
  348. $queryTokens = Zend_Search_Lucene_Analysis_Analyzer::getDefault()->tokenize($strQuery, self::$_instance->_encoding);
  349. require_once 'Zend/Search/Lucene/Search/Query/MultiTerm.php';
  350. $query = new Zend_Search_Lucene_Search_Query_MultiTerm();
  351. $termsSign = (self::$_instance->_defaultOperator == self::B_AND) ? true /* required term */ :
  352. null /* optional term */;
  353. require_once 'Zend/Search/Lucene/Index/Term.php';
  354. foreach ($queryTokens as $token) {
  355. $query->addTerm(new Zend_Search_Lucene_Index_Term($token->getTermText()), $termsSign);
  356. }
  357. return $query;
  358. } else {
  359. require_once 'Zend/Search/Lucene/Exception.php';
  360. throw new Zend_Search_Lucene_Exception($e->getMessage(), $e->getCode(), $e);
  361. }
  362. }
  363. }
  364. /*********************************************************************
  365. * Actions implementation
  366. *
  367. * Actions affect on recognized lexemes list
  368. *********************************************************************/
  369. /**
  370. * Add term to a query
  371. */
  372. public function addTermEntry()
  373. {
  374. require_once 'Zend/Search/Lucene/Search/QueryEntry/Term.php';
  375. $entry = new Zend_Search_Lucene_Search_QueryEntry_Term($this->_currentToken->text, $this->_context->getField());
  376. $this->_context->addEntry($entry);
  377. }
  378. /**
  379. * Add phrase to a query
  380. */
  381. public function addPhraseEntry()
  382. {
  383. require_once 'Zend/Search/Lucene/Search/QueryEntry/Phrase.php';
  384. $entry = new Zend_Search_Lucene_Search_QueryEntry_Phrase($this->_currentToken->text, $this->_context->getField());
  385. $this->_context->addEntry($entry);
  386. }
  387. /**
  388. * Set entry field
  389. */
  390. public function setField()
  391. {
  392. $this->_context->setNextEntryField($this->_currentToken->text);
  393. }
  394. /**
  395. * Set entry sign
  396. */
  397. public function setSign()
  398. {
  399. $this->_context->setNextEntrySign($this->_currentToken->type);
  400. }
  401. /**
  402. * Process fuzzy search/proximity modifier - '~'
  403. */
  404. public function processFuzzyProximityModifier()
  405. {
  406. $this->_context->processFuzzyProximityModifier();
  407. }
  408. /**
  409. * Process modifier parameter
  410. *
  411. * @throws Zend_Search_Lucene_Exception
  412. */
  413. public function processModifierParameter()
  414. {
  415. if ($this->_lastToken === null) {
  416. require_once 'Zend/Search/Lucene/Search/QueryParserException.php';
  417. throw new Zend_Search_Lucene_Search_QueryParserException('Lexeme modifier parameter must follow lexeme modifier. Char position 0.' );
  418. }
  419. switch ($this->_lastToken->type) {
  420. case Zend_Search_Lucene_Search_QueryToken::TT_FUZZY_PROX_MARK:
  421. $this->_context->processFuzzyProximityModifier($this->_currentToken->text);
  422. break;
  423. case Zend_Search_Lucene_Search_QueryToken::TT_BOOSTING_MARK:
  424. $this->_context->boost($this->_currentToken->text);
  425. break;
  426. default:
  427. // It's not a user input exception
  428. require_once 'Zend/Search/Lucene/Exception.php';
  429. throw new Zend_Search_Lucene_Exception('Lexeme modifier parameter must follow lexeme modifier. Char position 0.' );
  430. }
  431. }
  432. /**
  433. * Start subquery
  434. */
  435. public function subqueryStart()
  436. {
  437. require_once 'Zend/Search/Lucene/Search/QueryParserContext.php';
  438. $this->_contextStack[] = $this->_context;
  439. $this->_context = new Zend_Search_Lucene_Search_QueryParserContext($this->_encoding, $this->_context->getField());
  440. }
  441. /**
  442. * End subquery
  443. */
  444. public function subqueryEnd()
  445. {
  446. if (count($this->_contextStack) == 0) {
  447. require_once 'Zend/Search/Lucene/Search/QueryParserException.php';
  448. throw new Zend_Search_Lucene_Search_QueryParserException('Syntax Error: mismatched parentheses, every opening must have closing. Char position ' . $this->_currentToken->position . '.' );
  449. }
  450. $query = $this->_context->getQuery();
  451. $this->_context = array_pop($this->_contextStack);
  452. require_once 'Zend/Search/Lucene/Search/QueryEntry/Subquery.php';
  453. $this->_context->addEntry(new Zend_Search_Lucene_Search_QueryEntry_Subquery($query));
  454. }
  455. /**
  456. * Process logical operator
  457. */
  458. public function logicalOperator()
  459. {
  460. $this->_context->addLogicalOperator($this->_currentToken->type);
  461. }
  462. /**
  463. * Process first range query term (opened interval)
  464. */
  465. public function openedRQFirstTerm()
  466. {
  467. $this->_rqFirstTerm = $this->_currentToken->text;
  468. }
  469. /**
  470. * Process last range query term (opened interval)
  471. *
  472. * @throws Zend_Search_Lucene_Search_QueryParserException
  473. */
  474. public function openedRQLastTerm()
  475. {
  476. $tokens = Zend_Search_Lucene_Analysis_Analyzer::getDefault()->tokenize($this->_rqFirstTerm, $this->_encoding);
  477. if (count($tokens) > 1) {
  478. require_once 'Zend/Search/Lucene/Search/QueryParserException.php';
  479. throw new Zend_Search_Lucene_Search_QueryParserException('Range query boundary terms must be non-multiple word terms');
  480. } else if (count($tokens) == 1) {
  481. require_once 'Zend/Search/Lucene/Index/Term.php';
  482. $from = new Zend_Search_Lucene_Index_Term(reset($tokens)->getTermText(), $this->_context->getField());
  483. } else {
  484. $from = null;
  485. }
  486. $tokens = Zend_Search_Lucene_Analysis_Analyzer::getDefault()->tokenize($this->_currentToken->text, $this->_encoding);
  487. if (count($tokens) > 1) {
  488. require_once 'Zend/Search/Lucene/Search/QueryParserException.php';
  489. throw new Zend_Search_Lucene_Search_QueryParserException('Range query boundary terms must be non-multiple word terms');
  490. } else if (count($tokens) == 1) {
  491. require_once 'Zend/Search/Lucene/Index/Term.php';
  492. $to = new Zend_Search_Lucene_Index_Term(reset($tokens)->getTermText(), $this->_context->getField());
  493. } else {
  494. $to = null;
  495. }
  496. if ($from === null && $to === null) {
  497. require_once 'Zend/Search/Lucene/Search/QueryParserException.php';
  498. throw new Zend_Search_Lucene_Search_QueryParserException('At least one range query boundary term must be non-empty term');
  499. }
  500. require_once 'Zend/Search/Lucene/Search/Query/Range.php';
  501. $rangeQuery = new Zend_Search_Lucene_Search_Query_Range($from, $to, false);
  502. require_once 'Zend/Search/Lucene/Search/QueryEntry/Subquery.php';
  503. $entry = new Zend_Search_Lucene_Search_QueryEntry_Subquery($rangeQuery);
  504. $this->_context->addEntry($entry);
  505. }
  506. /**
  507. * Process first range query term (closed interval)
  508. */
  509. public function closedRQFirstTerm()
  510. {
  511. $this->_rqFirstTerm = $this->_currentToken->text;
  512. }
  513. /**
  514. * Process last range query term (closed interval)
  515. *
  516. * @throws Zend_Search_Lucene_Search_QueryParserException
  517. */
  518. public function closedRQLastTerm()
  519. {
  520. $tokens = Zend_Search_Lucene_Analysis_Analyzer::getDefault()->tokenize($this->_rqFirstTerm, $this->_encoding);
  521. if (count($tokens) > 1) {
  522. require_once 'Zend/Search/Lucene/Search/QueryParserException.php';
  523. throw new Zend_Search_Lucene_Search_QueryParserException('Range query boundary terms must be non-multiple word terms');
  524. } else if (count($tokens) == 1) {
  525. require_once 'Zend/Search/Lucene/Index/Term.php';
  526. $from = new Zend_Search_Lucene_Index_Term(reset($tokens)->getTermText(), $this->_context->getField());
  527. } else {
  528. $from = null;
  529. }
  530. $tokens = Zend_Search_Lucene_Analysis_Analyzer::getDefault()->tokenize($this->_currentToken->text, $this->_encoding);
  531. if (count($tokens) > 1) {
  532. require_once 'Zend/Search/Lucene/Search/QueryParserException.php';
  533. throw new Zend_Search_Lucene_Search_QueryParserException('Range query boundary terms must be non-multiple word terms');
  534. } else if (count($tokens) == 1) {
  535. require_once 'Zend/Search/Lucene/Index/Term.php';
  536. $to = new Zend_Search_Lucene_Index_Term(reset($tokens)->getTermText(), $this->_context->getField());
  537. } else {
  538. $to = null;
  539. }
  540. if ($from === null && $to === null) {
  541. require_once 'Zend/Search/Lucene/Search/QueryParserException.php';
  542. throw new Zend_Search_Lucene_Search_QueryParserException('At least one range query boundary term must be non-empty term');
  543. }
  544. require_once 'Zend/Search/Lucene/Search/Query/Range.php';
  545. $rangeQuery = new Zend_Search_Lucene_Search_Query_Range($from, $to, true);
  546. require_once 'Zend/Search/Lucene/Search/QueryEntry/Subquery.php';
  547. $entry = new Zend_Search_Lucene_Search_QueryEntry_Subquery($rangeQuery);
  548. $this->_context->addEntry($entry);
  549. }
  550. }