public function testSetCache() {
$client = new Elastica_Client();
$index = $client->getIndex('test');
$index->create(array(), true);
$type = $index->getType('test');
$doc = new Elastica_Document(1, array('name' => 'hello world'));
$type->addDocument($doc);
$doc = new Elastica_Document(2, array('name' => 'nicolas ruflin'));
$type->addDocument($doc);
$doc = new Elastica_Document(3, array('name' => 'ruflin'));
$type->addDocument($doc);
$and = new Elastica_Filter_And();
$idsFilter1 = new Elastica_Filter_Ids();
$idsFilter1->setIds(1);
$idsFilter2 = new Elastica_Filter_Ids();
$idsFilter2->setIds(1);
$and->addFilter($idsFilter1);
$and->addFilter($idsFilter2);
$index->refresh();
$and->setCached(true);
$resultSet = $type->search($and);
$this->assertEquals(1, $resultSet->count());
}
public function getFilter($exclude = false)
{
// facets filter
$filter = new \Elastica_Filter_And();
// add class filter
$class = $this->parameters->getClass();
if (count($class) > 0 && $exclude != 'class') {
$term = new \Elastica_Filter_Terms('class', $class);
$filter->addFilter($term);
}
// add family filter
$family = $this->parameters->getFamily();
if (count($family) > 0 && $exclude != 'family') {
$term = new \Elastica_Filter_Terms('family', $family);
$filter->addFilter($term);
}
// add town filter
$town = $this->parameters->getTown();
if (count($town) > 0 && $exclude != 'town') {
$term = new \Elastica_Filter_Terms('town', $town);
$filter->addFilter($term);
}
// add canton filter
$canton = $this->parameters->getCanton();
if (count($canton) > 0 && $exclude != 'canton') {
$term = new \Elastica_Filter_Terms('canton', $canton);
$filter->addFilter($term);
}
// add user filter
$user = $this->parameters->getUser();
if (count($user) > 0 && $exclude != 'user') {
$term = new \Elastica_Filter_Terms('user', $user);
$filter->addFilter($term);
}
// add habitat filter
$habitat = $this->parameters->getHabitat();
if (count($habitat) > 0 && $exclude != 'habitat') {
$term = new \Elastica_Filter_Terms('habitat', $habitat);
$filter->addFilter($term);
}
// add redlist filter
$redlist = $this->parameters->getRedlist();
if (count($redlist) > 0 && $exclude != 'redlist') {
$term = new \Elastica_Filter_Terms('redlist', $redlist);
$filter->addFilter($term);
}
// add image_type filter
$image_type = $this->parameters->getImage_type();
if (count($image_type) > 0 && $exclude != 'image_type') {
$term = new \Elastica_Filter_Terms('image_type', $image_type);
$filter->addFilter($term);
}
// filter date
$date = $this->parameters->getDate();
if (count($date) > 0 && $exclude != 'date') {
$range = $this->getDateFilter();
$filter->addFilter($range);
}
return $filter;
}
function search($query, $facets = array(), $offset = false, $limit = false, $indexName = false, $indexType = false)
{
$global_query = $query;
$query = preg_replace("/[^a-zA-Z 0-9]+/", "", $global_query['s']);
// Define a Query. We want a string query.
$elasticaQueryString = new Elastica_Query_QueryString();
$elasticaQueryString->setQuery($query);
$elasticaQueryString->setFields(array('title', 'content'));
$elasticaFilterAnd = new Elastica_Filter_And();
$elasticaFilterBool = new Elastica_Filter_Bool();
$tagTerm = $global_query['tags'];
$authorTerm = $global_query['author'];
$catTerm = $global_query['cats'];
$dateFrom = $global_query['datefrom'];
$dateTo = $global_query['dateto'];
if (!empty($tagTerm)) {
$tagTermArr = explode(",", $tagTerm);
$filterTag = new Elastica_Filter_Terms();
$filterTag->setTerms('tag', $tagTermArr);
$elasticaFilterAnd->addFilter($filterTag);
}
if (!empty($authorTerm)) {
$authorTermArr = explode(",", $authorTerm);
$filterAuthor = new Elastica_Filter_Terms();
$filterAuthor->setTerms('author', $authorTermArr);
$elasticaFilterAnd->addFilter($filterAuthor);
}
if (!empty($catTerm)) {
$catTermArr = explode(",", $catTerm);
$filterCat = new Elastica_Filter_Terms();
$filterCat->setTerms('cat', $catTermArr);
$elasticaFilterAnd->addFilter($filterCat);
}
if (!empty($dateFrom) && !empty($dateTo)) {
$filterDate = new Elastica_Filter_Range('date', array('from' => strftime('%F %T', strtotime($dateFrom)), 'to' => strftime('%F %T', strtotime($dateTo))));
// $dates = new Elastica_Filter_Terms();
// $dates->setTerms('date', array($dateFrom." -> ".$dateTo));
// $elasticaFilterAnd->addFilter($dates);
$elasticaFilterBool->addMust($filterDate);
}
// Create the actual search object with some data.
$elasticaQuery = new Elastica_Query();
$elasticaQuery->setQuery($elasticaQueryString);
if (!empty($tagTerm) || !empty($authorTerm) || !empty($catTerm) || !empty($dateFrom) || !empty($dateTo)) {
// $elasticaQuery->setFilter($elasticaFilterAnd);
$elasticaQuery->setFilter($elasticaFilterBool);
}
if ($offset) {
$elasticaQuery->setFrom($offset);
}
if ($limit) {
$elasticaQuery->setLimit($limit);
}
//Check facet fields
if (!empty($facets)) {
$facet_arr = array();
foreach ($facets as $facet) {
${$facet . "_facet"} = new Elastica_Facet_Terms($facet);
${$facet . "_facet"}->setField($facet);
${$facet . "_facet"}->setSize(10);
${$facet . "_facet"}->setOrder('reverse_count');
array_push($facet_arr, ${$facet . "_facet"});
}
$elasticaQuery->setFacets($facet_arr);
}
//Search on the index.
if ($indexType) {
$elasticaResultSet = $this->elastic_search_client->getIndex($indexName)->getType($indexType)->search($elasticaQuery);
} else {
$elasticaResultSet = $this->elastic_search_client->getIndex($indexName)->search($elasticaQuery);
}
return $elasticaResultSet;
}
/**
* Handles search and facets.
*
* @param string $q
* @param array $params
* @param string $type
* @return Elastica_ResultSet
* @throws Exception
*/
public function search($q, $params = array(), $type = 'product')
{
if ($this->getStatus()->indexExists($this->_index)) {
if (empty($params['filters'])) {
$params['filters'] = '*';
}
$queryFilter = new Elastica_Filter_Query(new Elastica_Query_QueryString($params['filters']));
if (isset($params['range_filters']) && !empty($params['range_filters'])) {
$andFilter = new Elastica_Filter_And();
$andFilter->addFilter($queryFilter);
$filter = new Elastica_Filter_Range();
foreach ($params['range_filters'] as $field => $rangeFilter) {
$filter->addField($field, $rangeFilter);
}
$andFilter->addFilter($filter);
$queryFilter = $andFilter;
}
if (empty($q)) {
$baseQuery = new Elastica_Query_MatchAll();
} else {
$baseQuery = new Elastica_Query_Bool();
if ($this->isFuzzyQueryEnabled()) {
$fields = $this->_getSearchFields(true, $q);
$queryFuzzy = new Elastica_Query_FuzzyLikeThis();
$queryFuzzy->addFields($fields);
$queryFuzzy->setLikeText($q);
$queryFuzzy->setMinSimilarity($this->getFuzzyMinSimilarity());
$queryFuzzy->setPrefixLength($this->getFuzzyPrefixLength());
$queryFuzzy->setMaxQueryTerms($this->getFuzzyMaxQueryTerms());
$queryFuzzy->setBoost($this->getFuzzyQueryBoost());
$baseQuery->addShould($queryFuzzy);
}
$queryString = new Elastica_Query_QueryString($q);
$queryString->setFields($this->_getSearchFields(false, $q));
$baseQuery->addShould($queryString);
}
$filteredQuery = new Elastica_Query_Filtered($baseQuery, $queryFilter);
$query = Elastica_Query::create($filteredQuery)->setFrom($params['offset'])->setLimit($params['limit']);
if (isset($params['facets']['queries']) && !empty($params['facets']['queries'])) {
foreach ($params['facets']['queries'] as $facetQuery) {
$facet = new Elastica_Facet_Query($facetQuery);
$facet->setParam('query_string', array('query' => $facetQuery));
$query->addFacet($facet);
}
}
if (isset($params['stats']['fields']) && !empty($params['stats']['fields'])) {
foreach ($params['stats']['fields'] as $field) {
$facet = new Elastica_Facet_Statistical($field);
$facet->setParam('field', $field);
$query->addFacet($facet);
}
} else {
if (isset($params['facets']['fields']) && !empty($params['facets']['fields'])) {
$properties = $this->_getIndexProperties();
foreach ($params['facets']['fields'] as $field) {
if (array_key_exists($field, $properties)) {
$facet = new Elastica_Facet_Terms($field);
if ($properties[$field]['type'] == 'multi_field') {
$field .= '.untouched';
}
$facet->setField($field);
$facet->setParam('all_terms', true);
$facet->setSize($this->getFacetsMaxSize());
$query->addFacet($facet);
}
}
}
if (isset($params['facets']['ranges']) && !empty($params['facets']['ranges'])) {
foreach ($params['facets']['ranges'] as $field => $ranges) {
$facet = new Elastica_Facet_Range($field);
$facet->setField($field);
$facet->setRanges($ranges);
$query->addFacet($facet);
}
}
}
if (isset($params['sort']) && !empty($params['sort'])) {
foreach ($params['sort'] as $sort) {
$query->addSort($sort);
}
}
$result = $this->getIndex($this->_index)->getType($type)->search($query);
return $result;
}
return array();
}
