Gazelle/classes/search.class.php

<?
//Require base class
if (!extension_loaded('sphinx')) {
	require(SERVER_ROOT.'/classes/sphinxapi.php');
}

class SPHINX_SEARCH extends SphinxClient {
	private $Index = '*';
	public $TotalResults = 0;
	public $Queries = array();
	public $Time = 0.0;
	public $Filters = array();

	function SPHINX_SEARCH() {
		parent::__construct();
		$this->SetServer(SPHINX_HOST, SPHINX_PORT);
		$this->SetMatchMode(SPH_MATCH_EXTENDED2);
	}

	/****************************************************************
	/--- Search function --------------------------------------------

	This function queries sphinx for whatever is in $Query, in
	extended2 mode. It then fetches the records for each primary key
	from memcached (by joining $CachePrefix and the primary key), and
	fetches the fields needed ($ReturnData) from the memcached
	result.

	Any keys not found in memcached are then queried in MySQL, using
	$SQL. They are then cached, and merged with the memcached matches
	and returned.

	$Query			- sphinx query
	$CachePrefix	- Prefix for memcache key (no underscore)
	$CacheLength	- How long to store data in the cache, if it's found by MySQL
	$ReturnData	- Array of keys to the array in memcached to return.
					  If empty, return all.
	$SQL			- SQL query to fetch results not found in memcached
					- Should take the format of:
					  SELECT fields FROM table WHERE primary key IN(%ids)
					  where %ids will be replaced by a list of IDs not found in memcached
	$IDColumn		- The primary key of the SQL table - must be the
					  same primary key returned by sphinx!

	****************************************************************/

	function search($Query = '', $CachePrefix = '', $CacheLength = 0, $ReturnData = array(), $SQL = '', $IDColumn = 'ID') {
		global $Cache, $DB;
		$QueryStartTime = microtime(true);
		$Result = $this->Query($Query, $this->Index);
		$QueryEndTime = microtime(true);

		$Filters = array();
		foreach ($this->Filters as $Name => $Values) {
			foreach ($Values as $Value) {
				$Filters[] = $Name." - ".$Value;
			}
		}

		$this->Queries[] = array('Params: '.$Query.' Filters: '.implode(", ", $Filters).' Indicies: '.$this->Index,($QueryEndTime - $QueryStartTime) * 1000);
		$this->Time += ($QueryEndTime - $QueryStartTime) * 1000;

		if ($Result === false) {
			if ($this->_connerror && !$Cache->get_value('sphinx_crash_reported')) {
				send_irc('PRIVMSG '.ADMIN_CHAN.' :!dev Connection to searchd failed');
				$Cache->cache_value('sphinx_crash_reported', 1, 3600);
			}
			send_irc('PRIVMSG '.LAB_CHAN.' :Search for "'.$Query.'" ('.str_replace("\n",'',print_r($this->Filters, true)).') failed: '.$this->GetLastError());
		}

		$this->TotalResults = $Result['total_found'];
		$this->SearchTime = $Result['time'];

		if (empty($Result['matches'])) {
			return false;
		}
		$Matches = $Result['matches'];

		$MatchIDs = array_keys($Matches);

		$NotFound = array();
		$Skip = array();
		if (!empty($ReturnData)) {
			$AllFields = false;
		} else {
			$AllFields = true;
		}

		foreach ($MatchIDs as $Match) {
			$Matches[$Match] = $Matches[$Match]['attrs'];
			if (!empty($CachePrefix)) {
				$Data = $Cache->get_value($CachePrefix.'_'.$Match);
				if ($Data == false) {
					$NotFound[] = $Match;
					continue;
				}
			} else {
				$NotFound[] = $Match;
			}
			if (!$AllFields) {
				// Populate list of fields to unset (faster than picking out the ones we need). Should only be run once, on the first cache key
				if (empty($Skip)) {
					foreach (array_keys($Data) as $Key) {
						if (!in_array($Key, $ReturnData)) {
							$Skip[] = $Key;
						}
					}
					if (empty($Skip)) {
						$AllFields = true;
					}
				}
				foreach ($Skip as $Key) {
					unset($Data[$Key]);
				}
				reset($Skip);
			}
			if (!empty($Data)) {
				$Matches[$Match] = array_merge($Matches[$Match], $Data);
			}
		}

		if ($SQL != '') {
			if (!empty($NotFound)) {
				$DB->query(str_replace('%ids', implode(',', $NotFound), $SQL));
				while ($Data = $DB->next_record(MYSQLI_ASSOC)) {
					$Matches[$Data[$IDColumn]] = array_merge($Matches[$Data[$IDColumn]], $Data);
					$Cache->cache_value($CachePrefix.'_'.$Data[$IDColumn], $Data, $CacheLength);
				}
			}
		} else {
			$Matches = array('matches'=>$Matches,'notfound'=>$NotFound);
		}

		return $Matches;
	}

	function limit($Start, $Length) {
		$Start = (int)$Start;
		$Length = (int)$Length;
		$this->SetLimits($Start, $Length, $Start + $Length);
	}


	function set_index($Index) {
		$this->Index = $Index;
	}

	function set_filter($Name, $Vals, $Exclude = false) {
		foreach ($Vals as $Val) {
			if ($Exclude) {
				$this->Filters[$Name][] = "!$Val";
			} else {
				$this->Filters[$Name][] = $Val;
			}
		}
		$this->SetFilter($Name, $Vals, $Exclude);
	}

	function set_filter_range($Name, $Min, $Max, $Exclude) {
		$this->Filters[$Name] = array($Min.'-'.$Max);
		$this->SetFilterRange($Name, $Min, $Max, $Exclude);
	}

	function escape_string($String) {
		return strtr($String, array(
			'('=>'\(',
			')'=>'\)',
			'|'=>'\|',
			'-'=>'\-',
			'@'=>'\@',
			'~'=>'\~',
			'&'=>'\&',
			'!'=>'\!',
			'"'=>'\"',
			'/'=>'\/',
			'\\'=>'\\\\',
			'*'=>'\*',
			'?'=>'\?',
			'^'=>'\^',
			'$'=>'\$',
			'='=>'\='));
		}
}
?>