]> git.wh0rd.org - tt-rss.git/blob - lib/sphinxapi.php.08_04_11_183927
git.wh0rd.org / tt-rss.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update lib/sphinxapi.php to V2.0.1
[tt-rss.git] / lib / sphinxapi.php.08_04_11_183927
1 <?php
2
3 //
4 // $Id: sphinxapi.php 2055 2009-11-06 23:09:58Z shodan $
5 //
6
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 //
15
16 /////////////////////////////////////////////////////////////////////////////
17 // PHP version of Sphinx searchd client (PHP API)
18 /////////////////////////////////////////////////////////////////////////////
19
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 );
28
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 );
36
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 );
42
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)
51
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 );
60
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 );
68
69 /// known filter types
70 define ( "SPH_FILTER_VALUES", 0 );
71 define ( "SPH_FILTER_RANGE", 1 );
72 define ( "SPH_FILTER_FLOATRANGE", 2 );
73
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 );
82
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 );
90
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
97
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
116
117 /// pack 64-bit signed
118 function sphPackI64 ( $v )
119 {
120 assert ( is_numeric($v) );
121
122 // x64
123 if ( PHP_INT_SIZE>=8 )
124 {
125 $v = (int)$v;
126 return pack ( "NN", $v>>32, $v&0xFFFFFFFF );
127 }
128
129 // x32, int
130 if ( is_int($v) )
131 return pack ( "NN", $v < 0 ? -1 : 0, $v );
132
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 }
142
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));
147
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
152
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 }
165
166 /// pack 64-bit unsigned
167 function sphPackU64 ( $v )
168 {
169 assert ( is_numeric($v) );
170
171 // x64
172 if ( PHP_INT_SIZE>=8 )
173 {
174 assert ( $v>=0 );
175
176 // x64, int
177 if ( is_int($v) )
178 return pack ( "NN", $v>>32, $v&0xFFFFFFFF );
179
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 }
187
188 // x64, no-bcmath
189 $p = max ( 0, strlen($v) - 13 );
190 $lo = (int)substr ( $v, $p );
191 $hi = (int)substr ( $v, 0, $p );
192
193 $m = $lo + $hi*1316134912;
194 $l = $m % 4294967296;
195 $h = $hi*2328 + (int)($m/4294967296);
196
197 return pack ( "NN", $h, $l );
198 }
199
200 // x32, int
201 if ( is_int($v) )
202 return pack ( "NN", 0, $v );
203
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 }
211
212 // x32, no-bcmath
213 $p = max(0, strlen($v) - 13);
214 $lo = (float)substr($v, $p);
215 $hi = (float)substr($v, 0, $p);
216
217 $m = $lo + $hi*1316134912.0;
218 $q = floor($m / 4294967296.0);
219 $l = $m - ($q * 4294967296.0);
220 $h = $hi*2328.0 + $q;
221
222 return pack ( "NN", $h, $l );
223 }
224
225 // unpack 64-bit unsigned
226 function sphUnpackU64 ( $v )
227 {
228 list ( $hi, $lo ) = array_values ( unpack ( "N*N*", $v ) );
229
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);
234
235 // x64, int
236 if ( $hi<=2147483647 )
237 return ($hi<<32) + $lo;
238
239 // x64, bcmath
240 if ( function_exists("bcmul") )
241 return bcadd ( $lo, bcmul ( $hi, "4294967296" ) );
242
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 }
252
253 if ( $h==0 )
254 return $l;
255 return sprintf ( "%d%05d", $h, $l );
256 }
257
258 // x32, int
259 if ( $hi==0 )
260 {
261 if ( $lo>0 )
262 return $lo;
263 return sprintf ( "%u", $lo );
264 }
265
266 $hi = sprintf ( "%u", $hi );
267 $lo = sprintf ( "%u", $lo );
268
269 // x32, bcmath
270 if ( function_exists("bcmul") )
271 return bcadd ( $lo, bcmul ( $hi, "4294967296" ) );
272
273 // x32, no-bcmath
274 $hi = (float)$hi;
275 $lo = (float)$lo;
276
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;
283
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 }
290
291 // unpack 64-bit signed
292 function sphUnpackI64 ( $v )
293 {
294 list ( $hi, $lo ) = array_values ( unpack ( "N*N*", $v ) );
295
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);
301
302 return ($hi<<32) + $lo;
303 }
304
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 }
319
320 $neg = "";
321 $c = 0;
322 if ( $hi<0 )
323 {
324 $hi = ~$hi;
325 $lo = ~$lo;
326 $c = 1;
327 $neg = "-";
328 }
329
330 $hi = sprintf ( "%u", $hi );
331 $lo = sprintf ( "%u", $lo );
332
333 // x32, bcmath
334 if ( function_exists("bcmul") )
335 return $neg . bcadd ( bcadd ( $lo, bcmul ( $hi, "4294967296" ) ), $c );
336
337 // x32, no-bcmath
338 $hi = (float)$hi;
339 $lo = (float)$lo;
340
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 }
352
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 }
359
360
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 }
375
376
377 /// sphinx searchd client class
378 class SphinxClient
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)
406
407 var $_error; ///< last error message
408 var $_warning; ///< last warning message
409 var $_connerror; ///< connection error vs remote error flag
410
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
415
416 /////////////////////////////////////////////////////////////////////////////
417 // common stuff
418 /////////////////////////////////////////////////////////////////////////////
419
420 /// create a new client object and fill defaults
421 function SphinxClient ()
422 {
423 // per-client-object settings
424 $this->_host = "localhost";
425 $this->_port = 9312;
426 $this->_path = false;
427 $this->_socket = false;
428
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 = "*";
454
455 $this->_error = ""; // per-reply fields (for single-query case)
456 $this->_warning = "";
457 $this->_connerror = false;
458
459 $this->_reqs = array (); // requests storage (for multi-query case)
460 $this->_mbenc = "";
461 $this->_arrayresult = false;
462 $this->_timeout = 0;
463 }
464
465 function __destruct()
466 {
467 if ( $this->_socket !== false )
468 fclose ( $this->_socket );
469 }
470
471 /// get last error message (string)
472 function GetLastError ()
473 {
474 return $this->_error;
475 }
476
477 /// get last warning message (string)
478 function GetLastWarning ()
479 {
480 return $this->_warning;
481 }
482
483 /// get last error flag (to tell network connection errors from searchd errors or broken responses)
484 function IsConnectError()
485 {
486 return $this->_connerror;
487 }
488
489 /// set searchd host name (string) and port (integer)
490 function SetServer ( $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 }
503
504 assert ( is_int($port) );
505 $this->_host = $host;
506 $this->_port = $port;
507 $this->_path = '';
508
509 }
510
511 /// set server connection timeout (0 to remove)
512 function SetConnectTimeout ( $timeout )
513 {
514 assert ( is_numeric($timeout) );
515 $this->_timeout = $timeout;
516 }
517
518
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 return false;
526 }
527 return true;
528 }
529
530 /////////////////////////////////////////////////////////////////////////////
531
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 }
542
543 /// leave mbstring workaround mode
544 function _MBPop ()
545 {
546 if ( $this->_mbenc )
547 mb_internal_encoding ( $this->_mbenc );
548 }
549
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;
559
560 // force reopen
561 $this->_socket = false;
562 }
563
564 $errno = 0;
565 $errstr = "";
566 $this->_connerror = false;
567
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 }
578
579 if ( $this->_timeout<=0 )
580 $fp = @fsockopen ( $host, $port, $errno, $errstr );
581 else
582 $fp = @fsockopen ( $host, $port, $errno, $errstr, $this->_timeout );
583
584 if ( !$fp )
585 {
586 if ( $this->_path )
587 $location = $this->_path;
588 else
589 $location = "{$this->_host}:{$this->_port}";
590
591 $errstr = trim ( $errstr );
592 $this->_error = "connection to $location failed (errno=$errno, msg=$errstr)";
593 $this->_connerror = true;
594 return false;
595 }
596
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 return false;
606 }
607
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 return false;
616 }
617
618 return $fp;
619 }
620
621 /// get and check response packet from searchd server
622 function _GetResponse ( $fp, $client_ver )
623 {
624 $response = "";
625 $len = 0;
626
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 );
644
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 return false;
653 }
654
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 return false;
666 }
667 if ( $status==SEARCHD_RETRY )
668 {
669 $this->_error = "temporary searchd error: " . substr ( $response, 4 );
670 return false;
671 }
672 if ( $status!=SEARCHD_OK )
673 {
674 $this->_error = "unknown status code '$status'";
675 return false;
676 }
677
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 }
684
685 return $response;
686 }
687
688 /////////////////////////////////////////////////////////////////////////////
689 // searching
690 /////////////////////////////////////////////////////////////////////////////
691
692 /// set offset and count into result set,
693 /// and optionally set max-matches and cutoff limits
694 function SetLimits ( $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 }
708
709 /// set maximum query time, in milliseconds, per-index
710 /// integer, 0 means "do not limit"
711 function SetMaxQueryTime ( $max )
712 {
713 assert ( is_int($max) );
714 assert ( $max>=0 );
715 $this->_maxquerytime = $max;
716 }
717
718 /// set matching mode
719 function SetMatchMode ( $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 }
730
731 /// set ranking mode
732 function SetRankingMode ( $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 }
741
742 /// set matches sorting mode
743 function SetSortMode ( $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 );
754
755 $this->_sort = $mode;
756 $this->_sortby = $sortby;
757 }
758
759 /// bind per-field weights by order
760 /// DEPRECATED; use SetFieldWeights() instead
761 function SetWeights ( $weights )
762 {
763 assert ( is_array($weights) );
764 foreach ( $weights as $weight )
765 assert ( is_int($weight) );
766
767 $this->_weights = $weights;
768 }
769
770 /// bind per-field weights by name
771 function SetFieldWeights ( $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 }
781
782 /// bind per-index weights by name
783 function SetIndexWeights ( $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 }
793
794 /// set IDs range to match
795 /// only match records if document ID is beetwen $min and $max (inclusive)
796 function SetIDRange ( $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 }
804
805 /// set values set filter
806 /// only match records where $attribute value is in given set
807 function SetFilter ( $attribute, $values, $exclude=false )
808 {
809 assert ( is_string($attribute) );
810 assert ( is_array($values) );
811 assert ( count($values) );
812
813 if ( is_array($values) && count($values) )
814 {
815 foreach ( $values as $value )
816 assert ( is_numeric($value) );
817
818 $this->_filters[] = array ( "type"=>SPH_FILTER_VALUES, "attr"=>$attribute, "exclude"=>$exclude, "values"=>$values );
819 }
820 }
821
822 /// set range filter
823 /// only match records if $attribute value is beetwen $min and $max (inclusive)
824 function SetFilterRange ( $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 );
830
831 $this->_filters[] = array ( "type"=>SPH_FILTER_RANGE, "attr"=>$attribute, "exclude"=>$exclude, "min"=>$min, "max"=>$max );
832 }
833
834 /// set float range filter
835 /// only match records if $attribute value is beetwen $min and $max (inclusive)
836 function SetFilterFloatRange ( $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 );
842
843 $this->_filters[] = array ( "type"=>SPH_FILTER_FLOATRANGE, "attr"=>$attribute, "exclude"=>$exclude, "min"=>$min, "max"=>$max );
844 }
845
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 function SetGeoAnchor ( $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) );
855
856 $this->_anchor = array ( "attrlat"=>$attrlat, "attrlong"=>$attrlong, "lat"=>$lat, "long"=>$long );
857 }
858
859 /// set grouping attribute and function
860 function SetGroupBy ( $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 );
870
871 $this->_groupby = $attribute;
872 $this->_groupfunc = $func;
873 $this->_groupsort = $groupsort;
874 }
875
876 /// set count-distinct attribute for group-by queries
877 function SetGroupDistinct ( $attribute )
878 {
879 assert ( is_string($attribute) );
880 $this->_groupdistinct = $attribute;
881 }
882
883 /// set distributed retries count and delay
884 function SetRetries ( $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 }
891
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 function SetArrayResult ( $arrayresult )
895 {
896 assert ( is_bool($arrayresult) );
897 $this->_arrayresult = $arrayresult;
898 }
899
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 function SetOverride ( $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 ) );
908
909 $this->_overrides[$attrname] = array ( "attr"=>$attrname, "type"=>$attrtype, "values"=>$values );
910 }
911
912 /// set select-list (attributes or expressions), SQL-like syntax
913 function SetSelect ( $select )
914 {
915 assert ( is_string ( $select ) );
916 $this->_select = $select;
917 }
918
919 //////////////////////////////////////////////////////////////////////////////
920
921 /// clear all filters (for multi-queries)
922 function ResetFilters ()
923 {
924 $this->_filters = array();
925 $this->_anchor = array();
926 }
927
928 /// clear groupby settings (for multi-queries)
929 function ResetGroupBy ()
930 {
931 $this->_groupby = "";
932 $this->_groupfunc = SPH_GROUPBY_DAY;
933 $this->_groupsort = "@group desc";
934 $this->_groupdistinct= "";
935 }
936
937 /// clear all attribute value overrides (for multi-queries)
938 function ResetOverrides ()
939 {
940 $this->_overrides = array ();
941 }
942
943 //////////////////////////////////////////////////////////////////////////////
944
945 /// connect to searchd server, run given search query through given indexes,
946 /// and return the search results
947 function Query ( $query, $index="*", $comment="" )
948 {
949 assert ( empty($this->_reqs) );
950
951 $this->AddQuery ( $query, $index, $comment );
952 $results = $this->RunQueries ();
953 $this->_reqs = array (); // just in case it failed too early
954
955 if ( !is_array($results) )
956 return false; // probably network error; error message should be already filled
957
958 $this->_error = $results[0]["error"];
959 $this->_warning = $results[0]["warning"];
960 if ( $results[0]["status"]==SEARCHD_ERROR )
961 return false;
962 else
963 return $results[0];
964 }
965
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 }
973
974 /// add query to multi-query batch
975 /// returns index into results array from RunQueries() call
976 function AddQuery ( $query, $index="*", $comment="" )
977 {
978 // mbstring workaround
979 $this->_MBPush ();
980
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
991
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;
1005
1006 case SPH_FILTER_RANGE:
1007 $req .= sphPackI64 ( $filter["min"] ) . sphPackI64 ( $filter["max"] );
1008 break;
1009
1010 case SPH_FILTER_FLOATRANGE:
1011 $req .= $this->_PackFloat ( $filter["min"] ) . $this->_PackFloat ( $filter["max"] );
1012 break;
1013
1014 default:
1015 assert ( 0 && "internal error: unhandled filter type" );
1016 }
1017 $req .= pack ( "N", $filter["exclude"] );
1018 }
1019
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;
1026
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 }
1039
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 );
1044
1045 // max query time
1046 $req .= pack ( "N", $this->_maxquerytime );
1047
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 );
1052
1053 // comment
1054 $req .= pack ( "N", strlen($comment) ) . $comment;
1055
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) );
1066
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 }
1076
1077 // select-list
1078 $req .= pack ( "N", strlen($this->_select) ) . $this->_select;
1079
1080 // mbstring workaround
1081 $this->_MBPop ();
1082
1083 // store request to requests array
1084 $this->_reqs[] = $req;
1085 return count($this->_reqs)-1;
1086 }
1087
1088 /// connect to searchd, run queries batch, and return an array of result sets
1089 function RunQueries ()
1090 {
1091 if ( empty($this->_reqs) )
1092 {
1093 $this->_error = "no queries defined, issue AddQuery() first";
1094 return false;
1095 }
1096
1097 // mbstring workaround
1098 $this->_MBPush ();
1099
1100 if (!( $fp = $this->_Connect() ))
1101 {
1102 $this->_MBPop ();
1103 return false;
1104 }
1105
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
1111
1112 if ( !( $this->_Send ( $fp, $req, $len+8 ) ) ||
1113 !( $response = $this->_GetResponse ( $fp, VER_COMMAND_SEARCH ) ) )
1114 {
1115 $this->_MBPop ();
1116 return false;
1117 }
1118
1119 // query sent ok; we can reset reqs now
1120 $this->_reqs = array ();
1121
1122 // parse and return response
1123 return $this->_ParseSearchResponse ( $response, $nreqs );
1124 }
1125
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
1131
1132 $results = array ();
1133 for ( $ires=0; $ires<$nreqs && $p<$max; $ires++ )
1134 {
1135 $results[] = array();
1136 $result =& $results[$ires];
1137
1138 $result["error"] = "";
1139 $result["warning"] = "";
1140
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;
1148
1149 if ( $status==SEARCHD_WARNING )
1150 {
1151 $result["warning"] = $message;
1152 } else
1153 {
1154 $result["error"] = $message;
1155 continue;
1156 }
1157 }
1158
1159 // read schema
1160 $fields = array ();
1161 $attrs = array ();
1162
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;
1170
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;
1180
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;
1184
1185 // read matches
1186 $idx = -1;
1187 while ( $count-->0 && $p<$max )
1188 {
1189 // index into result array
1190 $idx++;
1191
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 );
1206
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;
1212
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 }
1223
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 }
1232
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 }
1249
1250 if ( $this->_arrayresult )
1251 $result["matches"][$idx]["attrs"] = $attrvals;
1252 else
1253 $result["matches"][$doc]["attrs"] = $attrvals;
1254 }
1255
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;
1262
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 }
1273
1274 $this->_MBPop ();
1275 return $results;
1276 }
1277
1278 /////////////////////////////////////////////////////////////////////////////
1279 // excerpts generation
1280 /////////////////////////////////////////////////////////////////////////////
1281
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 function BuildExcerpts ( $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) );
1291
1292 $this->_MBPush ();
1293
1294 if (!( $fp = $this->_Connect() ))
1295 {
1296 $this->_MBPop();
1297 return false;
1298 }
1299
1300 /////////////////
1301 // fixup options
1302 /////////////////
1303
1304 if ( !isset($opts["before_match"]) ) $opts["before_match"] = "<b>";
1305 if ( !isset($opts["after_match"]) ) $opts["after_match"] = "</b>";
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;
1313
1314 /////////////////
1315 // build request
1316 /////////////////
1317
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
1327
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"] );
1334
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 }
1342
1343 ////////////////////////////
1344 // send query, get response
1345 ////////////////////////////
1346
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 return false;
1354 }
1355
1356 //////////////////
1357 // parse response
1358 //////////////////
1359
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;
1367
1368 if ( $pos+$len > $rlen )
1369 {
1370 $this->_error = "incomplete reply";
1371 $this->_MBPop ();
1372 return false;
1373 }
1374 $res[] = $len ? substr ( $response, $pos, $len ) : "";
1375 $pos += $len;
1376 }
1377
1378 $this->_MBPop ();
1379 return $res;
1380 }
1381
1382
1383 /////////////////////////////////////////////////////////////////////////////
1384 // keyword generation
1385 /////////////////////////////////////////////////////////////////////////////
1386
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 function BuildKeywords ( $query, $index, $hits )
1391 {
1392 assert ( is_string($query) );
1393 assert ( is_string($index) );
1394 assert ( is_bool($hits) );
1395
1396 $this->_MBPush ();
1397
1398 if (!( $fp = $this->_Connect() ))
1399 {
1400 $this->_MBPop();
1401 return false;
1402 }
1403
1404 /////////////////
1405 // build request
1406 /////////////////
1407
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 );
1412
1413 ////////////////////////////
1414 // send query, get response
1415 ////////////////////////////
1416
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 return false;
1424 }
1425
1426 //////////////////
1427 // parse response
1428 //////////////////
1429
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;
1440
1441 list(,$len) = unpack ( "N*", substr ( $response, $pos, 4 ) ); $pos += 4;
1442 $normalized = $len ? substr ( $response, $pos, $len ) : "";
1443 $pos += $len;
1444
1445 $res[] = array ( "tokenized"=>$tokenized, "normalized"=>$normalized );
1446
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 }
1454
1455 if ( $pos > $rlen )
1456 {
1457 $this->_error = "incomplete reply";
1458 $this->_MBPop ();
1459 return false;
1460 }
1461 }
1462
1463 $this->_MBPop ();
1464 return $res;
1465 }
1466
1467 function EscapeString ( $string )
1468 {
1469 $from = array ( '\\', '(',')','|','-','!','@','~','"','&', '/', '^', '$', '=' );
1470 $to = array ( '\\\\', '\(','\)','\|','\-','\!','\@','\~','\"', '\&', '\/', '\^', '\$', '\=' );
1471
1472 return str_replace ( $from, $to, $string );
1473 }
1474
1475 /////////////////////////////////////////////////////////////////////////////
1476 // attribute updates
1477 /////////////////////////////////////////////////////////////////////////////
1478
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 function UpdateAttributes ( $index, $attrs, $values, $mva=false )
1482 {
1483 // verify everything
1484 assert ( is_string($index) );
1485 assert ( is_bool($mva) );
1486
1487 assert ( is_array($attrs) );
1488 foreach ( $attrs as $attr )
1489 assert ( is_string($attr) );
1490
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 }
1508
1509 // build request
1510 $req = pack ( "N", strlen($index) ) . $index;
1511
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 }
1518
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 }
1531
1532 // connect, send query, get response
1533 if (!( $fp = $this->_Connect() ))
1534 return -1;
1535
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;
1540
1541 if (!( $response = $this->_GetResponse ( $fp, VER_COMMAND_UPDATE ) ))
1542 return -1;
1543
1544 // parse response
1545 list(,$updated) = unpack ( "N*", substr ( $response, 0, 4 ) );
1546 return $updated;
1547 }
1548
1549 /////////////////////////////////////////////////////////////////////////////
1550 // persistent connections
1551 /////////////////////////////////////////////////////////////////////////////
1552
1553 function Open()
1554 {
1555 if ( $this->_socket !== false )
1556 {
1557 $this->_error = 'already connected';
1558 return false;
1559 }
1560 if ( !$fp = $this->_Connect() )
1561 return false;
1562
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 return false;
1567
1568 $this->_socket = $fp;
1569 return true;
1570 }
1571
1572 function Close()
1573 {
1574 if ( $this->_socket === false )
1575 {
1576 $this->_error = 'not connected';
1577 return false;
1578 }
1579
1580 fclose ( $this->_socket );
1581 $this->_socket = false;
1582
1583 return true;
1584 }
1585
1586 //////////////////////////////////////////////////////////////////////////
1587 // status
1588 //////////////////////////////////////////////////////////////////////////
1589
1590 function Status ()
1591 {
1592 $this->_MBPush ();
1593 if (!( $fp = $this->_Connect() ))
1594 {
1595 $this->_MBPop();
1596 return false;
1597 }
1598
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 return false;
1605 }
1606
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;
1610
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 }
1618
1619 $this->_MBPop ();
1620 return $res;
1621 }
1622 }
1623
1624 //
1625 // $Id: sphinxapi.php 2055 2009-11-06 23:09:58Z shodan $
1626 //
web-based news feed (RSS/Atom) reader and aggregator; see https://tt-rss.org/