sphinx全文检索(整合ci框架)

2018-05-28 后端


加入sphinx类库（/application/libraries/sphinx_client.php）
  1. php
  3. //
  4. // $Id: sphinxapi.php 2055 2009-11-06 23:09:58Z shodan $
  5. //
  7. //
  8. // Copyright (c) 2001-2008, Andrew Aksyonoff. All rights reserved.
  9. //
  10. // This program is free software; you can redistribute it and/or modify
  11. // it under the terms of the GNU General Public License. You should have
  12. // received a copy of the GPL license along with this program; if you
  13. // did not, you can find it at http://www.gnu.org/
  14. //
  16. /////////////////////////////////////////////////////////////////////////////
  17. // PHP version of Sphinx searchd client (PHP API)
  18. /////////////////////////////////////////////////////////////////////////////
  20. /// known searchd commands
  21. define ("SEARCHD_COMMAND_SEARCH",0);
  22. define ("SEARCHD_COMMAND_EXCERPT",1);
  23. define ("SEARCHD_COMMAND_UPDATE",2);
  24. define ("SEARCHD_COMMAND_KEYWORDS",3);
  25. define ("SEARCHD_COMMAND_PERSIST",4);
  26. define ("SEARCHD_COMMAND_STATUS",5);
  27. define ("SEARCHD_COMMAND_QUERY",6);
  29. /// current client-side command implementation versions
  30. define ("VER_COMMAND_SEARCH",0x116);
  31. define ("VER_COMMAND_EXCERPT",0x100);
  32. define ("VER_COMMAND_UPDATE",0x102);
  33. define ("VER_COMMAND_KEYWORDS",0x100);
  34. define ("VER_COMMAND_STATUS",0x100);
  35. define ("VER_COMMAND_QUERY",0x100);
  37. /// known searchd status codes
  38. define ("SEARCHD_OK",0);
  39. define ("SEARCHD_ERROR",1);
  40. define ("SEARCHD_RETRY",2);
  41. define ("SEARCHD_WARNING",3);
  43. /// known match modes
  44. define ("SPH_MATCH_ALL",0);
  45. define ("SPH_MATCH_ANY",1);
  46. define ("SPH_MATCH_PHRASE",2);
  47. define ("SPH_MATCH_BOOLEAN",3);
  48. define ("SPH_MATCH_EXTENDED",4);
  49. define ("SPH_MATCH_FULLSCAN",5);
  50. define ("SPH_MATCH_EXTENDED2",6);// extended engine V2 (TEMPORARY, WILL BE REMOVED)
  52. /// known ranking modes (ext2 only)
  53. define ("SPH_RANK_PROXIMITY_BM25",0);///< default mode, phrase proximity major factor and BM25 minor one
  54. define ("SPH_RANK_BM25",1);///< statistical mode, BM25 ranking only (faster but worse quality)
  55. define ("SPH_RANK_NONE",2);///< no ranking, all matches get a weight of 1
  56. define ("SPH_RANK_WORDCOUNT",3);///< simple word-count weighting, rank is a weighted sum of per-field keyword occurence counts
  57. define ("SPH_RANK_PROXIMITY",4);
  58. define ("SPH_RANK_MATCHANY",5);
  59. define ("SPH_RANK_FIELDMASK",6);
  61. /// known sort modes
  62. define ("SPH_SORT_RELEVANCE",0);
  63. define ("SPH_SORT_ATTR_DESC",1);
  64. define ("SPH_SORT_ATTR_ASC",2);
  65. define ("SPH_SORT_TIME_SEGMENTS",3);
  66. define ("SPH_SORT_EXTENDED",4);
  67. define ("SPH_SORT_EXPR",5);
  69. /// known filter types
  70. define ("SPH_FILTER_VALUES",0);
  71. define ("SPH_FILTER_RANGE",1);
  72. define ("SPH_FILTER_FLOATRANGE",2);
  74. /// known attribute types
  75. define ("SPH_ATTR_INTEGER",1);
  76. define ("SPH_ATTR_TIMESTAMP",2);
  77. define ("SPH_ATTR_ORDINAL",3);
  78. define ("SPH_ATTR_BOOL",4);
  79. define ("SPH_ATTR_FLOAT",5);
  80. define ("SPH_ATTR_BIGINT",6);
  81. define ("SPH_ATTR_MULTI",0x40000000);
  83. /// known grouping functions
  84. define ("SPH_GROUPBY_DAY",0);
  85. define ("SPH_GROUPBY_WEEK",1);
  86. define ("SPH_GROUPBY_MONTH",2);
  87. define ("SPH_GROUPBY_YEAR",3);
  88. define ("SPH_GROUPBY_ATTR",4);
  89. define ("SPH_GROUPBY_ATTRPAIR",5);
  91. // important properties of PHP's integers:
  92. //  - always signed (one bit short of PHP_INT_SIZE)
  93. //  - conversion from string to int is saturated
  94. //  - float is double
  95. //  - div converts arguments to floats
  96. //  - mod converts arguments to ints
  98. // the packing code below works as follows:
  99. //  - when we got an int, just pack it
  100. //    if performance is a problem, this is the branch users should aim for
  101. //
  102. //  - otherwise, we got a number in string form
  103. //    this might be due to different reasons, but we assume that this is
  104. //    because it didn't fit into PHP int
  105. //
  106. //  - factor the string into high and low ints for packing
  107. //    - if we have bcmath, then it is used
  108. //    - if we don't, we have to do it manually (this is the fun part)
  109. //
  110. //    - x64 branch does factoring using ints
  111. //    - x32 (ab)uses floats, since we can't fit unsigned 32-bit number into an int
  112. //
  113. // unpacking routines are pretty much the same.
  114. //  - return ints if we can
  115. //  - otherwise format number into a string
  117. /// pack 64-bit signed
  118. function sphPackI64 ( $v )
  119. {
  120. assert( is_numeric($v));
  122. // x64
  123. if( PHP_INT_SIZE>=8)
  124. {
  125. 		$v =(int)$v;
  126. return pack ("NN", $v>>32, $v&0xFFFFFFFF);
  127. }
  129. // x32, int
  130. if( is_int($v))
  131. return pack ("NN", $v <0?-1:0, $v );
  133. // x32, bcmath	
  134. if( function_exists("bcmul"))
  135. {
  136. if( bccomp ( $v,0)==-1)
  137. 			$v = bcadd ("18446744073709551616", $v );
  138. 		$h = bcdiv ( $v,"4294967296",0);
  139. 		$l = bcmod ( $v,"4294967296");
  140. return pack ("NN",(float)$h,(float)$l );// conversion to float is intentional; int would lose 31st bit
  141. }
  143. // x32, no-bcmath
  144. 	$p = max(0, strlen($v)-13);
  145. 	$lo = abs((float)substr($v, $p));
  146. 	$hi = abs((float)substr($v,0, $p));
  148. 	$m = $lo + $hi*1316134912.0;// (10 ^ 13) % (1 << 32) = 1316134912
  149. 	$q = floor($m/4294967296.0);
  150. 	$l = $m -($q*4294967296.0);
  151. 	$h = $hi*2328.0+ $q;// (10 ^ 13) / (1 << 32) = 2328
  153. if( $v<0)
  154. {
  155. if( $l==0)
  156. 			$h =4294967296.0- $h;
  157. else
  158. {
  159. 			$h =4294967295.0- $h;
  160. 			$l =4294967296.0- $l;
  161. }
  162. }
  163. return pack ("NN", $h, $l );
  164. }
  166. /// pack 64-bit unsigned
  167. function sphPackU64 ( $v )
  168. {
  169. assert( is_numeric($v));
  171. // x64
  172. if( PHP_INT_SIZE>=8)
  173. {
  174. assert( $v>=0);
  176. // x64, int
  177. if( is_int($v))
  178. return pack ("NN", $v>>32, $v&0xFFFFFFFF);
  180. // x64, bcmath
  181. if( function_exists("bcmul"))
  182. {
  183. 			$h = bcdiv ( $v,4294967296,0);
  184. 			$l = bcmod ( $v,4294967296);
  185. return pack ("NN", $h, $l );
  186. }
  188. // x64, no-bcmath
  189. 		$p = max (0, strlen($v)-13);
  190. 		$lo =(int)substr ( $v, $p );
  191. 		$hi =(int)substr ( $v,0, $p );
  193. 		$m = $lo + $hi*1316134912;
  194. 		$l = $m %4294967296;
  195. 		$h = $hi*2328+(int)($m/4294967296);
  197. return pack ("NN", $h, $l );
  198. }
  200. // x32, int
  201. if( is_int($v))
  202. return pack ("NN",0, $v );
  204. // x32, bcmath
  205. if( function_exists("bcmul"))
  206. {
  207. 		$h = bcdiv ( $v,"4294967296",0);
  208. 		$l = bcmod ( $v,"4294967296");
  209. return pack ("NN",(float)$h,(float)$l );// conversion to float is intentional; int would lose 31st bit
  210. }
  212. // x32, no-bcmath
  213. 	$p = max(0, strlen($v)-13);
  214. 	$lo =(float)substr($v, $p);
  215. 	$hi =(float)substr($v,0, $p);
  217. 	$m = $lo + $hi*1316134912.0;
  218. 	$q = floor($m /4294967296.0);
  219. 	$l = $m -($q *4294967296.0);
  220. 	$h = $hi*2328.0+ $q;
  222. return pack ("NN", $h, $l );
  223. }
  225. // unpack 64-bit unsigned
  226. function sphUnpackU64 ( $v )
  227. {
  228. 	list ( $hi, $lo )= array_values ( unpack ("N*N*", $v ));
  230. if( PHP_INT_SIZE>=8)
  231. {
  232. if( $hi<0) $hi +=(1<<32);// because php 5.2.2 to 5.2.5 is totally fucked up again
  233. if( $lo<0) $lo +=(1<<32);
  235. // x64, int
  236. if( $hi<=2147483647)
  237. return($hi<<32)+ $lo;
  239. // x64, bcmath
  240. if( function_exists("bcmul"))
  241. return bcadd ( $lo, bcmul ( $hi,"4294967296"));
  243. // x64, no-bcmath
  244. 		$C =100000;
  245. 		$h =((int)($hi / $C)<<32)+(int)($lo / $C);
  246. 		$l =(($hi % $C)<<32)+($lo % $C);
  247. if( $l>$C )
  248. {
  249. 			$h +=(int)($l / $C);
  250. 			$l  = $l % $C;
  251. }
  253. if( $h==0)
  254. return $l;
  255. return sprintf ("%d%05d", $h, $l );
  256. }
  258. // x32, int
  259. if( $hi==0)
  260. {
  261. if( $lo>0)
  262. return $lo;
  263. return sprintf ("%u", $lo );
  264. }
  266. 	$hi = sprintf ("%u", $hi );
  267. 	$lo = sprintf ("%u", $lo );
  269. // x32, bcmath
  270. if( function_exists("bcmul"))
  271. return bcadd ( $lo, bcmul ( $hi,"4294967296"));
  273. // x32, no-bcmath
  274. 	$hi =(float)$hi;
  275. 	$lo =(float)$lo;
  277. 	$q = floor($hi/10000000.0);
  278. 	$r = $hi - $q*10000000.0;
  279. 	$m = $lo + $r*4967296.0;
  280. 	$mq = floor($m/10000000.0);
  281. 	$l = $m - $mq*10000000.0;
  282. 	$h = $q*4294967296.0+ $r*429.0+ $mq;
  284. 	$h = sprintf ("%.0f", $h );
  285. 	$l = sprintf ("%07.0f", $l );
  286. if( $h=="0")
  287. return sprintf("%.0f",(float)$l );
  288. return $h . $l;
  289. }
  291. // unpack 64-bit signed
  292. function sphUnpackI64 ( $v )
  293. {
  294. 	list ( $hi, $lo )= array_values ( unpack ("N*N*", $v ));
  296. // x64
  297. if( PHP_INT_SIZE>=8)
  298. {
  299. if( $hi<0) $hi +=(1<<32);// because php 5.2.2 to 5.2.5 is totally fucked up again
  300. if( $lo<0) $lo +=(1<<32);
  302. return($hi<<32)+ $lo;
  303. }
  305. // x32, int
  306. if( $hi==0)
  307. {
  308. if( $lo>0)
  309. return $lo;
  310. return sprintf ("%u", $lo );
  311. }
  312. // x32, int
  313. 	elseif ( $hi==-1)
  314. {
  315. if( $lo<0)
  316. return $lo;
  317. return sprintf ("%.0f", $lo -4294967296.0);
  318. }
  320. 	$neg ="";
  321. 	$c =0;
  322. if( $hi<0)
  323. {
  324. 		$hi =~$hi;
  325. 		$lo =~$lo;
  326. 		$c =1;
  327. 		$neg ="-";
  328. }
  330. 	$hi = sprintf ("%u", $hi );
  331. 	$lo = sprintf ("%u", $lo );
  333. // x32, bcmath
  334. if( function_exists("bcmul"))
  335. return $neg . bcadd ( bcadd ( $lo, bcmul ( $hi,"4294967296")), $c );
  337. // x32, no-bcmath
  338. 	$hi =(float)$hi;
  339. 	$lo =(float)$lo;
  341. 	$q = floor($hi/10000000.0);
  342. 	$r = $hi - $q*10000000.0;
  343. 	$m = $lo + $r*4967296.0;
  344. 	$mq = floor($m/10000000.0);
  345. 	$l = $m - $mq*10000000.0+ $c;
  346. 	$h = $q*4294967296.0+ $r*429.0+ $mq;
  347. if( $l==10000000)
  348. {
  349. 		$l =0;
  350. 		$h +=1;
  351. }
  353. 	$h = sprintf ("%.0f", $h );
  354. 	$l = sprintf ("%07.0f", $l );
  355. if( $h=="0")
  356. return $neg . sprintf("%.0f",(float)$l );
  357. return $neg . $h . $l;
  358. }
  361. function sphFixUint ( $value )
  362. {
  363. if( PHP_INT_SIZE>=8)
  364. {
  365. // x64 route, workaround broken unpack() in 5.2.2+
  366. if( $value<0) $value +=(1<<32);
  367. return $value;
  368. }
  369. else
  370. {
  371. // x32 route, workaround php signed/unsigned braindamage
  372. return sprintf ("%u", $value );
  373. }
  374. }
  377. /// sphinx searchd client class
  378. classSphinx_client
  379. {
  380. var $_host;///< searchd host (default is "localhost")
  381. var $_port;///< searchd port (default is 9312)
  382. var $_offset;///< how many records to seek from result-set start (default is 0)
  383. var $_limit;///< how many records to return from result-set starting at offset (default is 20)
  384. var $_mode;///< query matching mode (default is SPH_MATCH_ALL)
  385. var $_weights;///< per-field weights (default is 1 for all fields)
  386. var $_sort;///< match sorting mode (default is SPH_SORT_RELEVANCE)
  387. var $_sortby;///< attribute to sort by (defualt is "")
  388. var $_min_id;///< min ID to match (default is 0, which means no limit)
  389. var $_max_id;///< max ID to match (default is 0, which means no limit)
  390. var $_filters;///< search filters
  391. var $_groupby;///< group-by attribute name
  392. var $_groupfunc;///< group-by function (to pre-process group-by attribute value with)
  393. var $_groupsort;///< group-by sorting clause (to sort groups in result set with)
  394. var $_groupdistinct;///< group-by count-distinct attribute
  395. var $_maxmatches;///< max matches to retrieve
  396. var $_cutoff;///< cutoff to stop searching at (default is 0)
  397. var $_retrycount;///< distributed retries count
  398. var $_retrydelay;///< distributed retries delay
  399. var $_anchor;///< geographical anchor point
  400. var $_indexweights;///< per-index weights
  401. var $_ranker;///< ranking mode (default is SPH_RANK_PROXIMITY_BM25)
  402. var $_maxquerytime;///< max query time, milliseconds (default is 0, do not limit)
  403. var $_fieldweights;///< per-field-name weights
  404. var $_overrides;///< per-query attribute values overrides
  405. var $_select;///< select-list (attributes or expressions, with optional aliases)
  407. var $_error;///< last error message
  408. var $_warning;///< last warning message
  409. var $_connerror;///< connection error vs remote error flag
  411. var $_reqs;///< requests array for multi-query
  412. var $_mbenc;///< stored mbstring encoding
  413. var $_arrayresult;///< whether $result["matches"] should be a hash or an array
  414. var $_timeout;///< connect timeout
  416. /////////////////////////////////////////////////////////////////////////////
  417. // common stuff
  418. /////////////////////////////////////////////////////////////////////////////
  420. /// create a new client object and fill defaults
  421. function __construct ()
  422. {
  423. // per-client-object settings
  424. 		$this->_host		="localhost";
  425. 		$this->_port		=9312;
  426. 		$this->_path		=false;
  427. 		$this->_socket		=false;
  429. // per-query settings
  430. 		$this->_offset		=0;
  431. 		$this->_limit		=20;
  432. 		$this->_mode		= SPH_MATCH_ALL;
  433. 		$this->_weights		= array ();
  434. 		$this->_sort		= SPH_SORT_RELEVANCE;
  435. 		$this->_sortby		="";
  436. 		$this->_min_id		=0;
  437. 		$this->_max_id		=0;
  438. 		$this->_filters		= array ();
  439. 		$this->_groupby		="";
  440. 		$this->_groupfunc	= SPH_GROUPBY_DAY;
  441. 		$this->_groupsort	="@group desc";
  442. 		$this->_groupdistinct="";
  443. 		$this->_maxmatches	=1000;
  444. 		$this->_cutoff		=0;
  445. 		$this->_retrycount	=0;
  446. 		$this->_retrydelay	=0;
  447. 		$this->_anchor		= array ();
  448. 		$this->_indexweights= array ();
  449. 		$this->_ranker		= SPH_RANK_PROXIMITY_BM25;
  450. 		$this->_maxquerytime=0;
  451. 		$this->_fieldweights= array();
  452. 		$this->_overrides 	= array();
  453. 		$this->_select		="*";
  455. 		$this->_error		="";// per-reply fields (for single-query case)
  456. 		$this->_warning		="";
  457. 		$this->_connerror	=false;
  459. 		$this->_reqs		= array ();// requests storage (for multi-query case)
  460. 		$this->_mbenc		="";
  461. 		$this->_arrayresult	=false;
  462. 		$this->_timeout		=0;
  463. }
  465. function __destruct()
  466. {
  467. if( $this->_socket !==false)
  468. 			fclose ( $this->_socket );
  469. }
  471. /// get last error message (string)
  472. functionGetLastError()
  473. {
  474. return $this->_error;
  475. }
  477. /// get last warning message (string)
  478. functionGetLastWarning()
  479. {
  480. return $this->_warning;
  481. }
  483. /// get last error flag (to tell network connection errors from searchd errors or broken responses)
  484. functionIsConnectError()
  485. {
  486. return $this->_connerror;
  487. }
  489. /// set searchd host name (string) and port (integer)
  490. functionSetServer( $host, $port =0)
  491. {
  492. assert( is_string($host));
  493. if( $host[0]=='/')
  494. {
  495. 			$this->_path ='unix://'. $host;
  496. return;
  497. }
  498. if( substr ( $host,0,7)=="unix://")
  499. {
  500. 			$this->_path = $host;
  501. return;
  502. }
  504. assert( is_int($port));
  505. 		$this->_host = $host;
  506. 		$this->_port = $port;
  507. 		$this->_path ='';
  509. }
  511. /// set server connection timeout (0 to remove)
  512. functionSetConnectTimeout( $timeout )
  513. {
  514. assert( is_numeric($timeout));
  515. 		$this->_timeout = $timeout;
  516. }
  519. function_Send( $handle, $data, $length )
  520. {
  521. if( feof($handle)|| fwrite ( $handle, $data, $length )!== $length )
  522. {
  523. 			$this->_error ='connection unexpectedly closed (timed out?)';
  524. 			$this->_connerror =true;
  525. returnfalse;
  526. }
  527. returntrue;
  528. }
  530. /////////////////////////////////////////////////////////////////////////////
  532. /// enter mbstring workaround mode
  533. function_MBPush()
  534. {
  535. 		$this->_mbenc ="";
  536. if( ini_get ("mbstring.func_overload")&2)
  537. {
  538. 			$this->_mbenc = mb_internal_encoding();
  539. 			mb_internal_encoding ("latin1");
  540. }
  541. }
  543. /// leave mbstring workaround mode
  544. function_MBPop()
  545. {
  546. if( $this->_mbenc )
  547. 			mb_internal_encoding ( $this->_mbenc );
  548. }
  550. /// connect to searchd server
  551. function_Connect()
  552. {
  553. if( $this->_socket!==false)
  554. {
  555. // we are in persistent connection mode, so we have a socket
  556. // however, need to check whether it's still alive
  557. if(!@feof( $this->_socket ))
  558. return $this->_socket;
  560. // force reopen
  561. 			$this->_socket =false;
  562. }
  564. 		$errno =0;
  565. 		$errstr ="";
  566. 		$this->_connerror =false;
  568. if( $this->_path )
  569. {
  570. 			$host = $this->_path;
  571. 			$port =0;
  572. }
  573. else
  574. {
  575. 			$host = $this->_host;
  576. 			$port = $this->_port;
  577. }
  579. if( $this->_timeout<=0)
  580. 			$fp =@fsockopen( $host, $port, $errno, $errstr );
  581. else
  582. 			$fp =@fsockopen( $host, $port, $errno, $errstr, $this->_timeout );
  584. if(!$fp )
  585. {
  586. if( $this->_path )
  587. 				$location = $this->_path;
  588. else
  589. 				$location ="{$this->_host}:{$this->_port}";
  591. 			$errstr = trim ( $errstr );
  592. 			$this->_error ="connection to $location failed (errno=$errno, msg=$errstr)";
  593. 			$this->_connerror =true;
  594. returnfalse;
  595. }
  597. // send my version
  598. // this is a subtle part. we must do it before (!) reading back from searchd.
  599. // because otherwise under some conditions (reported on FreeBSD for instance)
  600. // TCP stack could throttle write-write-read pattern because of Nagle.
  601. if(!$this->_Send( $fp, pack ("N",1),4))
  602. {
  603. 			fclose ( $fp );
  604. 			$this->_error ="failed to send client protocol version";
  605. returnfalse;
  606. }
  608. // check version
  609. 		list(,$v)= unpack ("N*", fread ( $fp,4));
  610. 		$v =(int)$v;
  611. if( $v<1)
  612. {
  613. 			fclose ( $fp );
  614. 			$this->_error ="expected searchd protocol version 1+, got version '$v'";
  615. returnfalse;
  616. }
  618. return $fp;
  619. }
  621. /// get and check response packet from searchd server
  622. function_GetResponse( $fp, $client_ver )
  623. {
  624. 		$response ="";
  625. 		$len =0;
  627. 		$header = fread ( $fp,8);
  628. if( strlen($header)==8)
  629. {
  630. 			list ( $status, $ver, $len )= array_values ( unpack ("n2a/Nb", $header ));
  631. 			$left = $len;
  632. while( $left>0&&!feof($fp))
  633. {
  634. 				$chunk = fread ( $fp, $left );
  635. if( $chunk )
  636. {
  637. 					$response .= $chunk;
  638. 					$left -= strlen($chunk);
  639. }
  640. }
  641. }
  642. if( $this->_socket ===false)
  643. 			fclose ( $fp );
  645. // check response
  646. 		$read = strlen ( $response );
  647. if(!$response || $read!=$len )
  648. {
  649. 			$this->_error = $len
  650. ?"failed to read searchd response (status=$status, ver=$ver, len=$len, read=$read)"
  651. :"received zero-sized searchd response";
  652. returnfalse;
  653. }
  655. // check status
  656. if( $status==SEARCHD_WARNING )
  657. {
  658. 			list(,$wlen)= unpack ("N*", substr ( $response,0,4));
  659. 			$this->_warning = substr ( $response,4, $wlen );
  660. return substr ( $response,4+$wlen );
  661. }
  662. if( $status==SEARCHD_ERROR )
  663. {
  664. 			$this->_error ="searchd error: ". substr ( $response,4);
  665. returnfalse;
  666. }
  667. if( $status==SEARCHD_RETRY )
  668. {
  669. 			$this->_error ="temporary searchd error: ". substr ( $response,4);
  670. returnfalse;
  671. }
  672. if( $status!=SEARCHD_OK )
  673. {
  674. 			$this->_error ="unknown status code '$status'";
  675. returnfalse;
  676. }
  678. // check version
  679. if( $ver<$client_ver )
  680. {
  681. 			$this->_warning = sprintf ("searchd command v.%d.%d older than client's v.%d.%d, some options might not work",
  682. 				$ver>>8, $ver&0xff, $client_ver>>8, $client_ver&0xff);
  683. }
  685. return $response;
  686. }
  688. /////////////////////////////////////////////////////////////////////////////
  689. // searching
  690. /////////////////////////////////////////////////////////////////////////////
  692. /// set offset and count into result set,
  693. /// and optionally set max-matches and cutoff limits
  694. functionSetLimits( $offset, $limit, $max=0, $cutoff=0)
  695. {
  696. assert( is_int($offset));
  697. assert( is_int($limit));
  698. assert( $offset>=0);
  699. assert( $limit>0);
  700. assert( $max>=0);
  701. 		$this->_offset = $offset;
  702. 		$this->_limit = $limit;
  703. if( $max>0)
  704. 			$this->_maxmatches = $max;
  705. if( $cutoff>0)
  706. 			$this->_cutoff = $cutoff;
  707. }
  709. /// set maximum query time, in milliseconds, per-index
  710. /// integer, 0 means "do not limit"
  711. functionSetMaxQueryTime( $max )
  712. {
  713. assert( is_int($max));
  714. assert( $max>=0);
  715. 		$this->_maxquerytime = $max;
  716. }
  718. /// set matching mode
  719. functionSetMatchMode( $mode )
  720. {
  721. assert( $mode==SPH_MATCH_ALL
  722. || $mode==SPH_MATCH_ANY
  723. || $mode==SPH_MATCH_PHRASE
  724. || $mode==SPH_MATCH_BOOLEAN
  725. || $mode==SPH_MATCH_EXTENDED
  726. || $mode==SPH_MATCH_FULLSCAN
  727. || $mode==SPH_MATCH_EXTENDED2 );
  728. 		$this->_mode = $mode;
  729. }
  731. /// set ranking mode
  732. functionSetRankingMode( $ranker )
  733. {
  734. assert( $ranker==SPH_RANK_PROXIMITY_BM25
  735. || $ranker==SPH_RANK_BM25
  736. || $ranker==SPH_RANK_NONE
  737. || $ranker==SPH_RANK_WORDCOUNT
  738. || $ranker==SPH_RANK_PROXIMITY );
  739. 		$this->_ranker = $ranker;
  740. }
  742. /// set matches sorting mode
  743. functionSetSortMode( $mode, $sortby="")
  744. {
  745. assert(
  746. 			$mode==SPH_SORT_RELEVANCE ||
  747. 			$mode==SPH_SORT_ATTR_DESC ||
  748. 			$mode==SPH_SORT_ATTR_ASC ||
  749. 			$mode==SPH_SORT_TIME_SEGMENTS ||
  750. 			$mode==SPH_SORT_EXTENDED ||
  751. 			$mode==SPH_SORT_EXPR );
  752. assert( is_string($sortby));
  753. assert( $mode==SPH_SORT_RELEVANCE || strlen($sortby)>0);
  755. 		$this->_sort = $mode;
  756. 		$this->_sortby = $sortby;
  757. }
  759. /// bind per-field weights by order
  760. /// DEPRECATED; use SetFieldWeights() instead
  761. functionSetWeights( $weights )
  762. {
  763. assert( is_array($weights));
  764. foreach( $weights as $weight )
  765. assert( is_int($weight));
  767. 		$this->_weights = $weights;
  768. }
  770. /// bind per-field weights by name
  771. functionSetFieldWeights( $weights )
  772. {
  773. assert( is_array($weights));
  774. foreach( $weights as $name=>$weight )
  775. {
  776. assert( is_string($name));
  777. assert( is_int($weight));
  778. }
  779. 		$this->_fieldweights = $weights;
  780. }
  782. /// bind per-index weights by name
  783. functionSetIndexWeights( $weights )
  784. {
  785. assert( is_array($weights));
  786. foreach( $weights as $index=>$weight )
  787. {
  788. assert( is_string($index));
  789. assert( is_int($weight));
  790. }
  791. 		$this->_indexweights = $weights;
  792. }
  794. /// set IDs range to match
  795. /// only match records if document ID is beetwen $min and $max (inclusive)
  796. functionSetIDRange( $min, $max )
  797. {
  798. assert( is_numeric($min));
  799. assert( is_numeric($max));
  800. assert( $min<=$max );
  801. 		$this->_min_id = $min;
  802. 		$this->_max_id = $max;
  803. }
  805. /// set values set filter
  806. /// only match records where $attribute value is in given set
  807. functionSetFilter( $attribute, $values, $exclude=false)
  808. {
  809. assert( is_string($attribute));
  810. assert( is_array($values));
  811. assert( count($values));
  813. if( is_array($values)&& count($values))
  814. {
  815. foreach( $values as $value )
  816. assert( is_numeric($value));
  818. 			$this->_filters[]= array ("type"=>SPH_FILTER_VALUES,"attr"=>$attribute,"exclude"=>$exclude,"values"=>$values );
  819. }
  820. }
  822. /// set range filter
  823. /// only match records if $attribute value is beetwen $min and $max (inclusive)
  824. functionSetFilterRange( $attribute, $min, $max, $exclude=false)
  825. {
  826. assert( is_string($attribute));
  827. assert( is_numeric($min));
  828. assert( is_numeric($max));
  829. assert( $min<=$max );
  831. 		$this->_filters[]= array ("type"=>SPH_FILTER_RANGE,"attr"=>$attribute,"exclude"=>$exclude,"min"=>$min,"max"=>$max );
  832. }
  834. /// set float range filter
  835. /// only match records if $attribute value is beetwen $min and $max (inclusive)
  836. functionSetFilterFloatRange( $attribute, $min, $max, $exclude=false)
  837. {
  838. assert( is_string($attribute));
  839. assert( is_float($min));
  840. assert( is_float($max));
  841. assert( $min<=$max );
  843. 		$this->_filters[]= array ("type"=>SPH_FILTER_FLOATRANGE,"attr"=>$attribute,"exclude"=>$exclude,"min"=>$min,"max"=>$max );
  844. }
  846. /// setup anchor point for geosphere distance calculations
  847. /// required to use @geodist in filters and sorting
  848. /// latitude and longitude must be in radians
  849. functionSetGeoAnchor( $attrlat, $attrlong, $lat, $long )
  850. {
  851. assert( is_string($attrlat));
  852. assert( is_string($attrlong));
  853. assert( is_float($lat));
  854. assert( is_float($long));
  856. 		$this->_anchor = array ("attrlat"=>$attrlat,"attrlong"=>$attrlong,"lat"=>$lat,"long"=>$long );
  857. }
  859. /// set grouping attribute and function
  860. functionSetGroupBy( $attribute, $func, $groupsort="@group desc")
  861. {
  862. assert( is_string($attribute));
  863. assert( is_string($groupsort));
  864. assert( $func==SPH_GROUPBY_DAY
  865. || $func==SPH_GROUPBY_WEEK
  866. || $func==SPH_GROUPBY_MONTH
  867. || $func==SPH_GROUPBY_YEAR
  868. || $func==SPH_GROUPBY_ATTR
  869. || $func==SPH_GROUPBY_ATTRPAIR );
  871. 		$this->_groupby = $attribute;
  872. 		$this->_groupfunc = $func;
  873. 		$this->_groupsort = $groupsort;
  874. }
  876. /// set count-distinct attribute for group-by queries
  877. functionSetGroupDistinct( $attribute )
  878. {
  879. assert( is_string($attribute));
  880. 		$this->_groupdistinct = $attribute;
  881. }
  883. /// set distributed retries count and delay
  884. functionSetRetries( $count, $delay=0)
  885. {
  886. assert( is_int($count)&& $count>=0);
  887. assert( is_int($delay)&& $delay>=0);
  888. 		$this->_retrycount = $count;
  889. 		$this->_retrydelay = $delay;
  890. }
  892. /// set result set format (hash or array; hash by default)
  893. /// PHP specific; needed for group-by-MVA result sets that may contain duplicate IDs
  894. functionSetArrayResult( $arrayresult )
  895. {
  896. assert( is_bool($arrayresult));
  897. 		$this->_arrayresult = $arrayresult;
  898. }
  900. /// set attribute values override
  901. /// there can be only one override per attribute
  902. /// $values must be a hash that maps document IDs to attribute values
  903. functionSetOverride( $attrname, $attrtype, $values )
  904. {
  905. assert( is_string ( $attrname ));
  906. assert( in_array ( $attrtype, array ( SPH_ATTR_INTEGER, SPH_ATTR_TIMESTAMP, SPH_ATTR_BOOL, SPH_ATTR_FLOAT, SPH_ATTR_BIGINT )));
  907. assert( is_array ( $values ));
  909. 		$this->_overrides[$attrname]= array ("attr"=>$attrname,"type"=>$attrtype,"values"=>$values );
  910. }
  912. /// set select-list (attributes or expressions), SQL-like syntax
  913. functionSetSelect( $select )
  914. {
  915. assert( is_string ( $select ));
  916. 		$this->_select = $select;
  917. }
  919. //////////////////////////////////////////////////////////////////////////////
  921. /// clear all filters (for multi-queries)
  922. functionResetFilters()
  923. {
  924. 		$this->_filters = array();
  925. 		$this->_anchor = array();
  926. }
  928. /// clear groupby settings (for multi-queries)
  929. functionResetGroupBy()
  930. {
  931. 		$this->_groupby		="";
  932. 		$this->_groupfunc	= SPH_GROUPBY_DAY;
  933. 		$this->_groupsort	="@group desc";
  934. 		$this->_groupdistinct="";
  935. }
  937. /// clear all attribute value overrides (for multi-queries)
  938. functionResetOverrides()
  939. {
  940.     	$this->_overrides = array ();
  941. }
  943. //////////////////////////////////////////////////////////////////////////////
  945. /// connect to searchd server, run given search query through given indexes,
  946. /// and return the search results
  947. functionQuery( $query, $index="*", $comment="")
  948. {
  949. assert( empty($this->_reqs));
  951. 		$this->AddQuery( $query, $index, $comment );
  952. 		$results = $this->RunQueries();
  953. 		$this->_reqs = array ();// just in case it failed too early
  955. if(!is_array($results))
  956. returnfalse;// probably network error; error message should be already filled
  958. 		$this->_error = $results[0]["error"];
  959. 		$this->_warning = $results[0]["warning"];
  960. if( $results[0]["status"]==SEARCHD_ERROR )
  961. returnfalse;
  962. else
  963. return $results[0];
  964. }
  966. /// helper to pack floats in network byte order
  967. function_PackFloat( $f )
  968. {
  969. 		$t1 = pack ("f", $f );// machine order
  970. 		list(,$t2)= unpack ("L*", $t1 );// int in machine order
  971. return pack ("N", $t2 );
  972. }
  974. /// add query to multi-query batch
  975. /// returns index into results array from RunQueries() call
  976. functionAddQuery( $query, $index="*", $comment="")
  977. {
  978. // mbstring workaround
  979. 		$this->_MBPush();
  981. // build request
  982. 		$req = pack ("NNNNN", $this->_offset, $this->_limit, $this->_mode, $this->_ranker, $this->_sort );// mode and limits
  983. 		$req .= pack ("N", strlen($this->_sortby)). $this->_sortby;
  984. 		$req .= pack ("N", strlen($query)). $query;// query itself
  985. 		$req .= pack ("N", count($this->_weights));// weights
  986. foreach( $this->_weights as $weight )
  987. 			$req .= pack ("N",(int)$weight );
  988. 		$req .= pack ("N", strlen($index)). $index;// indexes
  989. 		$req .= pack ("N",1);// id64 range marker
  990. 		$req .= sphPackU64 ( $this->_min_id ). sphPackU64 ( $this->_max_id );// id64 range
  992. // filters
  993. 		$req .= pack ("N", count($this->_filters));
  994. foreach( $this->_filters as $filter )
  995. {
  996. 			$req .= pack ("N", strlen($filter["attr"])). $filter["attr"];
  997. 			$req .= pack ("N", $filter["type"]);
  998. switch( $filter["type"])
  999. {
  1000. case SPH_FILTER_VALUES:
  1001. 					$req .= pack ("N", count($filter["values"]));
  1002. foreach( $filter["values"]as $value )
  1003. 						$req .= sphPackI64 ( $value );
  1004. break;
  1006. case SPH_FILTER_RANGE:
  1007. 					$req .= sphPackI64 ( $filter["min"]). sphPackI64 ( $filter["max"]);
  1008. break;
  1010. case SPH_FILTER_FLOATRANGE:
  1011. 					$req .= $this->_PackFloat( $filter["min"]). $this->_PackFloat( $filter["max"]);
  1012. break;
  1014. default:
  1015. assert(0&&"internal error: unhandled filter type");
  1016. }
  1017. 			$req .= pack ("N", $filter["exclude"]);
  1018. }
  1020. // group-by clause, max-matches count, group-sort clause, cutoff count
  1021. 		$req .= pack ("NN", $this->_groupfunc, strlen($this->_groupby)). $this->_groupby;
  1022. 		$req .= pack ("N", $this->_maxmatches );
  1023. 		$req .= pack ("N", strlen($this->_groupsort)). $this->_groupsort;
  1024. 		$req .= pack ("NNN", $this->_cutoff, $this->_retrycount, $this->_retrydelay );
  1025. 		$req .= pack ("N", strlen($this->_groupdistinct)). $this->_groupdistinct;
  1027. // anchor point
  1028. if( empty($this->_anchor))
  1029. {
  1030. 			$req .= pack ("N",0);
  1031. }else
  1032. {
  1033. 			$a =& $this->_anchor;
  1034. 			$req .= pack ("N",1);
  1035. 			$req .= pack ("N", strlen($a["attrlat"])). $a["attrlat"];
  1036. 			$req .= pack ("N", strlen($a["attrlong"])). $a["attrlong"];
  1037. 			$req .= $this->_PackFloat( $a["lat"]). $this->_PackFloat( $a["long"]);
  1038. }
  1040. // per-index weights
  1041. 		$req .= pack ("N", count($this->_indexweights));
  1042. foreach( $this->_indexweights as $idx=>$weight )
  1043. 			$req .= pack ("N", strlen($idx)). $idx . pack ("N", $weight );
  1045. // max query time
  1046. 		$req .= pack ("N", $this->_maxquerytime );
  1048. // per-field weights
  1049. 		$req .= pack ("N", count($this->_fieldweights));
  1050. foreach( $this->_fieldweights as $field=>$weight )
  1051. 			$req .= pack ("N", strlen($field)). $field . pack ("N", $weight );
  1053. // comment
  1054. 		$req .= pack ("N", strlen($comment)). $comment;
  1056. // attribute overrides
  1057. 		$req .= pack ("N", count($this->_overrides));
  1058. foreach( $this->_overrides as $key => $entry )
  1059. {
  1060. 			$req .= pack ("N", strlen($entry["attr"])). $entry["attr"];
  1061. 			$req .= pack ("NN", $entry["type"], count($entry["values"]));
  1062. foreach( $entry["values"]as $id=>$val )
  1063. {
  1064. assert( is_numeric($id));
  1065. assert( is_numeric($val));
  1067. 				$req .= sphPackU64 ( $id );
  1068. switch( $entry["type"])
  1069. {
  1070. case SPH_ATTR_FLOAT:	$req .= $this->_PackFloat( $val );break;
  1071. case SPH_ATTR_BIGINT:	$req .= sphPackI64 ( $val );break;
  1072. default:				$req .= pack ("N", $val );break;
  1073. }
  1074. }
  1075. }
  1077. // select-list
  1078. 		$req .= pack ("N", strlen($this->_select)). $this->_select;
  1080. // mbstring workaround
  1081. 		$this->_MBPop();
  1083. // store request to requests array
  1084. 		$this->_reqs[]= $req;
  1085. return count($this->_reqs)-1;
  1086. }
  1088. /// connect to searchd, run queries batch, and return an array of result sets
  1089. functionRunQueries()
  1090. {
  1091. if( empty($this->_reqs))
  1092. {
  1093. 			$this->_error ="no queries defined, issue AddQuery() first";
  1094. returnfalse;
  1095. }
  1097. // mbstring workaround
  1098. 		$this->_MBPush();
  1100. if(!( $fp = $this->_Connect()))
  1101. {
  1102. 			$this->_MBPop();
  1103. returnfalse;
  1104. }
  1106. // send query, get response
  1107. 		$nreqs = count($this->_reqs);
  1108. 		$req = join ("", $this->_reqs );
  1109. 		$len =4+strlen($req);
  1110. 		$req = pack ("nnNN", SEARCHD_COMMAND_SEARCH, VER_COMMAND_SEARCH, $len, $nreqs ). $req;// add header
  1112. if(!( $this->_Send( $fp, $req, $len+8))||
  1113. !( $response = $this->_GetResponse( $fp, VER_COMMAND_SEARCH )))
  1114. {
  1115. 			$this->_MBPop();
  1116. returnfalse;
  1117. }
  1119. // query sent ok; we can reset reqs now
  1120. 		$this->_reqs = array ();
  1122. // parse and return response
  1123. return $this->_ParseSearchResponse( $response, $nreqs );
  1124. }
  1126. /// parse and return search query (or queries) response
  1127. function_ParseSearchResponse( $response, $nreqs )
  1128. {
  1129. 		$p =0;// current position
  1130. 		$max = strlen($response);// max position for checks, to protect against broken responses
  1132. 		$results = array ();
  1133. for( $ires=0; $ires<$nreqs && $p<$max; $ires++)
  1134. {
  1135. 			$results[]= array();
  1136. 			$result =& $results[$ires];
  1138. 			$result["error"]="";
  1139. 			$result["warning"]="";
  1141. // extract status
  1142. 			list(,$status)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1143. 			$result["status"]= $status;
  1144. if( $status!=SEARCHD_OK )
  1145. {
  1146. 				list(,$len)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1147. 				$message = substr ( $response, $p, $len ); $p += $len;
  1149. if( $status==SEARCHD_WARNING )
  1150. {
  1151. 					$result["warning"]= $message;
  1152. }else
  1153. {
  1154. 					$result["error"]= $message;
  1155. continue;
  1156. }
  1157. }
  1159. // read schema
  1160. 			$fields = array ();
  1161. 			$attrs = array ();
  1163. 			list(,$nfields)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1164. while( $nfields-->0&& $p<$max )
  1165. {
  1166. 				list(,$len)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1167. 				$fields[]= substr ( $response, $p, $len ); $p += $len;
  1168. }
  1169. 			$result["fields"]= $fields;
  1171. 			list(,$nattrs)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1172. while( $nattrs-->0&& $p<$max  )
  1173. {
  1174. 				list(,$len)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1175. 				$attr = substr ( $response, $p, $len ); $p += $len;
  1176. 				list(,$type)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1177. 				$attrs[$attr]= $type;
  1178. }
  1179. 			$result["attrs"]= $attrs;
  1181. // read match count
  1182. 			list(,$count)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1183. 			list(,$id64)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1185. // read matches
  1186. 			$idx =-1;
  1187. while( $count-->0&& $p<$max )
  1188. {
  1189. // index into result array
  1190. 				$idx++;
  1192. // parse document id and weight
  1193. if( $id64 )
  1194. {
  1195. 					$doc = sphUnpackU64 ( substr ( $response, $p,8)); $p +=8;
  1196. 					list(,$weight)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1197. }
  1198. else
  1199. {
  1200. 					list ( $doc, $weight )= array_values ( unpack ("N*N*",
  1201. 						substr ( $response, $p,8)));
  1202. 					$p +=8;
  1203. 					$doc = sphFixUint($doc);
  1204. }
  1205. 				$weight = sprintf ("%u", $weight );
  1207. // create match entry
  1208. if( $this->_arrayresult )
  1209. 					$result["matches"][$idx]= array ("id"=>$doc,"weight"=>$weight );
  1210. else
  1211. 					$result["matches"][$doc]["weight"]= $weight;
  1213. // parse and create attributes
  1214. 				$attrvals = array ();
  1215. foreach( $attrs as $attr=>$type )
  1216. {
  1217. // handle 64bit ints
  1218. if( $type==SPH_ATTR_BIGINT )
  1219. {
  1220. 						$attrvals[$attr]= sphUnpackI64 ( substr ( $response, $p,8)); $p +=8;
  1221. continue;
  1222. }
  1224. // handle floats
  1225. if( $type==SPH_ATTR_FLOAT )
  1226. {
  1227. 						list(,$uval)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1228. 						list(,$fval)= unpack ("f*", pack ("L", $uval ));
  1229. 						$attrvals[$attr]= $fval;
  1230. continue;
  1231. }
  1233. // handle everything else as unsigned ints
  1234. 					list(,$val)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1235. if( $type & SPH_ATTR_MULTI )
  1236. {
  1237. 						$attrvals[$attr]= array ();
  1238. 						$nvalues = $val;
  1239. while( $nvalues-->0&& $p<$max )
  1240. {
  1241. 							list(,$val)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1242. 							$attrvals[$attr][]= sphFixUint($val);
  1243. }
  1244. }else
  1245. {
  1246. 						$attrvals[$attr]= sphFixUint($val);
  1247. }
  1248. }
  1250. if( $this->_arrayresult )
  1251. 					$result["matches"][$idx]["attrs"]= $attrvals;
  1252. else
  1253. 					$result["matches"][$doc]["attrs"]= $attrvals;
  1254. }
  1256. 			list ( $total, $total_found, $msecs, $words )=
  1257. 				array_values ( unpack ("N*N*N*N*", substr ( $response, $p,16)));
  1258. 			$result["total"]= sprintf ("%u", $total );
  1259. 			$result["total_found"]= sprintf ("%u", $total_found );
  1260. 			$result["time"]= sprintf ("%.3f", $msecs/1000);
  1261. 			$p +=16;
  1263. while( $words-->0&& $p<$max )
  1264. {
  1265. 				list(,$len)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1266. 				$word = substr ( $response, $p, $len ); $p += $len;
  1267. 				list ( $docs, $hits )= array_values ( unpack ("N*N*", substr ( $response, $p,8))); $p +=8;
  1268. 				$result["words"][$word]= array (
  1269. "docs"=>sprintf ("%u", $docs ),
  1270. "hits"=>sprintf ("%u", $hits ));
  1271. }
  1272. }
  1274. 		$this->_MBPop();
  1275. return $results;
  1276. }
  1278. /////////////////////////////////////////////////////////////////////////////
  1279. // excerpts generation
  1280. /////////////////////////////////////////////////////////////////////////////
  1282. /// connect to searchd server, and generate exceprts (snippets)
  1283. /// of given documents for given query. returns false on failure,
  1284. /// an array of snippets on success
  1285. functionBuildExcerpts( $docs, $index, $words, $opts=array())
  1286. {
  1287. assert( is_array($docs));
  1288. assert( is_string($index));
  1289. assert( is_string($words));
  1290. assert( is_array($opts));
  1292. 		$this->_MBPush();
  1294. if(!( $fp = $this->_Connect()))
  1295. {
  1296. 			$this->_MBPop();
  1297. returnfalse;
  1298. }
  1300. /////////////////
  1301. // fixup options
  1302. /////////////////
  1304. if(!isset($opts["before_match"]))		$opts["before_match"]="";
  1305. if(!isset($opts["after_match"]))			$opts["after_match"]="";
  1306. if(!isset($opts["chunk_separator"]))		$opts["chunk_separator"]=" ... ";
  1307. if(!isset($opts["limit"]))				$opts["limit"]=256;
  1308. if(!isset($opts["around"]))				$opts["around"]=5;
  1309. if(!isset($opts["exact_phrase"]))		$opts["exact_phrase"]=false;
  1310. if(!isset($opts["single_passage"]))		$opts["single_passage"]=false;
  1311. if(!isset($opts["use_boundaries"]))		$opts["use_boundaries"]=false;
  1312. if(!isset($opts["weight_order"]))		$opts["weight_order"]=false;
  1314. /////////////////
  1315. // build request
  1316. /////////////////
  1318. // v.1.0 req
  1319. 		$flags =1;// remove spaces
  1320. if( $opts["exact_phrase"])	$flags |=2;
  1321. if( $opts["single_passage"])	$flags |=4;
  1322. if( $opts["use_boundaries"])	$flags |=8;
  1323. if( $opts["weight_order"])	$flags |=16;
  1324. 		$req = pack ("NN",0, $flags );// mode=0, flags=$flags
  1325. 		$req .= pack ("N", strlen($index)). $index;// req index
  1326. 		$req .= pack ("N", strlen($words)). $words;// req words
  1328. // options
  1329. 		$req .= pack ("N", strlen($opts["before_match"])). $opts["before_match"];
  1330. 		$req .= pack ("N", strlen($opts["after_match"])). $opts["after_match"];
  1331. 		$req .= pack ("N", strlen($opts["chunk_separator"])). $opts["chunk_separator"];
  1332. 		$req .= pack ("N",(int)$opts["limit"]);
  1333. 		$req .= pack ("N",(int)$opts["around"]);
  1335. // documents
  1336. 		$req .= pack ("N", count($docs));
  1337. foreach( $docs as $doc )
  1338. {
  1339. assert( is_string($doc));
  1340. 			$req .= pack ("N", strlen($doc)). $doc;
  1341. }
  1343. ////////////////////////////
  1344. // send query, get response
  1345. ////////////////////////////
  1347. 		$len = strlen($req);
  1348. 		$req = pack ("nnN", SEARCHD_COMMAND_EXCERPT, VER_COMMAND_EXCERPT, $len ). $req;// add header
  1349. if(!( $this->_Send( $fp, $req, $len+8))||
  1350. !( $response = $this->_GetResponse( $fp, VER_COMMAND_EXCERPT )))
  1351. {
  1352. 			$this->_MBPop();
  1353. returnfalse;
  1354. }
  1356. //////////////////
  1357. // parse response
  1358. //////////////////
  1360. 		$pos =0;
  1361. 		$res = array ();
  1362. 		$rlen = strlen($response);
  1363. for( $i=0; $i<count($docs); $i++)
  1364. {
  1365. 			list(,$len)= unpack ("N*", substr ( $response, $pos,4));
  1366. 			$pos +=4;
  1368. if( $pos+$len > $rlen )
  1369. {
  1370. 				$this->_error ="incomplete reply";
  1371. 				$this->_MBPop();
  1372. returnfalse;
  1373. }
  1374. 			$res[]= $len ? substr ( $response, $pos, $len ):"";
  1375. 			$pos += $len;
  1376. }
  1378. 		$this->_MBPop();
  1379. return $res;
  1380. }
  1383. /////////////////////////////////////////////////////////////////////////////
  1384. // keyword generation
  1385. /////////////////////////////////////////////////////////////////////////////
  1387. /// connect to searchd server, and generate keyword list for a given query
  1388. /// returns false on failure,
  1389. /// an array of words on success
  1390. functionBuildKeywords( $query, $index, $hits )
  1391. {
  1392. assert( is_string($query));
  1393. assert( is_string($index));
  1394. assert( is_bool($hits));
  1396. 		$this->_MBPush();
  1398. if(!( $fp = $this->_Connect()))
  1399. {
  1400. 			$this->_MBPop();
  1401. returnfalse;
  1402. }
  1404. /////////////////
  1405. // build request
  1406. /////////////////
  1408. // v.1.0 req
  1409. 		$req  = pack ("N", strlen($query)). $query;// req query
  1410. 		$req .= pack ("N", strlen($index)). $index;// req index
  1411. 		$req .= pack ("N",(int)$hits );
  1413. ////////////////////////////
  1414. // send query, get response
  1415. ////////////////////////////
  1417. 		$len = strlen($req);
  1418. 		$req = pack ("nnN", SEARCHD_COMMAND_KEYWORDS, VER_COMMAND_KEYWORDS, $len ). $req;// add header
  1419. if(!( $this->_Send( $fp, $req, $len+8))||
  1420. !( $response = $this->_GetResponse( $fp, VER_COMMAND_KEYWORDS )))
  1421. {
  1422. 			$this->_MBPop();
  1423. returnfalse;
  1424. }
  1426. //////////////////
  1427. // parse response
  1428. //////////////////
  1430. 		$pos =0;
  1431. 		$res = array ();
  1432. 		$rlen = strlen($response);
  1433. 		list(,$nwords)= unpack ("N*", substr ( $response, $pos,4));
  1434. 		$pos +=4;
  1435. for( $i=0; $i<$nwords; $i++)
  1436. {
  1437. 			list(,$len)= unpack ("N*", substr ( $response, $pos,4));	$pos +=4;
  1438. 			$tokenized = $len ? substr ( $response, $pos, $len ):"";
  1439. 			$pos += $len;
  1441. 			list(,$len)= unpack ("N*", substr ( $response, $pos,4));	$pos +=4;
  1442. 			$normalized = $len ? substr ( $response, $pos, $len ):"";
  1443. 			$pos += $len;
  1445. 			$res[]= array ("tokenized"=>$tokenized,"normalized"=>$normalized );
  1447. if( $hits )
  1448. {
  1449. 				list($ndocs,$nhits)= array_values ( unpack ("N*N*", substr ( $response, $pos,8)));
  1450. 				$pos +=8;
  1451. 				$res [$i]["docs"]= $ndocs;
  1452. 				$res [$i]["hits"]= $nhits;
  1453. }
  1455. if( $pos > $rlen )
  1456. {
  1457. 				$this->_error ="incomplete reply";
  1458. 				$this->_MBPop();
  1459. returnfalse;
  1460. }
  1461. }
  1463. 		$this->_MBPop();
  1464. return $res;
  1465. }
  1467. functionEscapeString( $string )
  1468. {
  1469. 		$from = array ('\','(',')','|','-','!','@','~','"','&','/','^','$','=');
  1470. 		$to   = array ('\\','(',')','|','-','!','@','~','"','&','/','^','$','=');
  1472. return str_replace ( $from, $to, $string );
  1473. }
  1475. /////////////////////////////////////////////////////////////////////////////
  1476. // attribute updates
  1477. /////////////////////////////////////////////////////////////////////////////
  1479. /// batch update given attributes in given rows in given indexes
  1480. /// returns amount of updated documents (0 or more) on success, or -1 on failure
  1481. functionUpdateAttributes( $index, $attrs, $values, $mva=false)
  1482. {
  1483. // verify everything
  1484. assert( is_string($index));
  1485. assert( is_bool($mva));
  1487. assert( is_array($attrs));
  1488. foreach( $attrs as $attr )
  1489. assert( is_string($attr));
  1491. assert( is_array($values));
  1492. foreach( $values as $id=>$entry )
  1493. {
  1494. assert( is_numeric($id));
  1495. assert( is_array($entry));
  1496. assert( count($entry)==count($attrs));
  1497. foreach( $entry as $v )
  1498. {
  1499. if( $mva )
  1500. {
  1501. assert( is_array($v));
  1502. foreach( $v as $vv )
  1503. assert( is_int($vv));
  1504. }else
  1505. assert( is_int($v));
  1506. }
  1507. }
  1509. // build request
  1510. 		$req = pack ("N", strlen($index)). $index;
  1512. 		$req .= pack ("N", count($attrs));
  1513. foreach( $attrs as $attr )
  1514. {
  1515. 			$req .= pack ("N", strlen($attr)). $attr;
  1516. 			$req .= pack ("N", $mva ?1:0);
  1517. }
  1519. 		$req .= pack ("N", count($values));
  1520. foreach( $values as $id=>$entry )
  1521. {
  1522. 			$req .= sphPackU64 ( $id );
  1523. foreach( $entry as $v )
  1524. {
  1525. 				$req .= pack ("N", $mva ? count($v): $v );
  1526. if( $mva )
  1527. foreach( $v as $vv )
  1528. 						$req .= pack ("N", $vv );
  1529. }
  1530. }
  1532. // connect, send query, get response
  1533. if(!( $fp = $this->_Connect()))
  1534. return-1;
  1536. 		$len = strlen($req);
  1537. 		$req = pack ("nnN", SEARCHD_COMMAND_UPDATE, VER_COMMAND_UPDATE, $len ). $req;// add header
  1538. if(!$this->_Send( $fp, $req, $len+8))
  1539. return-1;
  1541. if(!( $response = $this->_GetResponse( $fp, VER_COMMAND_UPDATE )))
  1542. return-1;
  1544. // parse response
  1545. 		list(,$updated)= unpack ("N*", substr ( $response,0,4));
  1546. return $updated;
  1547. }
  1549. /////////////////////////////////////////////////////////////////////////////
  1550. // persistent connections
  1551. /////////////////////////////////////////////////////////////////////////////
  1553. functionOpen()
  1554. {
  1555. if( $this->_socket !==false)
  1556. {
  1557. 			$this->_error ='already connected';
  1558. returnfalse;
  1559. }
  1560. if(!$fp = $this->_Connect())
  1561. returnfalse;
  1563. // command, command version = 0, body length = 4, body = 1
  1564. 		$req = pack ("nnNN", SEARCHD_COMMAND_PERSIST,0,4,1);
  1565. if(!$this->_Send( $fp, $req,12))
  1566. returnfalse;
  1568. 		$this->_socket = $fp;
  1569. returntrue;
  1570. }
  1572. functionClose()
  1573. {
  1574. if( $this->_socket ===false)
  1575. {
  1576. 			$this->_error ='not connected';
  1577. returnfalse;
  1578. }
  1580. 		fclose ( $this->_socket );
  1581. 		$this->_socket =false;
  1583. returntrue;
  1584. }
  1586. //////////////////////////////////////////////////////////////////////////
  1587. // status
  1588. //////////////////////////////////////////////////////////////////////////
  1590. functionStatus()
  1591. {
  1592. 		$this->_MBPush();
  1593. if(!( $fp = $this->_Connect()))
  1594. {
  1595. 			$this->_MBPop();
  1596. returnfalse;
  1597. }
  1599. 		$req = pack ("nnNN", SEARCHD_COMMAND_STATUS, VER_COMMAND_STATUS,4,1);// len=4, body=1
  1600. if(!( $this->_Send( $fp, $req,12))||
  1601. !( $response = $this->_GetResponse( $fp, VER_COMMAND_STATUS )))
  1602. {
  1603. 			$this->_MBPop();
  1604. returnfalse;
  1605. }
  1607. 		$res = substr ( $response,4);// just ignore length, error handling, etc
  1608. 		$p =0;
  1609. 		list ( $rows, $cols )= array_values ( unpack ("N*N*", substr ( $response, $p,8))); $p +=8;
  1611. 		$res = array();
  1612. for( $i=0; $i<$rows; $i++)
  1613. for( $j=0; $j<$cols; $j++)
  1614. {
  1615. 			list(,$len)= unpack ("N*", substr ( $response, $p,4)); $p +=4;
  1616. 			$res[$i][]= substr ( $response, $p, $len ); $p += $len;
  1617. }
  1619. 		$this->_MBPop();
  1620. return $res;
  1621. }
  1622. }
  1624. //
  1625. // $Id: sphinxapi.php 2055 2009-11-06 23:09:58Z shodan $
  1626. //

测试控制器(/application/controllers/search_page.php)
  1. php if(!defined('BASEPATH'))die('No Access');
  3. classSearch_pageextends CI_Controller{
  5. publicfunction __construct(){
  6.             parent::__construct();
  7. }
  9. publicfunction search(){
  10.             $this->load->helper('url');
  11.             $this->load->view('search');
  12. }
  14. publicfunction result(){
  15.             header('content-type: text/html;charset=utf-8');
  16.             $words = $this->input->get('words');
  17. if($words===NULL) $words ='';
  18.             $this->load->library('sphinx_client', NULL,'sphinx');
  19.             $index ="test1";
  20.             $opts = array
  21. (
  22. "before_match"=>'',
  23. "after_match"=>"",
  24. "chunk_separator"=>" ... ",
  25. "limit"=>60,
  26. "around"=>3,
  27. );
  28.             $this->sphinx->SetServer('192.168.23.128',9312);
  29.             $this->sphinx->SetConnectTimeout(3);
  30.             $this->sphinx->SetArrayResult(TRUE);
  31.             $this->sphinx->SetMatchMode(SPH_MATCH_ANY);
  32.             $this->sphinx->SetLimits(0,20);
  34.             $res = $this->sphinx->Query($words,'test1');
  35. if($res===FALSE){
  36.                 var_dump($this->sphinx->GetLastError());
  37. exit;
  38. }
  40.             echo "关键词 {$words} ，找到约 {$res['total_found']} 结果，用时 {$res['time']}s";
  41.             echo '

    '    ;
  42. if(array_key_exists('words', $res)&& is_array($res['words'])){
  43. foreach($res['words']as $k => $v){
  44.                     echo $k .' : '. $v['docs'].' - '. $v['hits'].'
    '    ;
  45. }
  46. }
  47.             echo '

    '    ;
  48.             $this->load->database();
  49.             $idarr = array();
  50. if(array_key_exists('matches', $res)&& is_array($res['matches'])){
  51. foreach($res['matches']as $v){
  52.                     $idarr[]= $v['id'];
  53. }
  54. }
  55. if(count($idarr)>0){
  56.                 $this->db->from('shop_goods_info');
  57.                 $this->db->select('pname,cretime');
  58.                 $this->db->where_in('id', $idarr);
  59.                 $result = $this->db->get()->result_array();
  60.                 echo '
      ';
    •                 $name_arr = array();
    • foreach($result as $k=>$v){
    •                     $name_arr[$k]= $v['pname'];
    • }
    •                 $name_arr = $this->sphinx->BuildExcerpts($name_arr, $index, $words, $opts);
    • foreach($result as $k=>$v){
    •                     echo '
    • '. $name_arr[$k].'('. date('Y-m-d H:i:s', $v['cretime']).')
      • ';
    • }
    •                 echo '
    ';
  61. }
  62.             $this->sphinx->Close();
  63. }
  65. }
  66. ?>


搜索表单(/application/views/search.php)
  4. http-equiv="content-type"content="text/html;charset=utf-8"/>
  5. </span><span class="pln">搜索</span><span class="tag">
  6. name="keywords"content="keywords"/>
  7. name="description"content="description"/>
  8. type="text/css">
  9. #panel {
  10.             margin:20px;
  11. }
  15. id="panel">
  16. php echo site_url(array('search_page','result'));?>">
  17. for="words">关键词:
  18. type="text"id="words"name="words"value=""size="60"/>
  19. type="submit"name="submit"value="搜索"/>