QueryGenerator::setPageLength() - Code Metrics - Inspection of "WIP: Next test, SearchableClassTest" - gordonbanderson/silverstripe-elastica - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — dev2 ( d5d1ea...bf3a9f )

by Gordon

created 2015-12-30 05:55 UTC

QueryGenerator::setPageLength() A

↳ Parent: QueryGenerator

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Metric	Value
dl	0
loc	3
ccs	0
cts	3
cp	0
rs	10
cc	1
eloc	2
nc	1
nop	1
crap	2

<?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			public static function getSearchFieldsMappingForClasses($classes = null, $fieldsAllowed = null) {
404
405			// Get a array of relevant classes to search
406			$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			$csvClasses = $classes;
408			if (is_array($classes)) {
409			$csvClasses = implode(',',$classes);
410			}
411
412			$key ='SEARCHABLE_FIELDS_'.str_replace(',', '_', $csvClasses);
413
414			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			$result = $cache->load($key);
422			if (!$result) {
423			$relevantClasses = array();
424			if (empty($csvClasses)) {
425			$sql = "SELECT DISTINCT Name from SearchableClass where InSiteTree = 1 order by Name";
426			$records = \DB::query($sql);
427			foreach ($records as $record) {
428			array_push($relevantClasses, $record['Name']);
429			}
430			} else {
431			$relevantClasses = explode(',', $csvClasses);
432			}
433
434			$result = array();
435			if (sizeof($relevantClasses) > 0) {
436			$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			. "sc.id = sf.SearchableClassID WHERE sc.name IN ($relevantClassesCSV)";
441			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			$records = \DB::query($sql);
449			foreach ($records as $record) {
450			$name = $record['Name'];
451			$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			$result[$name] = $type;
461			}
462			}
463			$cache->save(json_encode($result),$key);
464			} else {
465			// true is necessary here to decode the array hash back to an array and not a struct
466			self::$cacheHitCtr++;
467			$result = json_decode($result,true);
468			}
469
470			return $result;
471			}
472
473
474			public static function getCache() {
475			$cache = \SS_Cache::factory('elasticsearch');
476			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			public static function convertToQuotedCSV($csvOrArray) {
487			$asArray = $csvOrArray;
488			if (!is_array($csvOrArray)) {
489			if ($csvOrArray == null) {
490			$asArray = array();
491			} else {
492			$asArray = explode(',', $csvOrArray);
493			}
494			}
495			$quoted = array();
496			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			if (strlen($value) > 0) {
498			$item = "'".$value."'";
499			array_push($quoted, $item);
500			}
501
502			}
503			return implode(',', $quoted);;
504			}
505			}
506

gordonbanderson / silverstripe-elastica

Push — dev2 ( d5d1ea...bf3a9f )

QueryGenerator::setPageLength() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like