Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
0.00% |
0 / 52 |
CRAP | |
0.00% |
0 / 1141 |
| sphPackI64 | |
0.00% |
0 / 1 |
72.00 | |
0.00% |
0 / 36 |
|||
| sphPackU64 | |
0.00% |
0 / 1 |
42.00 | |
0.00% |
0 / 38 |
|||
| sphUnpackU64 | |
0.00% |
0 / 1 |
156.00 | |
0.00% |
0 / 46 |
|||
| sphUnpackI64 | |
0.00% |
0 / 1 |
156.00 | |
0.00% |
0 / 52 |
|||
| sphFixUint | |
0.00% |
0 / 1 |
12.00 | |
0.00% |
0 / 11 |
|||
| SphinxClient | |
0.00% |
0 / 1 |
|
0.00% |
0 / 47 |
49506.00 | |
0.00% |
0 / 899 |
| __construct | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 38 |
|||
| __destruct | |
0.00% |
0 / 1 |
6.00 | |
0.00% |
0 / 4 |
|||
| GetLastError | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 3 |
|||
| GetLastWarning | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 3 |
|||
| IsConnectError | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 3 |
|||
| SetServer | |
0.00% |
0 / 1 |
12.00 | |
0.00% |
0 / 17 |
|||
| SetConnectTimeout | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 4 |
|||
| _Send | |
0.00% |
0 / 1 |
12.00 | |
0.00% |
0 / 9 |
|||
| _MBPush | |
0.00% |
0 / 1 |
6.00 | |
0.00% |
0 / 8 |
|||
| _MBPop | |
0.00% |
0 / 1 |
6.00 | |
0.00% |
0 / 4 |
|||
| _Connect | |
0.00% |
0 / 1 |
90.00 | |
0.00% |
0 / 51 |
|||
| _GetResponse | |
0.00% |
0 / 1 |
210.00 | |
0.00% |
0 / 56 |
|||
| SetLimits | |
0.00% |
0 / 1 |
12.00 | |
0.00% |
0 / 13 |
|||
| SetMaxQueryTime | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 5 |
|||
| SetMatchMode | |
0.00% |
0 / 1 |
56.00 | |
0.00% |
0 / 10 |
|||
| SetRankingMode | |
0.00% |
0 / 1 |
6.00 | |
0.00% |
0 / 6 |
|||
| SetSortMode | |
0.00% |
0 / 1 |
56.00 | |
0.00% |
0 / 13 |
|||
| SetWeights | |
0.00% |
0 / 1 |
6.00 | |
0.00% |
0 / 6 |
|||
| SetFieldWeights | |
0.00% |
0 / 1 |
6.00 | |
0.00% |
0 / 9 |
|||
| SetIndexWeights | |
0.00% |
0 / 1 |
6.00 | |
0.00% |
0 / 9 |
|||
| SetIDRange | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 7 |
|||
| SetFilter | |
0.00% |
0 / 1 |
20.00 | |
0.00% |
0 / 11 |
|||
| SetFilterRange | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 7 |
|||
| SetFilterFloatRange | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 7 |
|||
| SetGeoAnchor | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 7 |
|||
| SetGroupBy | |
0.00% |
0 / 1 |
42.00 | |
0.00% |
0 / 13 |
|||
| SetGroupDistinct | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 4 |
|||
| SetRetries | |
0.00% |
0 / 1 |
12.00 | |
0.00% |
0 / 6 |
|||
| SetArrayResult | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 4 |
|||
| SetOverride | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 6 |
|||
| SetSelect | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 4 |
|||
| ResetFilters | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 4 |
|||
| ResetGroupBy | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 6 |
|||
| ResetOverrides | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 3 |
|||
| Query | |
0.00% |
0 / 1 |
12.00 | |
0.00% |
0 / 14 |
|||
| _PackFloat | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 5 |
|||
| AddQuery | |
0.00% |
0 / 1 |
272.00 | |
0.00% |
0 / 84 |
|||
| RunQueries | |
0.00% |
0 / 1 |
30.00 | |
0.00% |
0 / 25 |
|||
| _ParseSearchResponse | |
0.00% |
0 / 1 |
702.00 | |
0.00% |
0 / 133 |
|||
| BuildExcerpts | |
0.00% |
0 / 1 |
1482.00 | |
0.00% |
0 / 85 |
|||
| BuildKeywords | |
0.00% |
0 / 1 |
90.00 | |
0.00% |
0 / 52 |
|||
| EscapeString | |
0.00% |
0 / 1 |
2.00 | |
0.00% |
0 / 5 |
|||
| UpdateAttributes | |
0.00% |
0 / 1 |
272.00 | |
0.00% |
0 / 64 |
|||
| Open | |
0.00% |
0 / 1 |
20.00 | |
0.00% |
0 / 14 |
|||
| Close | |
0.00% |
0 / 1 |
6.00 | |
0.00% |
0 / 10 |
|||
| Status | |
0.00% |
0 / 1 |
42.00 | |
0.00% |
0 / 26 |
|||
| FlushAttributes | |
0.00% |
0 / 1 |
30.00 | |
0.00% |
0 / 22 |
|||
| <?php | |
| // | |
| // $Id: sphinxapi.php 3087 2012-01-30 23:07:35Z shodan $ | |
| // | |
| // | |
| // Copyright (c) 2001-2012, Andrew Aksyonoff | |
| // Copyright (c) 2008-2012, Sphinx Technologies Inc | |
| // All rights reserved | |
| // | |
| // This program is free software; you can redistribute it and/or modify | |
| // it under the terms of the GNU General Public License. You should have | |
| // received a copy of the GPL license along with this program; if you | |
| // did not, you can find it at http://www.gnu.org/ | |
| // | |
| ///////////////////////////////////////////////////////////////////////////// | |
| // PHP version of Sphinx searchd client (PHP API) | |
| ///////////////////////////////////////////////////////////////////////////// | |
| /// known searchd commands | |
| define ( "SEARCHD_COMMAND_SEARCH", 0 ); | |
| define ( "SEARCHD_COMMAND_EXCERPT", 1 ); | |
| define ( "SEARCHD_COMMAND_UPDATE", 2 ); | |
| define ( "SEARCHD_COMMAND_KEYWORDS", 3 ); | |
| define ( "SEARCHD_COMMAND_PERSIST", 4 ); | |
| define ( "SEARCHD_COMMAND_STATUS", 5 ); | |
| define ( "SEARCHD_COMMAND_FLUSHATTRS", 7 ); | |
| /// current client-side command implementation versions | |
| define ( "VER_COMMAND_SEARCH", 0x119 ); | |
| define ( "VER_COMMAND_EXCERPT", 0x104 ); | |
| define ( "VER_COMMAND_UPDATE", 0x102 ); | |
| define ( "VER_COMMAND_KEYWORDS", 0x100 ); | |
| define ( "VER_COMMAND_STATUS", 0x100 ); | |
| define ( "VER_COMMAND_QUERY", 0x100 ); | |
| define ( "VER_COMMAND_FLUSHATTRS", 0x100 ); | |
| /// known searchd status codes | |
| define ( "SEARCHD_OK", 0 ); | |
| define ( "SEARCHD_ERROR", 1 ); | |
| define ( "SEARCHD_RETRY", 2 ); | |
| define ( "SEARCHD_WARNING", 3 ); | |
| /// known match modes | |
| define ( "SPH_MATCH_ALL", 0 ); | |
| define ( "SPH_MATCH_ANY", 1 ); | |
| define ( "SPH_MATCH_PHRASE", 2 ); | |
| define ( "SPH_MATCH_BOOLEAN", 3 ); | |
| define ( "SPH_MATCH_EXTENDED", 4 ); | |
| define ( "SPH_MATCH_FULLSCAN", 5 ); | |
| define ( "SPH_MATCH_EXTENDED2", 6 ); // extended engine V2 (TEMPORARY, WILL BE REMOVED) | |
| /// known ranking modes (ext2 only) | |
| define ( "SPH_RANK_PROXIMITY_BM25", 0 ); ///< default mode, phrase proximity major factor and BM25 minor one | |
| define ( "SPH_RANK_BM25", 1 ); ///< statistical mode, BM25 ranking only (faster but worse quality) | |
| define ( "SPH_RANK_NONE", 2 ); ///< no ranking, all matches get a weight of 1 | |
| define ( "SPH_RANK_WORDCOUNT", 3 ); ///< simple word-count weighting, rank is a weighted sum of per-field keyword occurence counts | |
| define ( "SPH_RANK_PROXIMITY", 4 ); | |
| define ( "SPH_RANK_MATCHANY", 5 ); | |
| define ( "SPH_RANK_FIELDMASK", 6 ); | |
| define ( "SPH_RANK_SPH04", 7 ); | |
| define ( "SPH_RANK_EXPR", 8 ); | |
| define ( "SPH_RANK_TOTAL", 9 ); | |
| /// known sort modes | |
| define ( "SPH_SORT_RELEVANCE", 0 ); | |
| define ( "SPH_SORT_ATTR_DESC", 1 ); | |
| define ( "SPH_SORT_ATTR_ASC", 2 ); | |
| define ( "SPH_SORT_TIME_SEGMENTS", 3 ); | |
| define ( "SPH_SORT_EXTENDED", 4 ); | |
| define ( "SPH_SORT_EXPR", 5 ); | |
| /// known filter types | |
| define ( "SPH_FILTER_VALUES", 0 ); | |
| define ( "SPH_FILTER_RANGE", 1 ); | |
| define ( "SPH_FILTER_FLOATRANGE", 2 ); | |
| /// known attribute types | |
| define ( "SPH_ATTR_INTEGER", 1 ); | |
| define ( "SPH_ATTR_TIMESTAMP", 2 ); | |
| define ( "SPH_ATTR_ORDINAL", 3 ); | |
| define ( "SPH_ATTR_BOOL", 4 ); | |
| define ( "SPH_ATTR_FLOAT", 5 ); | |
| define ( "SPH_ATTR_BIGINT", 6 ); | |
| define ( "SPH_ATTR_STRING", 7 ); | |
| define ( "SPH_ATTR_MULTI", 0x40000001 ); | |
| define ( "SPH_ATTR_MULTI64", 0x40000002 ); | |
| /// known grouping functions | |
| define ( "SPH_GROUPBY_DAY", 0 ); | |
| define ( "SPH_GROUPBY_WEEK", 1 ); | |
| define ( "SPH_GROUPBY_MONTH", 2 ); | |
| define ( "SPH_GROUPBY_YEAR", 3 ); | |
| define ( "SPH_GROUPBY_ATTR", 4 ); | |
| define ( "SPH_GROUPBY_ATTRPAIR", 5 ); | |
| // important properties of PHP's integers: | |
| // - always signed (one bit short of PHP_INT_SIZE) | |
| // - conversion from string to int is saturated | |
| // - float is double | |
| // - div converts arguments to floats | |
| // - mod converts arguments to ints | |
| // the packing code below works as follows: | |
| // - when we got an int, just pack it | |
| // if performance is a problem, this is the branch users should aim for | |
| // | |
| // - otherwise, we got a number in string form | |
| // this might be due to different reasons, but we assume that this is | |
| // because it didn't fit into PHP int | |
| // | |
| // - factor the string into high and low ints for packing | |
| // - if we have bcmath, then it is used | |
| // - if we don't, we have to do it manually (this is the fun part) | |
| // | |
| // - x64 branch does factoring using ints | |
| // - x32 (ab)uses floats, since we can't fit unsigned 32-bit number into an int | |
| // | |
| // unpacking routines are pretty much the same. | |
| // - return ints if we can | |
| // - otherwise format number into a string | |
| /// pack 64-bit signed | |
| function sphPackI64 ( $v ) | |
| { | |
| assert ( is_numeric($v) ); | |
| // x64 | |
| if ( PHP_INT_SIZE>=8 ) | |
| { | |
| $v = (int)$v; | |
| return pack ( "NN", $v>>32, $v&0xFFFFFFFF ); | |
| } | |
| // x32, int | |
| if ( is_int($v) ) | |
| return pack ( "NN", $v < 0 ? -1 : 0, $v ); | |
| // x32, bcmath | |
| if ( function_exists("bcmul") ) | |
| { | |
| if ( bccomp ( $v, 0 ) == -1 ) | |
| $v = bcadd ( "18446744073709551616", $v ); | |
| $h = bcdiv ( $v, "4294967296", 0 ); | |
| $l = bcmod ( $v, "4294967296" ); | |
| return pack ( "NN", (float)$h, (float)$l ); // conversion to float is intentional; int would lose 31st bit | |
| } | |
| // x32, no-bcmath | |
| $p = max(0, strlen($v) - 13); | |
| $lo = abs((float)substr($v, $p)); | |
| $hi = abs((float)substr($v, 0, $p)); | |
| $m = $lo + $hi*1316134912.0; // (10 ^ 13) % (1 << 32) = 1316134912 | |
| $q = floor($m/4294967296.0); | |
| $l = $m - ($q*4294967296.0); | |
| $h = $hi*2328.0 + $q; // (10 ^ 13) / (1 << 32) = 2328 | |
| if ( $v<0 ) | |
| { | |
| if ( $l==0 ) | |
| $h = 4294967296.0 - $h; | |
| else | |
| { | |
| $h = 4294967295.0 - $h; | |
| $l = 4294967296.0 - $l; | |
| } | |
| } | |
| return pack ( "NN", $h, $l ); | |
| } | |
| /// pack 64-bit unsigned | |
| function sphPackU64 ( $v ) | |
| { | |
| assert ( is_numeric($v) ); | |
| // x64 | |
| if ( PHP_INT_SIZE>=8 ) | |
| { | |
| assert ( $v>=0 ); | |
| // x64, int | |
| if ( is_int($v) ) | |
| return pack ( "NN", $v>>32, $v&0xFFFFFFFF ); | |
| // x64, bcmath | |
| if ( function_exists("bcmul") ) | |
| { | |
| $h = bcdiv ( $v, 4294967296, 0 ); | |
| $l = bcmod ( $v, 4294967296 ); | |
| return pack ( "NN", $h, $l ); | |
| } | |
| // x64, no-bcmath | |
| $p = max ( 0, strlen($v) - 13 ); | |
| $lo = (int)substr ( $v, $p ); | |
| $hi = (int)substr ( $v, 0, $p ); | |
| $m = $lo + $hi*1316134912; | |
| $l = $m % 4294967296; | |
| $h = $hi*2328 + (int)($m/4294967296); | |
| return pack ( "NN", $h, $l ); | |
| } | |
| // x32, int | |
| if ( is_int($v) ) | |
| return pack ( "NN", 0, $v ); | |
| // x32, bcmath | |
| if ( function_exists("bcmul") ) | |
| { | |
| $h = bcdiv ( $v, "4294967296", 0 ); | |
| $l = bcmod ( $v, "4294967296" ); | |
| return pack ( "NN", (float)$h, (float)$l ); // conversion to float is intentional; int would lose 31st bit | |
| } | |
| // x32, no-bcmath | |
| $p = max(0, strlen($v) - 13); | |
| $lo = (float)substr($v, $p); | |
| $hi = (float)substr($v, 0, $p); | |
| $m = $lo + $hi*1316134912.0; | |
| $q = floor($m / 4294967296.0); | |
| $l = $m - ($q * 4294967296.0); | |
| $h = $hi*2328.0 + $q; | |
| return pack ( "NN", $h, $l ); | |
| } | |
| // unpack 64-bit unsigned | |
| function sphUnpackU64 ( $v ) | |
| { | |
| list ( $hi, $lo ) = array_values ( unpack ( "N*N*", $v ) ); | |
| if ( PHP_INT_SIZE>=8 ) | |
| { | |
| if ( $hi<0 ) $hi += (1<<32); // because php 5.2.2 to 5.2.5 is totally fucked up again | |
| if ( $lo<0 ) $lo += (1<<32); | |
| // x64, int | |
| if ( $hi<=2147483647 ) | |
| return ($hi<<32) + $lo; | |
| // x64, bcmath | |
| if ( function_exists("bcmul") ) | |
| return bcadd ( $lo, bcmul ( $hi, "4294967296" ) ); | |
| // x64, no-bcmath | |
| $C = 100000; | |
| $h = ((int)($hi / $C) << 32) + (int)($lo / $C); | |
| $l = (($hi % $C) << 32) + ($lo % $C); | |
| if ( $l>$C ) | |
| { | |
| $h += (int)($l / $C); | |
| $l = $l % $C; | |
| } | |
| if ( $h==0 ) | |
| return $l; | |
| return sprintf ( "%d%05d", $h, $l ); | |
| } | |
| // x32, int | |
| if ( $hi==0 ) | |
| { | |
| if ( $lo>0 ) | |
| return $lo; | |
| return sprintf ( "%u", $lo ); | |
| } | |
| $hi = sprintf ( "%u", $hi ); | |
| $lo = sprintf ( "%u", $lo ); | |
| // x32, bcmath | |
| if ( function_exists("bcmul") ) | |
| return bcadd ( $lo, bcmul ( $hi, "4294967296" ) ); | |
| // x32, no-bcmath | |
| $hi = (float)$hi; | |
| $lo = (float)$lo; | |
| $q = floor($hi/10000000.0); | |
| $r = $hi - $q*10000000.0; | |
| $m = $lo + $r*4967296.0; | |
| $mq = floor($m/10000000.0); | |
| $l = $m - $mq*10000000.0; | |
| $h = $q*4294967296.0 + $r*429.0 + $mq; | |
| $h = sprintf ( "%.0f", $h ); | |
| $l = sprintf ( "%07.0f", $l ); | |
| if ( $h=="0" ) | |
| return sprintf( "%.0f", (float)$l ); | |
| return $h . $l; | |
| } | |
| // unpack 64-bit signed | |
| function sphUnpackI64 ( $v ) | |
| { | |
| list ( $hi, $lo ) = array_values ( unpack ( "N*N*", $v ) ); | |
| // x64 | |
| if ( PHP_INT_SIZE>=8 ) | |
| { | |
| if ( $hi<0 ) $hi += (1<<32); // because php 5.2.2 to 5.2.5 is totally fucked up again | |
| if ( $lo<0 ) $lo += (1<<32); | |
| return ($hi<<32) + $lo; | |
| } | |
| // x32, int | |
| if ( $hi==0 ) | |
| { | |
| if ( $lo>0 ) | |
| return $lo; | |
| return sprintf ( "%u", $lo ); | |
| } | |
| // x32, int | |
| elseif ( $hi==-1 ) | |
| { | |
| if ( $lo<0 ) | |
| return $lo; | |
| return sprintf ( "%.0f", $lo - 4294967296.0 ); | |
| } | |
| $neg = ""; | |
| $c = 0; | |
| if ( $hi<0 ) | |
| { | |
| $hi = ~$hi; | |
| $lo = ~$lo; | |
| $c = 1; | |
| $neg = "-"; | |
| } | |
| $hi = sprintf ( "%u", $hi ); | |
| $lo = sprintf ( "%u", $lo ); | |
| // x32, bcmath | |
| if ( function_exists("bcmul") ) | |
| return $neg . bcadd ( bcadd ( $lo, bcmul ( $hi, "4294967296" ) ), $c ); | |
| // x32, no-bcmath | |
| $hi = (float)$hi; | |
| $lo = (float)$lo; | |
| $q = floor($hi/10000000.0); | |
| $r = $hi - $q*10000000.0; | |
| $m = $lo + $r*4967296.0; | |
| $mq = floor($m/10000000.0); | |
| $l = $m - $mq*10000000.0 + $c; | |
| $h = $q*4294967296.0 + $r*429.0 + $mq; | |
| if ( $l==10000000 ) | |
| { | |
| $l = 0; | |
| $h += 1; | |
| } | |
| $h = sprintf ( "%.0f", $h ); | |
| $l = sprintf ( "%07.0f", $l ); | |
| if ( $h=="0" ) | |
| return $neg . sprintf( "%.0f", (float)$l ); | |
| return $neg . $h . $l; | |
| } | |
| function sphFixUint ( $value ) | |
| { | |
| if ( PHP_INT_SIZE>=8 ) | |
| { | |
| // x64 route, workaround broken unpack() in 5.2.2+ | |
| if ( $value<0 ) $value += (1<<32); | |
| return $value; | |
| } | |
| else | |
| { | |
| // x32 route, workaround php signed/unsigned braindamage | |
| return sprintf ( "%u", $value ); | |
| } | |
| } | |
| /// sphinx searchd client class | |
| class SphinxClient | |
| { | |
| var $_host; ///< searchd host (default is "localhost") | |
| var $_port; ///< searchd port (default is 9312) | |
| var $_offset; ///< how many records to seek from result-set start (default is 0) | |
| var $_limit; ///< how many records to return from result-set starting at offset (default is 20) | |
| var $_mode; ///< query matching mode (default is SPH_MATCH_ALL) | |
| var $_weights; ///< per-field weights (default is 1 for all fields) | |
| var $_sort; ///< match sorting mode (default is SPH_SORT_RELEVANCE) | |
| var $_sortby; ///< attribute to sort by (defualt is "") | |
| var $_min_id; ///< min ID to match (default is 0, which means no limit) | |
| var $_max_id; ///< max ID to match (default is 0, which means no limit) | |
| var $_filters; ///< search filters | |
| var $_groupby; ///< group-by attribute name | |
| var $_groupfunc; ///< group-by function (to pre-process group-by attribute value with) | |
| var $_groupsort; ///< group-by sorting clause (to sort groups in result set with) | |
| var $_groupdistinct;///< group-by count-distinct attribute | |
| var $_maxmatches; ///< max matches to retrieve | |
| var $_cutoff; ///< cutoff to stop searching at (default is 0) | |
| var $_retrycount; ///< distributed retries count | |
| var $_retrydelay; ///< distributed retries delay | |
| var $_anchor; ///< geographical anchor point | |
| var $_indexweights; ///< per-index weights | |
| var $_ranker; ///< ranking mode (default is SPH_RANK_PROXIMITY_BM25) | |
| var $_rankexpr; ///< ranking mode expression (for SPH_RANK_EXPR) | |
| var $_maxquerytime; ///< max query time, milliseconds (default is 0, do not limit) | |
| var $_fieldweights; ///< per-field-name weights | |
| var $_overrides; ///< per-query attribute values overrides | |
| var $_select; ///< select-list (attributes or expressions, with optional aliases) | |
| var $_error; ///< last error message | |
| var $_warning; ///< last warning message | |
| var $_connerror; ///< connection error vs remote error flag | |
| var $_reqs; ///< requests array for multi-query | |
| var $_mbenc; ///< stored mbstring encoding | |
| var $_arrayresult; ///< whether $result["matches"] should be a hash or an array | |
| var $_timeout; ///< connect timeout | |
| ///////////////////////////////////////////////////////////////////////////// | |
| // common stuff | |
| ///////////////////////////////////////////////////////////////////////////// | |
| /// create a new client object and fill defaults | |
| function __construct () | |
| { | |
| // per-client-object settings | |
| $this->_host = "localhost"; | |
| $this->_port = 9312; | |
| $this->_path = false; | |
| $this->_socket = false; | |
| // per-query settings | |
| $this->_offset = 0; | |
| $this->_limit = 20; | |
| $this->_mode = SPH_MATCH_ALL; | |
| $this->_weights = array (); | |
| $this->_sort = SPH_SORT_RELEVANCE; | |
| $this->_sortby = ""; | |
| $this->_min_id = 0; | |
| $this->_max_id = 0; | |
| $this->_filters = array (); | |
| $this->_groupby = ""; | |
| $this->_groupfunc = SPH_GROUPBY_DAY; | |
| $this->_groupsort = "@group desc"; | |
| $this->_groupdistinct= ""; | |
| $this->_maxmatches = 1000; | |
| $this->_cutoff = 0; | |
| $this->_retrycount = 0; | |
| $this->_retrydelay = 0; | |
| $this->_anchor = array (); | |
| $this->_indexweights= array (); | |
| $this->_ranker = SPH_RANK_PROXIMITY_BM25; | |
| $this->_rankexpr = ""; | |
| $this->_maxquerytime= 0; | |
| $this->_fieldweights= array(); | |
| $this->_overrides = array(); | |
| $this->_select = "*"; | |
| $this->_error = ""; // per-reply fields (for single-query case) | |
| $this->_warning = ""; | |
| $this->_connerror = false; | |
| $this->_reqs = array (); // requests storage (for multi-query case) | |
| $this->_mbenc = ""; | |
| $this->_arrayresult = false; | |
| $this->_timeout = 0; | |
| } | |
| function __destruct() | |
| { | |
| if ( $this->_socket !== false ) | |
| fclose ( $this->_socket ); | |
| } | |
| /// get last error message (string) | |
| function GetLastError () | |
| { | |
| return $this->_error; | |
| } | |
| /// get last warning message (string) | |
| function GetLastWarning () | |
| { | |
| return $this->_warning; | |
| } | |
| /// get last error flag (to tell network connection errors from searchd errors or broken responses) | |
| function IsConnectError() | |
| { | |
| return $this->_connerror; | |
| } | |
| /// set searchd host name (string) and port (integer) | |
| function SetServer ( $host, $port = 0 ) | |
| { | |
| assert ( is_string($host) ); | |
| if ( $host[0] == '/') | |
| { | |
| $this->_path = 'unix://' . $host; | |
| return; | |
| } | |
| if ( substr ( $host, 0, 7 )=="unix://" ) | |
| { | |
| $this->_path = $host; | |
| return; | |
| } | |
| assert ( is_int($port) ); | |
| $this->_host = $host; | |
| $this->_port = $port; | |
| $this->_path = ''; | |
| } | |
| /// set server connection timeout (0 to remove) | |
| function SetConnectTimeout ( $timeout ) | |
| { | |
| assert ( is_numeric($timeout) ); | |
| $this->_timeout = $timeout; | |
| } | |
| function _Send ( $handle, $data, $length ) | |
| { | |
| if ( feof($handle) || fwrite ( $handle, $data, $length ) !== $length ) | |
| { | |
| $this->_error = 'connection unexpectedly closed (timed out?)'; | |
| $this->_connerror = true; | |
| return false; | |
| } | |
| return true; | |
| } | |
| ///////////////////////////////////////////////////////////////////////////// | |
| /// enter mbstring workaround mode | |
| function _MBPush () | |
| { | |
| $this->_mbenc = ""; | |
| if ( ini_get ( "mbstring.func_overload" ) & 2 ) | |
| { | |
| $this->_mbenc = mb_internal_encoding(); | |
| mb_internal_encoding ( "latin1" ); | |
| } | |
| } | |
| /// leave mbstring workaround mode | |
| function _MBPop () | |
| { | |
| if ( $this->_mbenc ) | |
| mb_internal_encoding ( $this->_mbenc ); | |
| } | |
| /// connect to searchd server | |
| function _Connect () | |
| { | |
| if ( $this->_socket!==false ) | |
| { | |
| // we are in persistent connection mode, so we have a socket | |
| // however, need to check whether it's still alive | |
| if ( !@feof ( $this->_socket ) ) | |
| return $this->_socket; | |
| // force reopen | |
| $this->_socket = false; | |
| } | |
| $errno = 0; | |
| $errstr = ""; | |
| $this->_connerror = false; | |
| if ( $this->_path ) | |
| { | |
| $host = $this->_path; | |
| $port = 0; | |
| } | |
| else | |
| { | |
| $host = $this->_host; | |
| $port = $this->_port; | |
| } | |
| if ( $this->_timeout<=0 ) | |
| $fp = @fsockopen ( $host, $port, $errno, $errstr ); | |
| else | |
| $fp = @fsockopen ( $host, $port, $errno, $errstr, $this->_timeout ); | |
| if ( !$fp ) | |
| { | |
| if ( $this->_path ) | |
| $location = $this->_path; | |
| else | |
| $location = "{$this->_host}:{$this->_port}"; | |
| $errstr = trim ( $errstr ); | |
| $this->_error = "connection to $location failed (errno=$errno, msg=$errstr)"; | |
| $this->_connerror = true; | |
| return false; | |
| } | |
| // send my version | |
| // this is a subtle part. we must do it before (!) reading back from searchd. | |
| // because otherwise under some conditions (reported on FreeBSD for instance) | |
| // TCP stack could throttle write-write-read pattern because of Nagle. | |
| if ( !$this->_Send ( $fp, pack ( "N", 1 ), 4 ) ) | |
| { | |
| fclose ( $fp ); | |
| $this->_error = "failed to send client protocol version"; | |
| return false; | |
| } | |
| // check version | |
| list(,$v) = unpack ( "N*", fread ( $fp, 4 ) ); | |
| $v = (int)$v; | |
| if ( $v<1 ) | |
| { | |
| fclose ( $fp ); | |
| $this->_error = "expected searchd protocol version 1+, got version '$v'"; | |
| return false; | |
| } | |
| return $fp; | |
| } | |
| /// get and check response packet from searchd server | |
| function _GetResponse ( $fp, $client_ver ) | |
| { | |
| $response = ""; | |
| $len = 0; | |
| $header = fread ( $fp, 8 ); | |
| if ( strlen($header)==8 ) | |
| { | |
| list ( $status, $ver, $len ) = array_values ( unpack ( "n2a/Nb", $header ) ); | |
| $left = $len; | |
| while ( $left>0 && !feof($fp) ) | |
| { | |
| $chunk = fread ( $fp, min ( 8192, $left ) ); | |
| if ( $chunk ) | |
| { | |
| $response .= $chunk; | |
| $left -= strlen($chunk); | |
| } | |
| } | |
| } | |
| if ( $this->_socket === false ) | |
| fclose ( $fp ); | |
| // check response | |
| $read = strlen ( $response ); | |
| if ( !$response || $read!=$len ) | |
| { | |
| $this->_error = $len | |
| ? "failed to read searchd response (status=$status, ver=$ver, len=$len, read=$read)" | |
| : "received zero-sized searchd response"; | |
| return false; | |
| } | |
| // check status | |
| if ( $status==SEARCHD_WARNING ) | |
| { | |
| list(,$wlen) = unpack ( "N*", substr ( $response, 0, 4 ) ); | |
| $this->_warning = substr ( $response, 4, $wlen ); | |
| return substr ( $response, 4+$wlen ); | |
| } | |
| if ( $status==SEARCHD_ERROR ) | |
| { | |
| $this->_error = "searchd error: " . substr ( $response, 4 ); | |
| return false; | |
| } | |
| if ( $status==SEARCHD_RETRY ) | |
| { | |
| $this->_error = "temporary searchd error: " . substr ( $response, 4 ); | |
| return false; | |
| } | |
| if ( $status!=SEARCHD_OK ) | |
| { | |
| $this->_error = "unknown status code '$status'"; | |
| return false; | |
| } | |
| // check version | |
| if ( $ver<$client_ver ) | |
| { | |
| $this->_warning = sprintf ( "searchd command v.%d.%d older than client's v.%d.%d, some options might not work", | |
| $ver>>8, $ver&0xff, $client_ver>>8, $client_ver&0xff ); | |
| } | |
| return $response; | |
| } | |
| ///////////////////////////////////////////////////////////////////////////// | |
| // searching | |
| ///////////////////////////////////////////////////////////////////////////// | |
| /// set offset and count into result set, | |
| /// and optionally set max-matches and cutoff limits | |
| function SetLimits ( $offset, $limit, $max=0, $cutoff=0 ) | |
| { | |
| assert ( is_int($offset) ); | |
| assert ( is_int($limit) ); | |
| assert ( $offset>=0 ); | |
| assert ( $limit>0 ); | |
| assert ( $max>=0 ); | |
| $this->_offset = $offset; | |
| $this->_limit = $limit; | |
| if ( $max>0 ) | |
| $this->_maxmatches = $max; | |
| if ( $cutoff>0 ) | |
| $this->_cutoff = $cutoff; | |
| } | |
| /// set maximum query time, in milliseconds, per-index | |
| /// integer, 0 means "do not limit" | |
| function SetMaxQueryTime ( $max ) | |
| { | |
| assert ( is_int($max) ); | |
| assert ( $max>=0 ); | |
| $this->_maxquerytime = $max; | |
| } | |
| /// set matching mode | |
| function SetMatchMode ( $mode ) | |
| { | |
| assert ( $mode==SPH_MATCH_ALL | |
| || $mode==SPH_MATCH_ANY | |
| || $mode==SPH_MATCH_PHRASE | |
| || $mode==SPH_MATCH_BOOLEAN | |
| || $mode==SPH_MATCH_EXTENDED | |
| || $mode==SPH_MATCH_FULLSCAN | |
| || $mode==SPH_MATCH_EXTENDED2 ); | |
| $this->_mode = $mode; | |
| } | |
| /// set ranking mode | |
| function SetRankingMode ( $ranker, $rankexpr="" ) | |
| { | |
| assert ( $ranker>=0 && $ranker<SPH_RANK_TOTAL ); | |
| assert ( is_string($rankexpr) ); | |
| $this->_ranker = $ranker; | |
| $this->_rankexpr = $rankexpr; | |
| } | |
| /// set matches sorting mode | |
| function SetSortMode ( $mode, $sortby="" ) | |
| { | |
| assert ( | |
| $mode==SPH_SORT_RELEVANCE || | |
| $mode==SPH_SORT_ATTR_DESC || | |
| $mode==SPH_SORT_ATTR_ASC || | |
| $mode==SPH_SORT_TIME_SEGMENTS || | |
| $mode==SPH_SORT_EXTENDED || | |
| $mode==SPH_SORT_EXPR ); | |
| assert ( is_string($sortby) ); | |
| assert ( $mode==SPH_SORT_RELEVANCE || strlen($sortby)>0 ); | |
| $this->_sort = $mode; | |
| $this->_sortby = $sortby; | |
| } | |
| /// bind per-field weights by order | |
| /// DEPRECATED; use SetFieldWeights() instead | |
| function SetWeights ( $weights ) | |
| { | |
| assert ( is_array($weights) ); | |
| foreach ( $weights as $weight ) | |
| assert ( is_int($weight) ); | |
| $this->_weights = $weights; | |
| } | |
| /// bind per-field weights by name | |
| function SetFieldWeights ( $weights ) | |
| { | |
| assert ( is_array($weights) ); | |
| foreach ( $weights as $name=>$weight ) | |
| { | |
| assert ( is_string($name) ); | |
| assert ( is_int($weight) ); | |
| } | |
| $this->_fieldweights = $weights; | |
| } | |
| /// bind per-index weights by name | |
| function SetIndexWeights ( $weights ) | |
| { | |
| assert ( is_array($weights) ); | |
| foreach ( $weights as $index=>$weight ) | |
| { | |
| assert ( is_string($index) ); | |
| assert ( is_int($weight) ); | |
| } | |
| $this->_indexweights = $weights; | |
| } | |
| /// set IDs range to match | |
| /// only match records if document ID is beetwen $min and $max (inclusive) | |
| function SetIDRange ( $min, $max ) | |
| { | |
| assert ( is_numeric($min) ); | |
| assert ( is_numeric($max) ); | |
| assert ( $min<=$max ); | |
| $this->_min_id = $min; | |
| $this->_max_id = $max; | |
| } | |
| /// set values set filter | |
| /// only match records where $attribute value is in given set | |
| function SetFilter ( $attribute, $values, $exclude=false ) | |
| { | |
| assert ( is_string($attribute) ); | |
| assert ( is_array($values) ); | |
| assert ( count($values) ); | |
| if ( is_array($values) && count($values) ) | |
| { | |
| foreach ( $values as $value ) | |
| assert ( is_numeric($value) ); | |
| $this->_filters[] = array ( "type"=>SPH_FILTER_VALUES, "attr"=>$attribute, "exclude"=>$exclude, "values"=>$values ); | |
| } | |
| } | |
| /// set range filter | |
| /// only match records if $attribute value is beetwen $min and $max (inclusive) | |
| function SetFilterRange ( $attribute, $min, $max, $exclude=false ) | |
| { | |
| assert ( is_string($attribute) ); | |
| assert ( is_numeric($min) ); | |
| assert ( is_numeric($max) ); | |
| assert ( $min<=$max ); | |
| $this->_filters[] = array ( "type"=>SPH_FILTER_RANGE, "attr"=>$attribute, "exclude"=>$exclude, "min"=>$min, "max"=>$max ); | |
| } | |
| /// set float range filter | |
| /// only match records if $attribute value is beetwen $min and $max (inclusive) | |
| function SetFilterFloatRange ( $attribute, $min, $max, $exclude=false ) | |
| { | |
| assert ( is_string($attribute) ); | |
| assert ( is_float($min) ); | |
| assert ( is_float($max) ); | |
| assert ( $min<=$max ); | |
| $this->_filters[] = array ( "type"=>SPH_FILTER_FLOATRANGE, "attr"=>$attribute, "exclude"=>$exclude, "min"=>$min, "max"=>$max ); | |
| } | |
| /// setup anchor point for geosphere distance calculations | |
| /// required to use @geodist in filters and sorting | |
| /// latitude and longitude must be in radians | |
| function SetGeoAnchor ( $attrlat, $attrlong, $lat, $long ) | |
| { | |
| assert ( is_string($attrlat) ); | |
| assert ( is_string($attrlong) ); | |
| assert ( is_float($lat) ); | |
| assert ( is_float($long) ); | |
| $this->_anchor = array ( "attrlat"=>$attrlat, "attrlong"=>$attrlong, "lat"=>$lat, "long"=>$long ); | |
| } | |
| /// set grouping attribute and function | |
| function SetGroupBy ( $attribute, $func, $groupsort="@group desc" ) | |
| { | |
| assert ( is_string($attribute) ); | |
| assert ( is_string($groupsort) ); | |
| assert ( $func==SPH_GROUPBY_DAY | |
| || $func==SPH_GROUPBY_WEEK | |
| || $func==SPH_GROUPBY_MONTH | |
| || $func==SPH_GROUPBY_YEAR | |
| || $func==SPH_GROUPBY_ATTR | |
| || $func==SPH_GROUPBY_ATTRPAIR ); | |
| $this->_groupby = $attribute; | |
| $this->_groupfunc = $func; | |
| $this->_groupsort = $groupsort; | |
| } | |
| /// set count-distinct attribute for group-by queries | |
| function SetGroupDistinct ( $attribute ) | |
| { | |
| assert ( is_string($attribute) ); | |
| $this->_groupdistinct = $attribute; | |
| } | |
| /// set distributed retries count and delay | |
| function SetRetries ( $count, $delay=0 ) | |
| { | |
| assert ( is_int($count) && $count>=0 ); | |
| assert ( is_int($delay) && $delay>=0 ); | |
| $this->_retrycount = $count; | |
| $this->_retrydelay = $delay; | |
| } | |
| /// set result set format (hash or array; hash by default) | |
| /// PHP specific; needed for group-by-MVA result sets that may contain duplicate IDs | |
| function SetArrayResult ( $arrayresult ) | |
| { | |
| assert ( is_bool($arrayresult) ); | |
| $this->_arrayresult = $arrayresult; | |
| } | |
| /// set attribute values override | |
| /// there can be only one override per attribute | |
| /// $values must be a hash that maps document IDs to attribute values | |
| function SetOverride ( $attrname, $attrtype, $values ) | |
| { | |
| assert ( is_string ( $attrname ) ); | |
| assert ( in_array ( $attrtype, array ( SPH_ATTR_INTEGER, SPH_ATTR_TIMESTAMP, SPH_ATTR_BOOL, SPH_ATTR_FLOAT, SPH_ATTR_BIGINT ) ) ); | |
| assert ( is_array ( $values ) ); | |
| $this->_overrides[$attrname] = array ( "attr"=>$attrname, "type"=>$attrtype, "values"=>$values ); | |
| } | |
| /// set select-list (attributes or expressions), SQL-like syntax | |
| function SetSelect ( $select ) | |
| { | |
| assert ( is_string ( $select ) ); | |
| $this->_select = $select; | |
| } | |
| ////////////////////////////////////////////////////////////////////////////// | |
| /// clear all filters (for multi-queries) | |
| function ResetFilters () | |
| { | |
| $this->_filters = array(); | |
| $this->_anchor = array(); | |
| } | |
| /// clear groupby settings (for multi-queries) | |
| function ResetGroupBy () | |
| { | |
| $this->_groupby = ""; | |
| $this->_groupfunc = SPH_GROUPBY_DAY; | |
| $this->_groupsort = "@group desc"; | |
| $this->_groupdistinct= ""; | |
| } | |
| /// clear all attribute value overrides (for multi-queries) | |
| function ResetOverrides () | |
| { | |
| $this->_overrides = array (); | |
| } | |
| ////////////////////////////////////////////////////////////////////////////// | |
| /// connect to searchd server, run given search query through given indexes, | |
| /// and return the search results | |
| function Query ( $query, $index="*", $comment="" ) | |
| { | |
| assert ( empty($this->_reqs) ); | |
| $this->AddQuery ( $query, $index, $comment ); | |
| $results = $this->RunQueries (); | |
| $this->_reqs = array (); // just in case it failed too early | |
| if ( !is_array($results) ) | |
| return false; // probably network error; error message should be already filled | |
| $this->_error = $results[0]["error"]; | |
| $this->_warning = $results[0]["warning"]; | |
| if ( $results[0]["status"]==SEARCHD_ERROR ) | |
| return false; | |
| else | |
| return $results[0]; | |
| } | |
| /// helper to pack floats in network byte order | |
| function _PackFloat ( $f ) | |
| { | |
| $t1 = pack ( "f", $f ); // machine order | |
| list(,$t2) = unpack ( "L*", $t1 ); // int in machine order | |
| return pack ( "N", $t2 ); | |
| } | |
| /// add query to multi-query batch | |
| /// returns index into results array from RunQueries() call | |
| function AddQuery ( $query, $index="*", $comment="" ) | |
| { | |
| // mbstring workaround | |
| $this->_MBPush (); | |
| // build request | |
| $req = pack ( "NNNN", $this->_offset, $this->_limit, $this->_mode, $this->_ranker ); | |
| if ( $this->_ranker==SPH_RANK_EXPR ) | |
| $req .= pack ( "N", strlen($this->_rankexpr) ) . $this->_rankexpr; | |
| $req .= pack ( "N", $this->_sort ); // (deprecated) sort mode | |
| $req .= pack ( "N", strlen($this->_sortby) ) . $this->_sortby; | |
| $req .= pack ( "N", strlen($query) ) . $query; // query itself | |
| $req .= pack ( "N", count($this->_weights) ); // weights | |
| foreach ( $this->_weights as $weight ) | |
| $req .= pack ( "N", (int)$weight ); | |
| $req .= pack ( "N", strlen($index) ) . $index; // indexes | |
| $req .= pack ( "N", 1 ); // id64 range marker | |
| $req .= sphPackU64 ( $this->_min_id ) . sphPackU64 ( $this->_max_id ); // id64 range | |
| // filters | |
| $req .= pack ( "N", count($this->_filters) ); | |
| foreach ( $this->_filters as $filter ) | |
| { | |
| $req .= pack ( "N", strlen($filter["attr"]) ) . $filter["attr"]; | |
| $req .= pack ( "N", $filter["type"] ); | |
| switch ( $filter["type"] ) | |
| { | |
| case SPH_FILTER_VALUES: | |
| $req .= pack ( "N", count($filter["values"]) ); | |
| foreach ( $filter["values"] as $value ) | |
| $req .= sphPackI64 ( $value ); | |
| break; | |
| case SPH_FILTER_RANGE: | |
| $req .= sphPackI64 ( $filter["min"] ) . sphPackI64 ( $filter["max"] ); | |
| break; | |
| case SPH_FILTER_FLOATRANGE: | |
| $req .= $this->_PackFloat ( $filter["min"] ) . $this->_PackFloat ( $filter["max"] ); | |
| break; | |
| default: | |
| assert ( 0 && "internal error: unhandled filter type" ); | |
| } | |
| $req .= pack ( "N", $filter["exclude"] ); | |
| } | |
| // group-by clause, max-matches count, group-sort clause, cutoff count | |
| $req .= pack ( "NN", $this->_groupfunc, strlen($this->_groupby) ) . $this->_groupby; | |
| $req .= pack ( "N", $this->_maxmatches ); | |
| $req .= pack ( "N", strlen($this->_groupsort) ) . $this->_groupsort; | |
| $req .= pack ( "NNN", $this->_cutoff, $this->_retrycount, $this->_retrydelay ); | |
| $req .= pack ( "N", strlen($this->_groupdistinct) ) . $this->_groupdistinct; | |
| // anchor point | |
| if ( empty($this->_anchor) ) | |
| { | |
| $req .= pack ( "N", 0 ); | |
| } else | |
| { | |
| $a =& $this->_anchor; | |
| $req .= pack ( "N", 1 ); | |
| $req .= pack ( "N", strlen($a["attrlat"]) ) . $a["attrlat"]; | |
| $req .= pack ( "N", strlen($a["attrlong"]) ) . $a["attrlong"]; | |
| $req .= $this->_PackFloat ( $a["lat"] ) . $this->_PackFloat ( $a["long"] ); | |
| } | |
| // per-index weights | |
| $req .= pack ( "N", count($this->_indexweights) ); | |
| foreach ( $this->_indexweights as $idx=>$weight ) | |
| $req .= pack ( "N", strlen($idx) ) . $idx . pack ( "N", $weight ); | |
| // max query time | |
| $req .= pack ( "N", $this->_maxquerytime ); | |
| // per-field weights | |
| $req .= pack ( "N", count($this->_fieldweights) ); | |
| foreach ( $this->_fieldweights as $field=>$weight ) | |
| $req .= pack ( "N", strlen($field) ) . $field . pack ( "N", $weight ); | |
| // comment | |
| $req .= pack ( "N", strlen($comment) ) . $comment; | |
| // attribute overrides | |
| $req .= pack ( "N", count($this->_overrides) ); | |
| foreach ( $this->_overrides as $key => $entry ) | |
| { | |
| $req .= pack ( "N", strlen($entry["attr"]) ) . $entry["attr"]; | |
| $req .= pack ( "NN", $entry["type"], count($entry["values"]) ); | |
| foreach ( $entry["values"] as $id=>$val ) | |
| { | |
| assert ( is_numeric($id) ); | |
| assert ( is_numeric($val) ); | |
| $req .= sphPackU64 ( $id ); | |
| switch ( $entry["type"] ) | |
| { | |
| case SPH_ATTR_FLOAT: $req .= $this->_PackFloat ( $val ); break; | |
| case SPH_ATTR_BIGINT: $req .= sphPackI64 ( $val ); break; | |
| default: $req .= pack ( "N", $val ); break; | |
| } | |
| } | |
| } | |
| // select-list | |
| $req .= pack ( "N", strlen($this->_select) ) . $this->_select; | |
| // mbstring workaround | |
| $this->_MBPop (); | |
| // store request to requests array | |
| $this->_reqs[] = $req; | |
| return count($this->_reqs)-1; | |
| } | |
| /// connect to searchd, run queries batch, and return an array of result sets | |
| function RunQueries () | |
| { | |
| if ( empty($this->_reqs) ) | |
| { | |
| $this->_error = "no queries defined, issue AddQuery() first"; | |
| return false; | |
| } | |
| // mbstring workaround | |
| $this->_MBPush (); | |
| if (!( $fp = $this->_Connect() )) | |
| { | |
| $this->_MBPop (); | |
| return false; | |
| } | |
| // send query, get response | |
| $nreqs = count($this->_reqs); | |
| $req = join ( "", $this->_reqs ); | |
| $len = 8+strlen($req); | |
| $req = pack ( "nnNNN", SEARCHD_COMMAND_SEARCH, VER_COMMAND_SEARCH, $len, 0, $nreqs ) . $req; // add header | |
| if ( !( $this->_Send ( $fp, $req, $len+8 ) ) || | |
| !( $response = $this->_GetResponse ( $fp, VER_COMMAND_SEARCH ) ) ) | |
| { | |
| $this->_MBPop (); | |
| return false; | |
| } | |
| // query sent ok; we can reset reqs now | |
| $this->_reqs = array (); | |
| // parse and return response | |
| return $this->_ParseSearchResponse ( $response, $nreqs ); | |
| } | |
| /// parse and return search query (or queries) response | |
| function _ParseSearchResponse ( $response, $nreqs ) | |
| { | |
| $p = 0; // current position | |
| $max = strlen($response); // max position for checks, to protect against broken responses | |
| $results = array (); | |
| for ( $ires=0; $ires<$nreqs && $p<$max; $ires++ ) | |
| { | |
| $results[] = array(); | |
| $result =& $results[$ires]; | |
| $result["error"] = ""; | |
| $result["warning"] = ""; | |
| // extract status | |
| list(,$status) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| $result["status"] = $status; | |
| if ( $status!=SEARCHD_OK ) | |
| { | |
| list(,$len) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| $message = substr ( $response, $p, $len ); $p += $len; | |
| if ( $status==SEARCHD_WARNING ) | |
| { | |
| $result["warning"] = $message; | |
| } else | |
| { | |
| $result["error"] = $message; | |
| continue; | |
| } | |
| } | |
| // read schema | |
| $fields = array (); | |
| $attrs = array (); | |
| list(,$nfields) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| while ( $nfields-->0 && $p<$max ) | |
| { | |
| list(,$len) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| $fields[] = substr ( $response, $p, $len ); $p += $len; | |
| } | |
| $result["fields"] = $fields; | |
| list(,$nattrs) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| while ( $nattrs-->0 && $p<$max ) | |
| { | |
| list(,$len) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| $attr = substr ( $response, $p, $len ); $p += $len; | |
| list(,$type) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| $attrs[$attr] = $type; | |
| } | |
| $result["attrs"] = $attrs; | |
| // read match count | |
| list(,$count) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| list(,$id64) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| // read matches | |
| $idx = -1; | |
| while ( $count-->0 && $p<$max ) | |
| { | |
| // index into result array | |
| $idx++; | |
| // parse document id and weight | |
| if ( $id64 ) | |
| { | |
| $doc = sphUnpackU64 ( substr ( $response, $p, 8 ) ); $p += 8; | |
| list(,$weight) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| } | |
| else | |
| { | |
| list ( $doc, $weight ) = array_values ( unpack ( "N*N*", | |
| substr ( $response, $p, 8 ) ) ); | |
| $p += 8; | |
| $doc = sphFixUint($doc); | |
| } | |
| $weight = sprintf ( "%u", $weight ); | |
| // create match entry | |
| if ( $this->_arrayresult ) | |
| $result["matches"][$idx] = array ( "id"=>$doc, "weight"=>$weight ); | |
| else | |
| $result["matches"][$doc]["weight"] = $weight; | |
| // parse and create attributes | |
| $attrvals = array (); | |
| foreach ( $attrs as $attr=>$type ) | |
| { | |
| // handle 64bit ints | |
| if ( $type==SPH_ATTR_BIGINT ) | |
| { | |
| $attrvals[$attr] = sphUnpackI64 ( substr ( $response, $p, 8 ) ); $p += 8; | |
| continue; | |
| } | |
| // handle floats | |
| if ( $type==SPH_ATTR_FLOAT ) | |
| { | |
| list(,$uval) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| list(,$fval) = unpack ( "f*", pack ( "L", $uval ) ); | |
| $attrvals[$attr] = $fval; | |
| continue; | |
| } | |
| // handle everything else as unsigned ints | |
| list(,$val) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| if ( $type==SPH_ATTR_MULTI ) | |
| { | |
| $attrvals[$attr] = array (); | |
| $nvalues = $val; | |
| while ( $nvalues-->0 && $p<$max ) | |
| { | |
| list(,$val) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| $attrvals[$attr][] = sphFixUint($val); | |
| } | |
| } else if ( $type==SPH_ATTR_MULTI64 ) | |
| { | |
| $attrvals[$attr] = array (); | |
| $nvalues = $val; | |
| while ( $nvalues>0 && $p<$max ) | |
| { | |
| $attrvals[$attr][] = sphUnpackU64 ( substr ( $response, $p, 8 ) ); $p += 8; | |
| $nvalues -= 2; | |
| } | |
| } else if ( $type==SPH_ATTR_STRING ) | |
| { | |
| $attrvals[$attr] = substr ( $response, $p, $val ); | |
| $p += $val; | |
| } else | |
| { | |
| $attrvals[$attr] = sphFixUint($val); | |
| } | |
| } | |
| if ( $this->_arrayresult ) | |
| $result["matches"][$idx]["attrs"] = $attrvals; | |
| else | |
| $result["matches"][$doc]["attrs"] = $attrvals; | |
| } | |
| list ( $total, $total_found, $msecs, $words ) = | |
| array_values ( unpack ( "N*N*N*N*", substr ( $response, $p, 16 ) ) ); | |
| $result["total"] = sprintf ( "%u", $total ); | |
| $result["total_found"] = sprintf ( "%u", $total_found ); | |
| $result["time"] = sprintf ( "%.3f", $msecs/1000 ); | |
| $p += 16; | |
| while ( $words-->0 && $p<$max ) | |
| { | |
| list(,$len) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| $word = substr ( $response, $p, $len ); $p += $len; | |
| list ( $docs, $hits ) = array_values ( unpack ( "N*N*", substr ( $response, $p, 8 ) ) ); $p += 8; | |
| $result["words"][$word] = array ( | |
| "docs"=>sprintf ( "%u", $docs ), | |
| "hits"=>sprintf ( "%u", $hits ) ); | |
| } | |
| } | |
| $this->_MBPop (); | |
| return $results; | |
| } | |
| ///////////////////////////////////////////////////////////////////////////// | |
| // excerpts generation | |
| ///////////////////////////////////////////////////////////////////////////// | |
| /// connect to searchd server, and generate exceprts (snippets) | |
| /// of given documents for given query. returns false on failure, | |
| /// an array of snippets on success | |
| function BuildExcerpts ( $docs, $index, $words, $opts=array() ) | |
| { | |
| assert ( is_array($docs) ); | |
| assert ( is_string($index) ); | |
| assert ( is_string($words) ); | |
| assert ( is_array($opts) ); | |
| $this->_MBPush (); | |
| if (!( $fp = $this->_Connect() )) | |
| { | |
| $this->_MBPop(); | |
| return false; | |
| } | |
| ///////////////// | |
| // fixup options | |
| ///////////////// | |
| if ( !isset($opts["before_match"]) ) $opts["before_match"] = "<b>"; | |
| if ( !isset($opts["after_match"]) ) $opts["after_match"] = "</b>"; | |
| if ( !isset($opts["chunk_separator"]) ) $opts["chunk_separator"] = " ... "; | |
| if ( !isset($opts["limit"]) ) $opts["limit"] = 256; | |
| if ( !isset($opts["limit_passages"]) ) $opts["limit_passages"] = 0; | |
| if ( !isset($opts["limit_words"]) ) $opts["limit_words"] = 0; | |
| if ( !isset($opts["around"]) ) $opts["around"] = 5; | |
| if ( !isset($opts["exact_phrase"]) ) $opts["exact_phrase"] = false; | |
| if ( !isset($opts["single_passage"]) ) $opts["single_passage"] = false; | |
| if ( !isset($opts["use_boundaries"]) ) $opts["use_boundaries"] = false; | |
| if ( !isset($opts["weight_order"]) ) $opts["weight_order"] = false; | |
| if ( !isset($opts["query_mode"]) ) $opts["query_mode"] = false; | |
| if ( !isset($opts["force_all_words"]) ) $opts["force_all_words"] = false; | |
| if ( !isset($opts["start_passage_id"]) ) $opts["start_passage_id"] = 1; | |
| if ( !isset($opts["load_files"]) ) $opts["load_files"] = false; | |
| if ( !isset($opts["html_strip_mode"]) ) $opts["html_strip_mode"] = "index"; | |
| if ( !isset($opts["allow_empty"]) ) $opts["allow_empty"] = false; | |
| if ( !isset($opts["passage_boundary"]) ) $opts["passage_boundary"] = "none"; | |
| if ( !isset($opts["emit_zones"]) ) $opts["emit_zones"] = false; | |
| if ( !isset($opts["load_files_scattered"]) ) $opts["load_files_scattered"] = false; | |
| ///////////////// | |
| // build request | |
| ///////////////// | |
| // v.1.2 req | |
| $flags = 1; // remove spaces | |
| if ( $opts["exact_phrase"] ) $flags |= 2; | |
| if ( $opts["single_passage"] ) $flags |= 4; | |
| if ( $opts["use_boundaries"] ) $flags |= 8; | |
| if ( $opts["weight_order"] ) $flags |= 16; | |
| if ( $opts["query_mode"] ) $flags |= 32; | |
| if ( $opts["force_all_words"] ) $flags |= 64; | |
| if ( $opts["load_files"] ) $flags |= 128; | |
| if ( $opts["allow_empty"] ) $flags |= 256; | |
| if ( $opts["emit_zones"] ) $flags |= 512; | |
| if ( $opts["load_files_scattered"] ) $flags |= 1024; | |
| $req = pack ( "NN", 0, $flags ); // mode=0, flags=$flags | |
| $req .= pack ( "N", strlen($index) ) . $index; // req index | |
| $req .= pack ( "N", strlen($words) ) . $words; // req words | |
| // options | |
| $req .= pack ( "N", strlen($opts["before_match"]) ) . $opts["before_match"]; | |
| $req .= pack ( "N", strlen($opts["after_match"]) ) . $opts["after_match"]; | |
| $req .= pack ( "N", strlen($opts["chunk_separator"]) ) . $opts["chunk_separator"]; | |
| $req .= pack ( "NN", (int)$opts["limit"], (int)$opts["around"] ); | |
| $req .= pack ( "NNN", (int)$opts["limit_passages"], (int)$opts["limit_words"], (int)$opts["start_passage_id"] ); // v.1.2 | |
| $req .= pack ( "N", strlen($opts["html_strip_mode"]) ) . $opts["html_strip_mode"]; | |
| $req .= pack ( "N", strlen($opts["passage_boundary"]) ) . $opts["passage_boundary"]; | |
| // documents | |
| $req .= pack ( "N", count($docs) ); | |
| foreach ( $docs as $doc ) | |
| { | |
| assert ( is_string($doc) ); | |
| $req .= pack ( "N", strlen($doc) ) . $doc; | |
| } | |
| //////////////////////////// | |
| // send query, get response | |
| //////////////////////////// | |
| $len = strlen($req); | |
| $req = pack ( "nnN", SEARCHD_COMMAND_EXCERPT, VER_COMMAND_EXCERPT, $len ) . $req; // add header | |
| if ( !( $this->_Send ( $fp, $req, $len+8 ) ) || | |
| !( $response = $this->_GetResponse ( $fp, VER_COMMAND_EXCERPT ) ) ) | |
| { | |
| $this->_MBPop (); | |
| return false; | |
| } | |
| ////////////////// | |
| // parse response | |
| ////////////////// | |
| $pos = 0; | |
| $res = array (); | |
| $rlen = strlen($response); | |
| for ( $i=0; $i<count($docs); $i++ ) | |
| { | |
| list(,$len) = unpack ( "N*", substr ( $response, $pos, 4 ) ); | |
| $pos += 4; | |
| if ( $pos+$len > $rlen ) | |
| { | |
| $this->_error = "incomplete reply"; | |
| $this->_MBPop (); | |
| return false; | |
| } | |
| $res[] = $len ? substr ( $response, $pos, $len ) : ""; | |
| $pos += $len; | |
| } | |
| $this->_MBPop (); | |
| return $res; | |
| } | |
| ///////////////////////////////////////////////////////////////////////////// | |
| // keyword generation | |
| ///////////////////////////////////////////////////////////////////////////// | |
| /// connect to searchd server, and generate keyword list for a given query | |
| /// returns false on failure, | |
| /// an array of words on success | |
| function BuildKeywords ( $query, $index, $hits ) | |
| { | |
| assert ( is_string($query) ); | |
| assert ( is_string($index) ); | |
| assert ( is_bool($hits) ); | |
| $this->_MBPush (); | |
| if (!( $fp = $this->_Connect() )) | |
| { | |
| $this->_MBPop(); | |
| return false; | |
| } | |
| ///////////////// | |
| // build request | |
| ///////////////// | |
| // v.1.0 req | |
| $req = pack ( "N", strlen($query) ) . $query; // req query | |
| $req .= pack ( "N", strlen($index) ) . $index; // req index | |
| $req .= pack ( "N", (int)$hits ); | |
| //////////////////////////// | |
| // send query, get response | |
| //////////////////////////// | |
| $len = strlen($req); | |
| $req = pack ( "nnN", SEARCHD_COMMAND_KEYWORDS, VER_COMMAND_KEYWORDS, $len ) . $req; // add header | |
| if ( !( $this->_Send ( $fp, $req, $len+8 ) ) || | |
| !( $response = $this->_GetResponse ( $fp, VER_COMMAND_KEYWORDS ) ) ) | |
| { | |
| $this->_MBPop (); | |
| return false; | |
| } | |
| ////////////////// | |
| // parse response | |
| ////////////////// | |
| $pos = 0; | |
| $res = array (); | |
| $rlen = strlen($response); | |
| list(,$nwords) = unpack ( "N*", substr ( $response, $pos, 4 ) ); | |
| $pos += 4; | |
| for ( $i=0; $i<$nwords; $i++ ) | |
| { | |
| list(,$len) = unpack ( "N*", substr ( $response, $pos, 4 ) ); $pos += 4; | |
| $tokenized = $len ? substr ( $response, $pos, $len ) : ""; | |
| $pos += $len; | |
| list(,$len) = unpack ( "N*", substr ( $response, $pos, 4 ) ); $pos += 4; | |
| $normalized = $len ? substr ( $response, $pos, $len ) : ""; | |
| $pos += $len; | |
| $res[] = array ( "tokenized"=>$tokenized, "normalized"=>$normalized ); | |
| if ( $hits ) | |
| { | |
| list($ndocs,$nhits) = array_values ( unpack ( "N*N*", substr ( $response, $pos, 8 ) ) ); | |
| $pos += 8; | |
| $res [$i]["docs"] = $ndocs; | |
| $res [$i]["hits"] = $nhits; | |
| } | |
| if ( $pos > $rlen ) | |
| { | |
| $this->_error = "incomplete reply"; | |
| $this->_MBPop (); | |
| return false; | |
| } | |
| } | |
| $this->_MBPop (); | |
| return $res; | |
| } | |
| function EscapeString ( $string ) | |
| { | |
| $from = array ( '\\', '(',')','|','-','!','@','~','"','&', '/', '^', '$', '=' ); | |
| $to = array ( '\\\\', '\(','\)','\|','\-','\!','\@','\~','\"', '\&', '\/', '\^', '\$', '\=' ); | |
| return str_replace ( $from, $to, $string ); | |
| } | |
| ///////////////////////////////////////////////////////////////////////////// | |
| // attribute updates | |
| ///////////////////////////////////////////////////////////////////////////// | |
| /// batch update given attributes in given rows in given indexes | |
| /// returns amount of updated documents (0 or more) on success, or -1 on failure | |
| function UpdateAttributes ( $index, $attrs, $values, $mva=false ) | |
| { | |
| // verify everything | |
| assert ( is_string($index) ); | |
| assert ( is_bool($mva) ); | |
| assert ( is_array($attrs) ); | |
| foreach ( $attrs as $attr ) | |
| assert ( is_string($attr) ); | |
| assert ( is_array($values) ); | |
| foreach ( $values as $id=>$entry ) | |
| { | |
| assert ( is_numeric($id) ); | |
| assert ( is_array($entry) ); | |
| assert ( count($entry)==count($attrs) ); | |
| foreach ( $entry as $v ) | |
| { | |
| if ( $mva ) | |
| { | |
| assert ( is_array($v) ); | |
| foreach ( $v as $vv ) | |
| assert ( is_int($vv) ); | |
| } else | |
| assert ( is_int($v) ); | |
| } | |
| } | |
| // build request | |
| $this->_MBPush (); | |
| $req = pack ( "N", strlen($index) ) . $index; | |
| $req .= pack ( "N", count($attrs) ); | |
| foreach ( $attrs as $attr ) | |
| { | |
| $req .= pack ( "N", strlen($attr) ) . $attr; | |
| $req .= pack ( "N", $mva ? 1 : 0 ); | |
| } | |
| $req .= pack ( "N", count($values) ); | |
| foreach ( $values as $id=>$entry ) | |
| { | |
| $req .= sphPackU64 ( $id ); | |
| foreach ( $entry as $v ) | |
| { | |
| $req .= pack ( "N", $mva ? count($v) : $v ); | |
| if ( $mva ) | |
| foreach ( $v as $vv ) | |
| $req .= pack ( "N", $vv ); | |
| } | |
| } | |
| // connect, send query, get response | |
| if (!( $fp = $this->_Connect() )) | |
| { | |
| $this->_MBPop (); | |
| return -1; | |
| } | |
| $len = strlen($req); | |
| $req = pack ( "nnN", SEARCHD_COMMAND_UPDATE, VER_COMMAND_UPDATE, $len ) . $req; // add header | |
| if ( !$this->_Send ( $fp, $req, $len+8 ) ) | |
| { | |
| $this->_MBPop (); | |
| return -1; | |
| } | |
| if (!( $response = $this->_GetResponse ( $fp, VER_COMMAND_UPDATE ) )) | |
| { | |
| $this->_MBPop (); | |
| return -1; | |
| } | |
| // parse response | |
| list(,$updated) = unpack ( "N*", substr ( $response, 0, 4 ) ); | |
| $this->_MBPop (); | |
| return $updated; | |
| } | |
| ///////////////////////////////////////////////////////////////////////////// | |
| // persistent connections | |
| ///////////////////////////////////////////////////////////////////////////// | |
| function Open() | |
| { | |
| if ( $this->_socket !== false ) | |
| { | |
| $this->_error = 'already connected'; | |
| return false; | |
| } | |
| if ( !$fp = $this->_Connect() ) | |
| return false; | |
| // command, command version = 0, body length = 4, body = 1 | |
| $req = pack ( "nnNN", SEARCHD_COMMAND_PERSIST, 0, 4, 1 ); | |
| if ( !$this->_Send ( $fp, $req, 12 ) ) | |
| return false; | |
| $this->_socket = $fp; | |
| return true; | |
| } | |
| function Close() | |
| { | |
| if ( $this->_socket === false ) | |
| { | |
| $this->_error = 'not connected'; | |
| return false; | |
| } | |
| fclose ( $this->_socket ); | |
| $this->_socket = false; | |
| return true; | |
| } | |
| ////////////////////////////////////////////////////////////////////////// | |
| // status | |
| ////////////////////////////////////////////////////////////////////////// | |
| function Status () | |
| { | |
| $this->_MBPush (); | |
| if (!( $fp = $this->_Connect() )) | |
| { | |
| $this->_MBPop(); | |
| return false; | |
| } | |
| $req = pack ( "nnNN", SEARCHD_COMMAND_STATUS, VER_COMMAND_STATUS, 4, 1 ); // len=4, body=1 | |
| if ( !( $this->_Send ( $fp, $req, 12 ) ) || | |
| !( $response = $this->_GetResponse ( $fp, VER_COMMAND_STATUS ) ) ) | |
| { | |
| $this->_MBPop (); | |
| return false; | |
| } | |
| $p = 0; | |
| list ( $rows, $cols ) = array_values ( unpack ( "N*N*", substr ( $response, $p, 8 ) ) ); $p += 8; | |
| $res = array(); | |
| for ( $i=0; $i<$rows; $i++ ) | |
| for ( $j=0; $j<$cols; $j++ ) | |
| { | |
| list(,$len) = unpack ( "N*", substr ( $response, $p, 4 ) ); $p += 4; | |
| $res[$i][] = substr ( $response, $p, $len ); $p += $len; | |
| } | |
| $this->_MBPop (); | |
| return $res; | |
| } | |
| ////////////////////////////////////////////////////////////////////////// | |
| // flush | |
| ////////////////////////////////////////////////////////////////////////// | |
| function FlushAttributes () | |
| { | |
| $this->_MBPush (); | |
| if (!( $fp = $this->_Connect() )) | |
| { | |
| $this->_MBPop(); | |
| return -1; | |
| } | |
| $req = pack ( "nnN", SEARCHD_COMMAND_FLUSHATTRS, VER_COMMAND_FLUSHATTRS, 0 ); // len=0 | |
| if ( !( $this->_Send ( $fp, $req, 8 ) ) || | |
| !( $response = $this->_GetResponse ( $fp, VER_COMMAND_FLUSHATTRS ) ) ) | |
| { | |
| $this->_MBPop (); | |
| return -1; | |
| } | |
| $tag = -1; | |
| if ( strlen($response)==4 ) | |
| list(,$tag) = unpack ( "N*", $response ); | |
| else | |
| $this->_error = "unexpected response length"; | |
| $this->_MBPop (); | |
| return $tag; | |
| } | |
| } | |
| // | |
| // $Id: sphinxapi.php 3087 2012-01-30 23:07:35Z shodan $ | |
| // |