QueryGenerator - Code Metrics - Inspection of "WIP: Testing SearchableFieldTest" - gordonbanderson/silverstripe-elastica - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — dev2 ( bf3a9f...7a5f92 )

by Gordon

created 2015-12-30 06:00 UTC

QueryGenerator C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	490
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	14

Test Coverage

Coverage

19.42%

Importance

Changes	2
Bugs	1	Features	0

Metric	Value
wmc	60
lcom	1
cbo	14
dl	0
loc	490
ccs	47
cts	242
cp	0.1942
rs	5.6364
c	2
b	1
f	0

21 Methods

Rating	Name	Size	Complexity
A	getShowResultsForEmptyQuery()	3	1
A	getCacheHitCounter()	3	1
A	resetCacheHitCounter()	3	1
B	generateElasticaAutocompleteQuery()	34	2
A	getCache()	4	1
B	convertToQuotedCSV()	19	5
A	setSelectedFilters()	3	1
A	setQueryResultManipulator()	3	1
B	generateElasticaQuery()	56	6
C	addFilters()	58	9
A	addAggregation()	6	2
A	simpleTextQuery()	14	3
B	multiMatchQuery()	29	4
C	convertWeightedFieldsForElastica()	26	7
A	setClasses()	3	1
A	setQueryText()	3	1
A	setFields()	3	1
A	setShowResultsForEmptyQuery()	3	1
A	setPageLength()	3	1
A	setStart()	3	1
C	getSearchFieldsMappingForClasses()	69	10

How to fix Complexity

<?php
namespace SilverStripe\Elastica;

use \SilverStripe\Elastica\ResultList;
use Elastica\Query;

use Elastica\Query\QueryString;
use Elastica\Aggregation\Filter;
use Elastica\Filter\Term;
use Elastica\Filter\BoolAnd;
use Elastica\Filter\MatchAll;
use Elastica\Query\Filtered;
use Elastica\Query\MultiMatch;
use SilverStripe\Elastica\RangedAggregation;

class QueryGenerator {

	/* The term to search for */
	private $queryText = '';

	/* Fields to search for as an array of Name to weighting, otherwise null for all, ie not
	a multi match query */
	private $fields = null;

	/* Aggregations already selected in format array(key => value), e.g. array('ISO' => 400) */
	private $selectedFilters = null;

	/* For an empty query, show results or not */
	private $showResultsForEmptyQuery = false;

	/* Manipulator to be used for aggregations */
	private $manipulator = null;

	/* The length of a page of results */
	private $pageLength = 10;

	/* Where to start, normally a multiple of pageLength */
	private $start = 0;

	/* Cache hit counter for test purposes */
	private static $cacheHitCtr = 0;

	/**
	 * Comma separated list of SilverStripe ClassNames to search. Leave blank for all
	 * @var string
	 */
	private $classes = '';


	public function setQueryText($newQueryText) {
		$this->queryText = $newQueryText;
	}


	public function setFields($newFields) {
		$this->fields = $newFields;
	}


	public function setSelectedFilters($newSelectedFilters) {
		$this->selectedFilters = $newSelectedFilters;
	}


	public function setShowResultsForEmptyQuery($newShowResultsForEmptyQuery) {
		$this->showResultsForEmptyQuery = $newShowResultsForEmptyQuery;
	}


	public function getShowResultsForEmptyQuery() {
		return $this->showResultsForEmptyQuery;
	}


	public function setPageLength($newPageLength) {
		$this->pageLength = $newPageLength;
	}


	public function setStart($newStart) {
		$this->start = $newStart;
	}


	/**
	 * Update the list of Classes to search, use SilverStripe ClassName comma separated
	 * @param string $newClasses comma separated list of SilverStripe ClassNames
	 */
	public function setClasses($newClasses) {
		$this->classes = $newClasses;
	}



	/**
	 * Set the manipulator, mainly used for aggregation
	 * @param string $newManipulator manipulator used for aggregation, must implement ElasticaSearchHelper
	 */
	public function setQueryResultManipulator($newManipulator) {
		$this->manipulator = $newManipulator;
	}


