php 连接测试sphinx

<?php

    header("Content-type:text/html;charset=utf-8");

    include 'SphinxClient.php';

    $cl = new SphinxClient();

    $cl->SetServer('localhost',9312);

    $cl->SetMatchMode(SPH_MATCH_ALL);

    $cl->SetArrayResult(true);

    $res = $cl->Query("test one","*");

    print_r($res);    

?>

<?php

//

// $Id: sphinxapi.php 2055 2009-11-06 23:09:58Z shodan $

//

//

// Copyright (c) 2001-2008, Andrew Aksyonoff. 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_QUERY",    6 );

/// current client-side command implementation versions

define ( "VER_COMMAND_SEARCH",        0x116 );

define ( "VER_COMMAND_EXCERPT",        0x100 );

define ( "VER_COMMAND_UPDATE",        0x102 );

define ( "VER_COMMAND_KEYWORDS",    0x100 );

define ( "VER_COMMAND_STATUS",        0x100 );

define ( "VER_COMMAND_QUERY",        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 );

/// 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_MULTI",            0x40000000 );

/// 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 $_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 SphinxClient ()

    {

        // 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->_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, $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 )

    {

        assert ( $ranker==SPH_RANK_PROXIMITY_BM25

            || $ranker==SPH_RANK_BM25

            || $ranker==SPH_RANK_NONE

            || $ranker==SPH_RANK_WORDCOUNT

            || $ranker==SPH_RANK_PROXIMITY );

        $this->_ranker = $ranker;

    }

    /// 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 ( "NNNNN", $this->_offset, $this->_limit, $this->_mode, $this->_ranker, $this->_sort ); // mode and limits

        $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 = 4+strlen($req);

        $req = pack ( "nnNN", SEARCHD_COMMAND_SEARCH, VER_COMMAND_SEARCH, $len, $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

                    {

                        $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["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;

        /////////////////

        // build request

        /////////////////

        // v.1.0 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;

        $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 ( "N", (int)$opts["limit"] );

        $req .= pack ( "N", (int)$opts["around"] );

        // 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

        $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() ))

            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 ) )

            return -1;

        if (!( $response = $this->_GetResponse ( $fp, VER_COMMAND_UPDATE ) ))

            return -1;

        // parse response

        list(,$updated) = unpack ( "N*", substr ( $response, 0, 4 ) );

        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;

        }

        $res = substr ( $response, 4 ); // just ignore length, error handling, etc

        $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;

    }

}

//

// $Id: sphinxapi.php 2055 2009-11-06 23:09:58Z shodan $

//