	/*
	Accessor to cache hit counter, for testing purposes
	 */
	public static function getCacheHitCounter() {
		return self::$cacheHitCtr;
	}


	public static function resetCacheHitCounter() {
		self::$cacheHitCtr = 0;
	}


	/**
	 * From the input variables create a suitable query using Elastica.  This is somewhat complex
	 * due to different formats with and without query text, with and without filters, with and
	 * without selected filters.  Extracting this logic into a separate class makes testing much
	 * faster and can be used for testing new cases
	 *
	 * @return \Elastica\Query           Query object suitable for searching using the Elastica library
	 */
	public function generateElasticaQuery() {
		$queryTextExists = ($this->queryText != '');
		$isMultiMatch = ($this->fields != null);

		if ($this->selectedFilters == null) {
			$this->selectedFilters = array();
		}

		$this->manipulatorInstance = null;
		if ($this->manipulator) {
			$this->manipulatorInstance = \Injector::inst()->create($this->manipulator);
			$this->manipulatorInstance->queryGenerator = $this;
			$this->manipulatorInstance->originalQueryString = $this->queryText;
		}

		//This is a query_string object
		$textQuery = null;

		if (!$isMultiMatch) {
			$textQuery = $this->simpleTextQuery();
		} else {
			$textQuery = $this->multiMatchQuery();
		}

		$query = $this->addFilters($textQuery);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

		//This ensures that the original query text is available to search helpers
		$query->OriginalQueryText = $this->queryText;

		//This needs to be query object of some form
		$this->addAggregation($query);


		// pagination
		$query->setSize($this->pageLength);
		$query->setFrom($this->start);

		if ($this->manipulatorInstance && !$queryTextExists) {
			$sort = $this->manipulatorInstance->getDefaultSort();
			$query->setSort($sort);
		}

		// Add suggestions in case required for poor spellings or typos
		$suggest = new \Elastica\Suggest();
		$phrase = new \Elastica\Suggest\Phrase('query-phrase-suggestions', '_all');
		$phrase->setText($this->queryText)->setSize(4);

		$highlightsCfg = \Config::inst()->get('Elastica', 'Highlights');
		$preTags = $highlightsCfg['PreTags'];
		$postTags = $highlightsCfg['PostTags'];

		$phrase->setHighlight($preTags, $postTags);
		$suggest->addSuggestion($phrase);
		$query->setSuggest($suggest);
		return $query;
	}


	/**
	 * Generate a query for autocomplete
	 * @return \Elastica\Query Autocompletion query for use with Elastica library
	 */
	public function generateElasticaAutocompleteQuery() {
		$field = array_keys($this->fields)[0];
		$data = array(
			'size' => 10,
			'query' => array(
				'match' => array(
					$field.'.autocomplete' => array(
						'query' => $this->queryText,
						'operator' => 'and'
					)
				)
			)
		);

		// The query clause can only have one entry, so a bit of mangling
		if (!empty($this->selectedFilters)) {
			$filtered = array();
			$filtered['query'] = $data['query'];
			unset($data['query']);
			$filtered['filter'] = array('term' => $this->selectedFilters);
			$data['query'] = array('filtered' => $filtered);
		}

/*

{
    "filtered": {
        "query":  { "match": { "email": "business opportunity" }},
        "filter": { "term":  { "folder": "inbox" }}
    }
}
*/
		$query = new Query($data);
		return $query;
	}





	/**
	 * Using a query string object, return a suitable filtered or unfiltered query object
	 * @param Elastica\Query\QueryString $textQuery A query_string representing the current query
	 */
	private function addFilters($textQuery) {
		if ($this->manipulator) {
			$this->manipulatorInstance->updateFilters($this->selectedFilters);
		}

		$elFilters = array();
		$rangeFilterKeys = RangedAggregation::getTitles();

		foreach ($this->selectedFilters as $key => $value) {
			if (!in_array($key, $rangeFilterKeys)) {
				$filter = new Term();
				$filter->setTerm($key,$value);
				$elFilters[] = $filter;
			} else {
				// get the selected range filter
				$range = RangedAggregation::getByTitle($key);
				$filter = $range->getFilter($value);
				$elFilters[] = $filter;
			}
		}


		// if not facets selected, pass through null
		$queryFilter = null;
		switch (count($this->selectedFilters)) {
			case 0:
				// filter already null
				break;
			case 1:
				$queryFilter = $elFilters[0];
				break;
			default:
				$queryFilter = new BoolAnd();

				foreach ($elFilters as $filter) {
					$queryFilter->addFilter($filter);
				}
				break;
		}

		// the Elastica query object
		if ($queryFilter == null) {
			$query = new Query($textQuery);
		} else {
			//MatchAll appears not be allowed inside a filtered query which is a bit of a pain.
			if ($textQuery instanceof MatchAll) {
				$textQuery = null;
			}

			$filtered = new Filtered(
			  $textQuery,
			  $queryFilter
			);
			$query = new Query($filtered);
		}

		return $query;
	}


	private function addAggregation(&$query) {
		// aggregation (optional)
		if ($this->manipulatorInstance) {
			$this->manipulatorInstance->augmentQuery($query);
		}
	}


	/*
	Simplest form of search, namely search for text string against all fields.  In Curl terms:

	curl -XGET 'http://localhost:9200/elastica_ss_module_test_en_us/_search?pretty' -d '
	{
	   "query": {
	        "query_string": {
	            "query":        "Image"
	        }
	    }
	}
	'
	 */
	private function simpleTextQuery() {
		// this will search all fields

		$textQuery = new QueryString($this->queryText);

		//Setting the lenient flag means that numeric fields can be searched for text values
		$textQuery->setParam('lenient', true);

		if ($this->showResultsForEmptyQuery && $this->queryText == '') {
			$textQuery = new MatchAll();
		}

		return $textQuery;
	}


	// USE MATCH_ALL, see https://www.elastic.co/guide/en/elasticsearch/reference/1.4/query-dsl-match-all-query.html
	private function multiMatchQuery() {
		$textQuery = new MultiMatch();

		// Differing cases for showing and not showing empty string
		if ($this->queryText == '') {
			if (!$this->showResultsForEmptyQuery) {
				$textQuery->setQuery('');
			} else {
				//WIP
				$textQuery = new MatchAll();
			}
		}

		// If there is text, search for it regardless
		else {
			$textQuery->setQuery($this->queryText);
		}

		if ($textQuery instanceof MultiMatch) {
			$elasticaFields = $this->convertWeightedFieldsForElastica($this->fields);
			$textQuery->setFields($elasticaFields);
			$textQuery->setType('most_fields');

			//Setting the lenient flag means that numeric fields can be searched for text values
			$textQuery->setParam('lenient', true);
		}

		return $textQuery;
	}



	/**
	 * Use the configuration from the Search settings held in the database to
	 * form the array of fields suitable for a multimatch query.  Call this
	 * after having called setClasses
	 *
	 * @return array Array of fieldsname to weight
	 */
	public function convertWeightedFieldsForElastica($fields) {
		$result = array();
		$nameToType = self::getSearchFieldsMappingForClasses($this->classes,$fields);

		if (sizeof($fields) != 0) {
			foreach ($fields as $fieldName => $weight) {
				$fieldCfg = "$fieldName";
				if ($weight != 1) {
					$fieldCfg .= '^'.$weight;
				}
				array_push($result, $fieldCfg);
				if (isset($nameToType[$fieldName])) {
					if ($nameToType[$fieldName] == 'string') {
						$fieldCfg = "{$fieldName}.*";
						if ($weight != 1) {
							$fieldCfg .= '^'.$weight;
						}
						array_push($result, $fieldCfg);
					}
				} else {
					throw new \Exception("Field $fieldName does not exist");
				}
			}
		}
		return $result;
	}



	/**
	 * Get a hash of name to Elasticserver mapping, e.g. 'Title' => 'string'
	 * Use SS_Cache to save on database hits, as this data only changes at build time
	 * @param  string $classes CSV or array of ClassNames to search, or empty for
	 *         all of SiteTree
	 * @return array Array hash of fieldname to Elasticsearch mapping
	 */
	public static function getSearchFieldsMappingForClasses($classes = null, $fieldsAllowed = null) {

		// Get a array of relevant classes to search
		$cache = QueryGenerator::getCache();
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
		$csvClasses = $classes;
		if (is_array($classes)) {
			$csvClasses = implode(',',$classes);
		}

		$key ='SEARCHABLE_FIELDS_'.str_replace(',', '_', $csvClasses);

		if ($fieldsAllowed) {
			$fieldsAllowedCSV = self::convertToQuotedCSV(array_keys($fieldsAllowed));
			$key .= '_' . str_replace(',', '_', str_replace("'", '_',$fieldsAllowedCSV));
			$key = str_replace('.', '_', $key);
			$key = str_replace(' ', '_', $key);
		}

		$result = $cache->load($key);
		if (!$result) {
			$relevantClasses = array();
			if (empty($csvClasses)) {
				$sql = "SELECT DISTINCT Name from SearchableClass where InSiteTree = 1 order by Name";
				$records = \DB::query($sql);
				foreach ($records as $record) {
					array_push($relevantClasses, $record['Name']);
				}
			} else {
				$relevantClasses = explode(',', $csvClasses);
			}

			$result = array();
			if (sizeof($relevantClasses) > 0) {
				$relevantClassesCSV = self::convertToQuotedCSV($relevantClasses);

				//Perform a database query to get get a list of searchable fieldnames to Elasticsearch mapping
				$sql = "SELECT  sf.Name,sf.Type FROM SearchableClass sc  INNER JOIN SearchableField sf ON "
					 . "sc.id = sf.SearchableClassID WHERE sc.name IN ($relevantClassesCSV)";
				if ($fieldsAllowed) {
					$fieldsAllowedCSV = self::convertToQuotedCSV(array_keys($fieldsAllowed));
					if (strlen($fieldsAllowedCSV) > 0) {
						$sql .= " AND sf.Name IN ($fieldsAllowedCSV)";
					}
				}

				$records = \DB::query($sql);
				foreach ($records as $record) {
					$name = $record['Name'];
					$type = $record['Type'];

					/**
					 * FIXME:
					 * This will overwrite duplicate keys such as Content or Title from other Classes.
					 * Ideally need to check if the mapping being overwritten changes, e.g. if
					 * a field such as BirthDate is date in one class and string in another
					 * and throw an exception accordingly
					 */
					$result[$name] = $type;
				}
			}
			$cache->save(json_encode($result),$key);
		}  else {
			// true is necessary here to decode the array hash back to an array and not a struct
			self::$cacheHitCtr++;
			$result = json_decode($result,true);
		}

		return $result;
	}


	public static function getCache() {
		$cache = \SS_Cache::factory('elasticsearch');
		return $cache;
	}


	/**
	 * Convert either a CSV string or an array to a CSV single quoted string, suitable for use in
	 * an SQL IN clause
	 * @param  string|array $csvOrArray A string separated by commas or an array
	 * @return string             string or array as a CSV, but values quoted with single quotes
	 */
	public static function convertToQuotedCSV($csvOrArray) {
		$asArray = $csvOrArray;
		if (!is_array($csvOrArray)) {
			if ($csvOrArray == null) {
				$asArray = array();
			} else {
				$asArray = explode(',', $csvOrArray);
			}
		}
		$quoted = array();
		foreach ($asArray as $value) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
			if (strlen($value) > 0) {
				$item = "'".$value."'";
				array_push($quoted, $item);
			}

		}
		return implode(',', $quoted);;
	}
}


1		<?php
2		namespace SilverStripe\Elastica;
3
4		use \SilverStripe\Elastica\ResultList;
5		use Elastica\Query;
6
7		use Elastica\Query\QueryString;
8		use Elastica\Aggregation\Filter;
9		use Elastica\Filter\Term;
10		use Elastica\Filter\BoolAnd;
11		use Elastica\Filter\MatchAll;
12		use Elastica\Query\Filtered;
13		use Elastica\Query\MultiMatch;
14		use SilverStripe\Elastica\RangedAggregation;
15
16		class QueryGenerator {
17
18		/* The term to search for */
19		private $queryText = '';
20
21		/* Fields to search for as an array of Name to weighting, otherwise null for all, ie not
22		a multi match query */
23		private $fields = null;
24
25		/* Aggregations already selected in format array(key => value), e.g. array('ISO' => 400) */
26		private $selectedFilters = null;
27
28		/* For an empty query, show results or not */
29		private $showResultsForEmptyQuery = false;
30
31		/* Manipulator to be used for aggregations */
32		private $manipulator = null;
33
34		/* The length of a page of results */
35		private $pageLength = 10;
36
37		/* Where to start, normally a multiple of pageLength */
38		private $start = 0;
39
40		/* Cache hit counter for test purposes */
41		private static $cacheHitCtr = 0;
42
43		/**
44		* Comma separated list of SilverStripe ClassNames to search. Leave blank for all
45		* @var string
46		*/
47		private $classes = '';
48
49
50		public function setQueryText($newQueryText) {
51		$this->queryText = $newQueryText;
52		}
53
54
55		public function setFields($newFields) {
56		$this->fields = $newFields;
57		}
58
59
60		public function setSelectedFilters($newSelectedFilters) {
61		$this->selectedFilters = $newSelectedFilters;
62		}
63
64
65		public function setShowResultsForEmptyQuery($newShowResultsForEmptyQuery) {
66		$this->showResultsForEmptyQuery = $newShowResultsForEmptyQuery;
67		}
68
69
70		public function getShowResultsForEmptyQuery() {
71		return $this->showResultsForEmptyQuery;
72		}
73
74
75		public function setPageLength($newPageLength) {
76		$this->pageLength = $newPageLength;
77		}
78
79
80		public function setStart($newStart) {
81		$this->start = $newStart;
82		}
83
84
85		/**
86		* Update the list of Classes to search, use SilverStripe ClassName comma separated
87		* @param string $newClasses comma separated list of SilverStripe ClassNames
88		*/
89		public function setClasses($newClasses) {
90		$this->classes = $newClasses;
91		}
92
93
94
95		/**
96		* Set the manipulator, mainly used for aggregation
97		* @param string $newManipulator manipulator used for aggregation, must implement ElasticaSearchHelper
98		*/
99		public function setQueryResultManipulator($newManipulator) {
100		$this->manipulator = $newManipulator;
101		}
102
103
104		/*
105		Accessor to cache hit counter, for testing purposes
106		*/
107		public static function getCacheHitCounter() {
108		return self::$cacheHitCtr;
109		}
110
111
112		public static function resetCacheHitCounter() {
113		self::$cacheHitCtr = 0;
114		}
115
116
117		/**
118		* From the input variables create a suitable query using Elastica. This is somewhat complex
119		* due to different formats with and without query text, with and without filters, with and
120		* without selected filters. Extracting this logic into a separate class makes testing much
121		* faster and can be used for testing new cases
122		*
123		* @return \Elastica\Query Query object suitable for searching using the Elastica library
124		*/
125		public function generateElasticaQuery() {
126		$queryTextExists = ($this->queryText != '');
127		$isMultiMatch = ($this->fields != null);
128
129		if ($this->selectedFilters == null) {
130		$this->selectedFilters = array();
131		}
132
133		$this->manipulatorInstance = null;
134		if ($this->manipulator) {
135		$this->manipulatorInstance = \Injector::inst()->create($this->manipulator);
136		$this->manipulatorInstance->queryGenerator = $this;
137		$this->manipulatorInstance->originalQueryString = $this->queryText;
138		}
139
140		//This is a query_string object
141		$textQuery = null;
142
143		if (!$isMultiMatch) {
144		$textQuery = $this->simpleTextQuery();
145		} else {
146		$textQuery = $this->multiMatchQuery();
147		}
148
149		$query = $this->addFilters($textQuery);
		0 ignored issues – show Documentation introduced 2015-12-01 14:39 UTC by Report Bug Copy Issue Report `$textQuery` is of type `object<Elastica\Filter\M...stica\Query\MultiMatch>`, but the function expects a `object<SilverStripe\Elas...tica\Query\QueryString>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
150
151		//This ensures that the original query text is available to search helpers
152		$query->OriginalQueryText = $this->queryText;
153
154		//This needs to be query object of some form
155		$this->addAggregation($query);
156
157
158		// pagination
159		$query->setSize($this->pageLength);
160		$query->setFrom($this->start);
161
162		if ($this->manipulatorInstance && !$queryTextExists) {
163		$sort = $this->manipulatorInstance->getDefaultSort();
164		$query->setSort($sort);
165		}
166
167		// Add suggestions in case required for poor spellings or typos
168		$suggest = new \Elastica\Suggest();
169		$phrase = new \Elastica\Suggest\Phrase('query-phrase-suggestions', '_all');
170		$phrase->setText($this->queryText)->setSize(4);
171
172		$highlightsCfg = \Config::inst()->get('Elastica', 'Highlights');
173		$preTags = $highlightsCfg['PreTags'];
174		$postTags = $highlightsCfg['PostTags'];
175
176		$phrase->setHighlight($preTags, $postTags);
177		$suggest->addSuggestion($phrase);
178		$query->setSuggest($suggest);
179		return $query;
180		}
181
182
183		/**
184		* Generate a query for autocomplete
185		* @return \Elastica\Query Autocompletion query for use with Elastica library
186		*/
187		public function generateElasticaAutocompleteQuery() {
188		$field = array_keys($this->fields)[0];
189		$data = array(
190		'size' => 10,
191		'query' => array(
192		'match' => array(
193		$field.'.autocomplete' => array(
194		'query' => $this->queryText,
195		'operator' => 'and'
196		)
197		)
198		)
199		);
200
201		// The query clause can only have one entry, so a bit of mangling
202		if (!empty($this->selectedFilters)) {
203		$filtered = array();
204		$filtered['query'] = $data['query'];
205		unset($data['query']);
206		$filtered['filter'] = array('term' => $this->selectedFilters);
207		$data['query'] = array('filtered' => $filtered);
208		}
209
210		/*
		0 ignored issues – show Unused Code Comprehensibility introduced 2015-12-01 14:39 UTC by Report Bug Copy Issue Report `61%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
211		{
212		"filtered": {
213		"query": { "match": { "email": "business opportunity" }},
214		"filter": { "term": { "folder": "inbox" }}
215		}
216		}
217		*/
218		$query = new Query($data);
219		return $query;
220		}
221
222
223
224
225
226		/**
227		* Using a query string object, return a suitable filtered or unfiltered query object
228		* @param Elastica\Query\QueryString $textQuery A query_string representing the current query
229		*/
230		private function addFilters($textQuery) {
231		if ($this->manipulator) {
232		$this->manipulatorInstance->updateFilters($this->selectedFilters);
233		}
234
235		$elFilters = array();
236		$rangeFilterKeys = RangedAggregation::getTitles();
237
238		foreach ($this->selectedFilters as $key => $value) {
239		if (!in_array($key, $rangeFilterKeys)) {
240		$filter = new Term();
241		$filter->setTerm($key,$value);
242		$elFilters[] = $filter;
243		} else {
244		// get the selected range filter
245		$range = RangedAggregation::getByTitle($key);
246		$filter = $range->getFilter($value);
247		$elFilters[] = $filter;
248		}
249		}
250
251
252		// if not facets selected, pass through null
253		$queryFilter = null;
254		switch (count($this->selectedFilters)) {
255		case 0:
256		// filter already null
257		break;
258		case 1:
259		$queryFilter = $elFilters[0];
260		break;
261		default:
262		$queryFilter = new BoolAnd();
263
264		foreach ($elFilters as $filter) {
265		$queryFilter->addFilter($filter);
266		}
267		break;
268		}
269
270		// the Elastica query object
271		if ($queryFilter == null) {
272		$query = new Query($textQuery);
273		} else {
274		//MatchAll appears not be allowed inside a filtered query which is a bit of a pain.
275		if ($textQuery instanceof MatchAll) {
276		$textQuery = null;
277		}
278
279		$filtered = new Filtered(
280		$textQuery,
281		$queryFilter
282		);
283		$query = new Query($filtered);
284		}
285
286		return $query;
287		}
288
289
290		private function addAggregation(&$query) {
291		// aggregation (optional)
292		if ($this->manipulatorInstance) {
293		$this->manipulatorInstance->augmentQuery($query);
294		}
295		}
296
297
298		/*
299		Simplest form of search, namely search for text string against all fields. In Curl terms:
300
301		curl -XGET 'http://localhost:9200/elastica_ss_module_test_en_us/_search?pretty' -d '
302		{
303		"query": {
304		"query_string": {
305		"query": "Image"
306		}
307		}
308		}
309		'
310		*/
311		private function simpleTextQuery() {
312		// this will search all fields
313
314		$textQuery = new QueryString($this->queryText);
315
316		//Setting the lenient flag means that numeric fields can be searched for text values
317		$textQuery->setParam('lenient', true);
318
319		if ($this->showResultsForEmptyQuery && $this->queryText == '') {
320		$textQuery = new MatchAll();
321		}
322
323		return $textQuery;
324		}
325
326
327		// USE MATCH_ALL, see https://www.elastic.co/guide/en/elasticsearch/reference/1.4/query-dsl-match-all-query.html
328		private function multiMatchQuery() {
329		$textQuery = new MultiMatch();
330
331		// Differing cases for showing and not showing empty string
332		if ($this->queryText == '') {
333		if (!$this->showResultsForEmptyQuery) {
334		$textQuery->setQuery('');
335		} else {
336		//WIP
337		$textQuery = new MatchAll();
338		}
339		}
340
341		// If there is text, search for it regardless
342		else {
343		$textQuery->setQuery($this->queryText);
344		}
345
346		if ($textQuery instanceof MultiMatch) {
347		$elasticaFields = $this->convertWeightedFieldsForElastica($this->fields);
348		$textQuery->setFields($elasticaFields);
349		$textQuery->setType('most_fields');
350
351		//Setting the lenient flag means that numeric fields can be searched for text values
352		$textQuery->setParam('lenient', true);
353		}
354
355		return $textQuery;
356		}
357
358
359
360		/**
361		* Use the configuration from the Search settings held in the database to
362		* form the array of fields suitable for a multimatch query. Call this
363		* after having called setClasses
364		*
365		* @return array Array of fieldsname to weight
366		*/
367		public function convertWeightedFieldsForElastica($fields) {
368		$result = array();
369		$nameToType = self::getSearchFieldsMappingForClasses($this->classes,$fields);
370
371		if (sizeof($fields) != 0) {
372		foreach ($fields as $fieldName => $weight) {
373		$fieldCfg = "$fieldName";
374		if ($weight != 1) {
375		$fieldCfg .= '^'.$weight;
376		}
377		array_push($result, $fieldCfg);
378		if (isset($nameToType[$fieldName])) {
379		if ($nameToType[$fieldName] == 'string') {
380		$fieldCfg = "{$fieldName}.*";
381		if ($weight != 1) {
382		$fieldCfg .= '^'.$weight;
383		}
384		array_push($result, $fieldCfg);
385		}
386		} else {
387		throw new \Exception("Field $fieldName does not exist");
388		}
389		}
390		}
391		return $result;
392		}
393
394
395
396		/**
397		* Get a hash of name to Elasticserver mapping, e.g. 'Title' => 'string'
398		* Use SS_Cache to save on database hits, as this data only changes at build time
399		* @param string $classes CSV or array of ClassNames to search, or empty for
400		* all of SiteTree
401		* @return array Array hash of fieldname to Elasticsearch mapping
402		*/
403	8	public static function getSearchFieldsMappingForClasses($classes = null, $fieldsAllowed = null) {
404
405		// Get a array of relevant classes to search
406	8	$cache = QueryGenerator::getCache();
		1 ignored issue – show Coding Style introduced 2015-12-29 09:15 UTC by Report Bug Copy Issue Report As per coding style, `self` should be used for accessing local static members. This check looks for accesses to local static members using the fully qualified name instead of `self::`. <?php class Certificate { const TRIPLEDES_CBC = 'ASDFGHJKL'; private $key; public function __construct() { $this->key = Certificate::TRIPLEDES_CBC; } } While this is perfectly valid, the fully qualified name of `Certificate::TRIPLEDES_CBC` could just as well be replaced by `self::TRIPLEDES_CBC`. Referencing local members with `self::` assured the access will still work when the class is renamed, makes it perfectly clear that the member is in fact local and will usually be shorter. Loading history...
407	8	$csvClasses = $classes;
408	8	if (is_array($classes)) {
409		$csvClasses = implode(',',$classes);
410		}
411
412	8	$key ='SEARCHABLE_FIELDS_'.str_replace(',', '_', $csvClasses);
413
414	8	if ($fieldsAllowed) {
415		$fieldsAllowedCSV = self::convertToQuotedCSV(array_keys($fieldsAllowed));
416		$key .= '_' . str_replace(',', '_', str_replace("'", '_',$fieldsAllowedCSV));
417		$key = str_replace('.', '_', $key);
418		$key = str_replace(' ', '_', $key);
419		}
420
421	8	$result = $cache->load($key);
422	8	if (!$result) {
423	8	$relevantClasses = array();
424	8	if (empty($csvClasses)) {
425	8	$sql = "SELECT DISTINCT Name from SearchableClass where InSiteTree = 1 order by Name";
426	8	$records = \DB::query($sql);
427	8	foreach ($records as $record) {
428	8	array_push($relevantClasses, $record['Name']);
429	8	}
430	8	} else {
431		$relevantClasses = explode(',', $csvClasses);
432		}
433
434	8	$result = array();
435	8	if (sizeof($relevantClasses) > 0) {
436	8	$relevantClassesCSV = self::convertToQuotedCSV($relevantClasses);
437
438		//Perform a database query to get get a list of searchable fieldnames to Elasticsearch mapping
439		$sql = "SELECT sf.Name,sf.Type FROM SearchableClass sc INNER JOIN SearchableField sf ON "
440	8	. "sc.id = sf.SearchableClassID WHERE sc.name IN ($relevantClassesCSV)";
441	8	if ($fieldsAllowed) {
442		$fieldsAllowedCSV = self::convertToQuotedCSV(array_keys($fieldsAllowed));
443		if (strlen($fieldsAllowedCSV) > 0) {
444		$sql .= " AND sf.Name IN ($fieldsAllowedCSV)";
445		}
446		}
447
448	8	$records = \DB::query($sql);
449	8	foreach ($records as $record) {
450	8	$name = $record['Name'];
451	8	$type = $record['Type'];
452
453		/**
454		* FIXME:
455		* This will overwrite duplicate keys such as Content or Title from other Classes.
456		* Ideally need to check if the mapping being overwritten changes, e.g. if
457		* a field such as BirthDate is date in one class and string in another
458		* and throw an exception accordingly
459		*/
460	8	$result[$name] = $type;
461	8	}
462	8	}
463	8	$cache->save(json_encode($result),$key);
464	8	} else {
465		// true is necessary here to decode the array hash back to an array and not a struct
466	8	self::$cacheHitCtr++;
467	8	$result = json_decode($result,true);
468		}
469
470	8	return $result;
471		}
472
473
474	8	public static function getCache() {
475	8	$cache = \SS_Cache::factory('elasticsearch');
476	8	return $cache;
477		}
478
479
480		/**
481		* Convert either a CSV string or an array to a CSV single quoted string, suitable for use in
482		* an SQL IN clause
483		* @param string\|array $csvOrArray A string separated by commas or an array
484		* @return string string or array as a CSV, but values quoted with single quotes
485		*/
486	8	public static function convertToQuotedCSV($csvOrArray) {
487	8	$asArray = $csvOrArray;
488	8	if (!is_array($csvOrArray)) {
489		if ($csvOrArray == null) {
490		$asArray = array();
491		} else {
492		$asArray = explode(',', $csvOrArray);
493		}
494		}
495	8	$quoted = array();
496	8	foreach ($asArray as $value) {
		0 ignored issues – show Bug introduced 2015-12-02 05:29 UTC by Report Bug Copy Issue Report The expression `$asArray` of type `string\|array` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
497	8	if (strlen($value) > 0) {
498	8	$item = "'".$value."'";
499	8	array_push($quoted, $item);
500	8	}
501
502	8	}
503	8	return implode(',', $quoted);;
504		}
505		}
506

gordonbanderson / silverstripe-elastica

Push — dev2 ( bf3a9f...7a5f92 )

QueryGenerator C

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

21 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like