]> git.openstreetmap.org Git - nominatim.git/blob - lib/Geocode.php
Merge branch 'moreurl-with-countrycodes' of https://github.com/mtmail/Nominatim into...
[nominatim.git] / lib / Geocode.php
1 <?php
2
3 namespace Nominatim;
4
5 require_once(CONST_BasePath.'/lib/PlaceLookup.php');
6 require_once(CONST_BasePath.'/lib/ReverseGeocode.php');
7
8 class Geocode
9 {
10     protected $oDB;
11
12     protected $aLangPrefOrder = array();
13
14     protected $bIncludeAddressDetails = false;
15     protected $bIncludeExtraTags = false;
16     protected $bIncludeNameDetails = false;
17
18     protected $bIncludePolygonAsPoints = false;
19     protected $bIncludePolygonAsText = false;
20     protected $bIncludePolygonAsGeoJSON = false;
21     protected $bIncludePolygonAsKML = false;
22     protected $bIncludePolygonAsSVG = false;
23     protected $fPolygonSimplificationThreshold = 0.0;
24
25     protected $aExcludePlaceIDs = array();
26     protected $bDeDupe = true;
27     protected $bReverseInPlan = false;
28
29     protected $iLimit = 20;
30     protected $iFinalLimit = 10;
31     protected $iOffset = 0;
32     protected $bFallback = false;
33
34     protected $aCountryCodes = false;
35     protected $aNearPoint = false;
36
37     protected $bBoundedSearch = false;
38     protected $aViewBox = false;
39     protected $sViewboxCentreSQL = false;
40     protected $sViewboxSmallSQL = false;
41     protected $sViewboxLargeSQL = false;
42
43     protected $iMaxRank = 20;
44     protected $iMinAddressRank = 0;
45     protected $iMaxAddressRank = 30;
46     protected $aAddressRankList = array();
47     protected $exactMatchCache = array();
48
49     protected $sAllowedTypesSQLList = false;
50
51     protected $sQuery = false;
52     protected $aStructuredQuery = false;
53
54
55     public function __construct(&$oDB)
56     {
57         $this->oDB =& $oDB;
58     }
59
60     public function setReverseInPlan($bReverse)
61     {
62         $this->bReverseInPlan = $bReverse;
63     }
64
65     public function setLanguagePreference($aLangPref)
66     {
67         $this->aLangPrefOrder = $aLangPref;
68     }
69
70     public function getIncludeAddressDetails()
71     {
72         return $this->bIncludeAddressDetails;
73     }
74
75     public function getIncludeExtraTags()
76     {
77         return $this->bIncludeExtraTags;
78     }
79
80     public function getIncludeNameDetails()
81     {
82         return $this->bIncludeNameDetails;
83     }
84
85     public function setIncludePolygonAsPoints($b = true)
86     {
87         $this->bIncludePolygonAsPoints = $b;
88     }
89
90     public function setIncludePolygonAsText($b = true)
91     {
92         $this->bIncludePolygonAsText = $b;
93     }
94
95     public function setIncludePolygonAsGeoJSON($b = true)
96     {
97         $this->bIncludePolygonAsGeoJSON = $b;
98     }
99
100     public function setIncludePolygonAsKML($b = true)
101     {
102         $this->bIncludePolygonAsKML = $b;
103     }
104
105     public function setIncludePolygonAsSVG($b = true)
106     {
107         $this->bIncludePolygonAsSVG = $b;
108     }
109
110     public function setPolygonSimplificationThreshold($f)
111     {
112         $this->fPolygonSimplificationThreshold = $f;
113     }
114
115     public function setLimit($iLimit = 10)
116     {
117         if ($iLimit > 50) $iLimit = 50;
118         if ($iLimit < 1) $iLimit = 1;
119
120         $this->iFinalLimit = $iLimit;
121         $this->iLimit = $iLimit + min($iLimit, 10);
122     }
123
124     public function getExcludedPlaceIDs()
125     {
126         return $this->aExcludePlaceIDs;
127     }
128
129
130     public function getCountryCodes()
131     {
132         return $this->aCountryCodes;
133     }
134
135     public function getViewBoxString()
136     {
137         if (!$this->aViewBox) return null;
138         return $this->aViewBox[0].','.$this->aViewBox[3].','.$this->aViewBox[2].','.$this->aViewBox[1];
139     }
140
141     public function setFeatureType($sFeatureType)
142     {
143         switch ($sFeatureType) {
144             case 'country':
145                 $this->setRankRange(4, 4);
146                 break;
147             case 'state':
148                 $this->setRankRange(8, 8);
149                 break;
150             case 'city':
151                 $this->setRankRange(14, 16);
152                 break;
153             case 'settlement':
154                 $this->setRankRange(8, 20);
155                 break;
156         }
157     }
158
159     public function setRankRange($iMin, $iMax)
160     {
161         $this->iMinAddressRank = $iMin;
162         $this->iMaxAddressRank = $iMax;
163     }
164
165     public function setRoute($aRoutePoints, $fRouteWidth)
166     {
167         $this->aViewBox = false;
168
169         $this->sViewboxCentreSQL = "ST_SetSRID('LINESTRING(";
170         $sSep = '';
171         foreach ($aRoutePoints as $aPoint) {
172             $fPoint = (float)$aPoint;
173             $this->sViewboxCentreSQL .= $sSep.$fPoint;
174             $sSep = ($sSep == ' ') ? ',' : ' ';
175         }
176         $this->sViewboxCentreSQL .= ")'::geometry,4326)";
177
178         $this->sViewboxSmallSQL = 'ST_BUFFER('.$this->sViewboxCentreSQL;
179         $this->sViewboxSmallSQL .= ','.($fRouteWidth/69).')';
180
181         $this->sViewboxLargeSQL = 'ST_BUFFER('.$this->sViewboxCentreSQL;
182         $this->sViewboxLargeSQL .= ','.($fRouteWidth/30).')';
183     }
184
185     public function setViewbox($aViewbox)
186     {
187         $this->aViewBox = array_map('floatval', $aViewbox);
188
189         $this->aViewBox[0] = max(-180.0, min(180, $this->aViewBox[0]));
190         $this->aViewBox[1] = max(-90.0, min(90, $this->aViewBox[1]));
191         $this->aViewBox[2] = max(-180.0, min(180, $this->aViewBox[2]));
192         $this->aViewBox[3] = max(-90.0, min(90, $this->aViewBox[3]));
193
194         if (abs($this->aViewBox[0] - $this->aViewBox[2]) < 0.000000001
195             || abs($this->aViewBox[1] - $this->aViewBox[3]) < 0.000000001
196         ) {
197             userError("Bad parameter 'viewbox'. Not a box.");
198         }
199
200         $fHeight = $this->aViewBox[0] - $this->aViewBox[2];
201         $fWidth = $this->aViewBox[1] - $this->aViewBox[3];
202         $aBigViewBox[0] = $this->aViewBox[0] + $fHeight;
203         $aBigViewBox[2] = $this->aViewBox[2] - $fHeight;
204         $aBigViewBox[1] = $this->aViewBox[1] + $fWidth;
205         $aBigViewBox[3] = $this->aViewBox[3] - $fWidth;
206
207         $this->sViewboxCentreSQL = false;
208         $this->sViewboxSmallSQL = sprintf(
209             'ST_SetSRID(ST_MakeBox2D(ST_Point(%F,%F),ST_Point(%F,%F)),4326)',
210             $this->aViewBox[0],
211             $this->aViewBox[1],
212             $this->aViewBox[2],
213             $this->aViewBox[3]
214         );
215         $this->sViewboxLargeSQL = sprintf(
216             'ST_SetSRID(ST_MakeBox2D(ST_Point(%F,%F),ST_Point(%F,%F)),4326)',
217             $aBigViewBox[0],
218             $aBigViewBox[1],
219             $aBigViewBox[2],
220             $aBigViewBox[3]
221         );
222     }
223
224     public function setNearPoint($aNearPoint, $fRadiusDeg = 0.1)
225     {
226         $this->aNearPoint = array((float)$aNearPoint[0], (float)$aNearPoint[1], (float)$fRadiusDeg);
227     }
228
229     public function setQuery($sQueryString)
230     {
231         $this->sQuery = $sQueryString;
232         $this->aStructuredQuery = false;
233     }
234
235     public function getQueryString()
236     {
237         return $this->sQuery;
238     }
239
240
241     public function loadParamArray($oParams)
242     {
243         $this->bIncludeAddressDetails
244          = $oParams->getBool('addressdetails', $this->bIncludeAddressDetails);
245         $this->bIncludeExtraTags
246          = $oParams->getBool('extratags', $this->bIncludeExtraTags);
247         $this->bIncludeNameDetails
248          = $oParams->getBool('namedetails', $this->bIncludeNameDetails);
249
250         $this->bBoundedSearch = $oParams->getBool('bounded', $this->bBoundedSearch);
251         $this->bDeDupe = $oParams->getBool('dedupe', $this->bDeDupe);
252
253         $this->setLimit($oParams->getInt('limit', $this->iFinalLimit));
254         $this->iOffset = $oParams->getInt('offset', $this->iOffset);
255
256         $this->bFallback = $oParams->getBool('fallback', $this->bFallback);
257
258         // List of excluded Place IDs - used for more acurate pageing
259         $sExcluded = $oParams->getStringList('exclude_place_ids');
260         if ($sExcluded) {
261             foreach ($sExcluded as $iExcludedPlaceID) {
262                 $iExcludedPlaceID = (int)$iExcludedPlaceID;
263                 if ($iExcludedPlaceID)
264                     $aExcludePlaceIDs[$iExcludedPlaceID] = $iExcludedPlaceID;
265             }
266
267             if (isset($aExcludePlaceIDs))
268                 $this->aExcludePlaceIDs = $aExcludePlaceIDs;
269         }
270
271         // Only certain ranks of feature
272         $sFeatureType = $oParams->getString('featureType');
273         if (!$sFeatureType) $sFeatureType = $oParams->getString('featuretype');
274         if ($sFeatureType) $this->setFeatureType($sFeatureType);
275
276         // Country code list
277         $sCountries = $oParams->getStringList('countrycodes');
278         if ($sCountries) {
279             foreach ($sCountries as $sCountryCode) {
280                 if (preg_match('/^[a-zA-Z][a-zA-Z]$/', $sCountryCode)) {
281                     $aCountries[] = strtolower($sCountryCode);
282                 }
283             }
284             if (isset($aCountries))
285                 $this->aCountryCodes = $aCountries;
286         }
287
288         $aViewbox = $oParams->getStringList('viewboxlbrt');
289         if ($aViewbox) {
290             if (count($aViewbox) != 4) {
291                 userError("Bad parmater 'viewbox'. Expected 4 coordinates.");
292             }
293             $this->setViewbox($aViewbox);
294         } else {
295             $aViewbox = $oParams->getStringList('viewbox');
296             if ($aViewbox) {
297                 if (count($aViewbox) != 4) {
298                     userError("Bad parmater 'viewbox'. Expected 4 coordinates.");
299                 }
300                 $this->setViewBox(array(
301                                    $aViewbox[0],
302                                    $aViewbox[3],
303                                    $aViewbox[2],
304                                    $aViewbox[1]
305                                   ));
306             } else {
307                 $aRoute = $oParams->getStringList('route');
308                 $fRouteWidth = $oParams->getFloat('routewidth');
309                 if ($aRoute && $fRouteWidth) {
310                     $this->setRoute($aRoute, $fRouteWidth);
311                 }
312             }
313         }
314     }
315
316     public function setQueryFromParams($oParams)
317     {
318         // Search query
319         $sQuery = $oParams->getString('q');
320         if (!$sQuery) {
321             $this->setStructuredQuery(
322                 $oParams->getString('amenity'),
323                 $oParams->getString('street'),
324                 $oParams->getString('city'),
325                 $oParams->getString('county'),
326                 $oParams->getString('state'),
327                 $oParams->getString('country'),
328                 $oParams->getString('postalcode')
329             );
330             $this->setReverseInPlan(false);
331         } else {
332             $this->setQuery($sQuery);
333         }
334     }
335
336     public function loadStructuredAddressElement($sValue, $sKey, $iNewMinAddressRank, $iNewMaxAddressRank, $aItemListValues)
337     {
338         $sValue = trim($sValue);
339         if (!$sValue) return false;
340         $this->aStructuredQuery[$sKey] = $sValue;
341         if ($this->iMinAddressRank == 0 && $this->iMaxAddressRank == 30) {
342             $this->iMinAddressRank = $iNewMinAddressRank;
343             $this->iMaxAddressRank = $iNewMaxAddressRank;
344         }
345         if ($aItemListValues) $this->aAddressRankList = array_merge($this->aAddressRankList, $aItemListValues);
346         return true;
347     }
348
349     public function setStructuredQuery($sAmentiy = false, $sStreet = false, $sCity = false, $sCounty = false, $sState = false, $sCountry = false, $sPostalCode = false)
350     {
351         $this->sQuery = false;
352
353         // Reset
354         $this->iMinAddressRank = 0;
355         $this->iMaxAddressRank = 30;
356         $this->aAddressRankList = array();
357
358         $this->aStructuredQuery = array();
359         $this->sAllowedTypesSQLList = '';
360
361         $this->loadStructuredAddressElement($sAmentiy, 'amenity', 26, 30, false);
362         $this->loadStructuredAddressElement($sStreet, 'street', 26, 30, false);
363         $this->loadStructuredAddressElement($sCity, 'city', 14, 24, false);
364         $this->loadStructuredAddressElement($sCounty, 'county', 9, 13, false);
365         $this->loadStructuredAddressElement($sState, 'state', 8, 8, false);
366         $this->loadStructuredAddressElement($sPostalCode, 'postalcode', 5, 11, array(5, 11));
367         $this->loadStructuredAddressElement($sCountry, 'country', 4, 4, false);
368
369         if (sizeof($this->aStructuredQuery) > 0) {
370             $this->sQuery = join(', ', $this->aStructuredQuery);
371             if ($this->iMaxAddressRank < 30) {
372                 $sAllowedTypesSQLList = '(\'place\',\'boundary\')';
373             }
374         }
375     }
376
377     public function fallbackStructuredQuery()
378     {
379         if (!$this->aStructuredQuery) return false;
380
381         $aParams = $this->aStructuredQuery;
382
383         if (sizeof($aParams) == 1) return false;
384
385         $aOrderToFallback = array('postalcode', 'street', 'city', 'county', 'state');
386
387         foreach ($aOrderToFallback as $sType) {
388             if (isset($aParams[$sType])) {
389                 unset($aParams[$sType]);
390                 $this->setStructuredQuery(@$aParams['amenity'], @$aParams['street'], @$aParams['city'], @$aParams['county'], @$aParams['state'], @$aParams['country'], @$aParams['postalcode']);
391                 return true;
392             }
393         }
394
395         return false;
396     }
397
398     public function getDetails($aPlaceIDs)
399     {
400         //$aPlaceIDs is an array with key: placeID and value: tiger-housenumber, if found, else -1
401         if (sizeof($aPlaceIDs) == 0) return array();
402
403         $sLanguagePrefArraySQL = "ARRAY[".join(',', array_map("getDBQuoted", $this->aLangPrefOrder))."]";
404
405         // Get the details for display (is this a redundant extra step?)
406         $sPlaceIDs = join(',', array_keys($aPlaceIDs));
407
408         $sImportanceSQL = '';
409         if ($this->sViewboxSmallSQL) $sImportanceSQL .= " CASE WHEN ST_Contains($this->sViewboxSmallSQL, ST_Collect(centroid)) THEN 1 ELSE 0.75 END * ";
410         if ($this->sViewboxLargeSQL) $sImportanceSQL .= " CASE WHEN ST_Contains($this->sViewboxLargeSQL, ST_Collect(centroid)) THEN 1 ELSE 0.75 END * ";
411
412         $sSQL  = "SELECT ";
413         $sSQL .= "    osm_type,";
414         $sSQL .= "    osm_id,";
415         $sSQL .= "    class,";
416         $sSQL .= "    type,";
417         $sSQL .= "    admin_level,";
418         $sSQL .= "    rank_search,";
419         $sSQL .= "    rank_address,";
420         $sSQL .= "    min(place_id) AS place_id, ";
421         $sSQL .= "    min(parent_place_id) AS parent_place_id, ";
422         $sSQL .= "    calculated_country_code AS country_code, ";
423         $sSQL .= "    get_address_by_language(place_id, -1, $sLanguagePrefArraySQL) AS langaddress,";
424         $sSQL .= "    get_name_by_language(name, $sLanguagePrefArraySQL) AS placename,";
425         $sSQL .= "    get_name_by_language(name, ARRAY['ref']) AS ref,";
426         if ($this->bIncludeExtraTags) $sSQL .= "hstore_to_json(extratags)::text AS extra,";
427         if ($this->bIncludeNameDetails) $sSQL .= "hstore_to_json(name)::text AS names,";
428         $sSQL .= "    avg(ST_X(centroid)) AS lon, ";
429         $sSQL .= "    avg(ST_Y(centroid)) AS lat, ";
430         $sSQL .= "    ".$sImportanceSQL."COALESCE(importance,0.75-(rank_search::float/40)) AS importance, ";
431         $sSQL .= "    ( ";
432         $sSQL .= "       SELECT max(p.importance*(p.rank_address+2))";
433         $sSQL .= "       FROM ";
434         $sSQL .= "         place_addressline s, ";
435         $sSQL .= "         placex p";
436         $sSQL .= "       WHERE s.place_id = min(CASE WHEN placex.rank_search < 28 THEN placex.place_id ELSE placex.parent_place_id END)";
437         $sSQL .= "         AND p.place_id = s.address_place_id ";
438         $sSQL .= "         AND s.isaddress ";
439         $sSQL .= "         AND p.importance is not null ";
440         $sSQL .= "    ) AS addressimportance, ";
441         $sSQL .= "    (extratags->'place') AS extra_place ";
442         $sSQL .= " FROM placex";
443         $sSQL .= " WHERE place_id in ($sPlaceIDs) ";
444         $sSQL .= "   AND (";
445         $sSQL .= "            placex.rank_address between $this->iMinAddressRank and $this->iMaxAddressRank ";
446         if (14 >= $this->iMinAddressRank && 14 <= $this->iMaxAddressRank) {
447             $sSQL .= "        OR (extratags->'place') = 'city'";
448         }
449         if ($this->aAddressRankList) {
450             $sSQL .= "        OR placex.rank_address in (".join(',', $this->aAddressRankList).")";
451         }
452         $sSQL .= "       ) ";
453         if ($this->sAllowedTypesSQLList) {
454             $sSQL .= "AND placex.class in $this->sAllowedTypesSQLList ";
455         }
456         $sSQL .= "    AND linked_place_id is null ";
457         $sSQL .= " GROUP BY ";
458         $sSQL .= "     osm_type, ";
459         $sSQL .= "     osm_id, ";
460         $sSQL .= "     class, ";
461         $sSQL .= "     type, ";
462         $sSQL .= "     admin_level, ";
463         $sSQL .= "     rank_search, ";
464         $sSQL .= "     rank_address, ";
465         $sSQL .= "     calculated_country_code, ";
466         $sSQL .= "     importance, ";
467         if (!$this->bDeDupe) $sSQL .= "place_id,";
468         $sSQL .= "     langaddress, ";
469         $sSQL .= "     placename, ";
470         $sSQL .= "     ref, ";
471         if ($this->bIncludeExtraTags) $sSQL .= "extratags, ";
472         if ($this->bIncludeNameDetails) $sSQL .= "name, ";
473         $sSQL .= "     extratags->'place' ";
474
475         if (30 >= $this->iMinAddressRank && 30 <= $this->iMaxAddressRank) {
476             // only Tiger housenumbers and interpolation lines need to be interpolated, because they are saved as lines
477             // with start- and endnumber, the common osm housenumbers are usually saved as points
478             $sHousenumbers = "";
479             $i = 0;
480             $length = count($aPlaceIDs);
481             foreach ($aPlaceIDs as $placeID => $housenumber) {
482                 $i++;
483                 $sHousenumbers .= "(".$placeID.", ".$housenumber.")";
484                 if ($i<$length) $sHousenumbers .= ", ";
485             }
486
487             if (CONST_Use_US_Tiger_Data) {
488                 // Tiger search only if a housenumber was searched and if it was found (i.e. aPlaceIDs[placeID] = housenumber != -1) (realized through a join)
489                 $sSQL .= " union";
490                 $sSQL .= " SELECT ";
491                 $sSQL .= "     'T' AS osm_type, ";
492                 $sSQL .= "     (SELECT osm_id from placex p WHERE p.place_id=min(blub.parent_place_id)) as osm_id, ";
493                 $sSQL .= "     'place' AS class, ";
494                 $sSQL .= "     'house' AS type, ";
495                 $sSQL .= "     null AS admin_level, ";
496                 $sSQL .= "     30 AS rank_search, ";
497                 $sSQL .= "     30 AS rank_address, ";
498                 $sSQL .= "     min(place_id) AS place_id, ";
499                 $sSQL .= "     min(parent_place_id) AS parent_place_id, ";
500                 $sSQL .= "     'us' AS country_code, ";
501                 $sSQL .= "     get_address_by_language(place_id, housenumber_for_place, $sLanguagePrefArraySQL) AS langaddress,";
502                 $sSQL .= "     null AS placename, ";
503                 $sSQL .= "     null AS ref, ";
504                 if ($this->bIncludeExtraTags) $sSQL .= "null AS extra,";
505                 if ($this->bIncludeNameDetails) $sSQL .= "null AS names,";
506                 $sSQL .= "     avg(st_x(centroid)) AS lon, ";
507                 $sSQL .= "     avg(st_y(centroid)) AS lat,";
508                 $sSQL .= "     ".$sImportanceSQL."-1.15 AS importance, ";
509                 $sSQL .= "     (";
510                 $sSQL .= "        SELECT max(p.importance*(p.rank_address+2))";
511                 $sSQL .= "        FROM ";
512                 $sSQL .= "          place_addressline s, ";
513                 $sSQL .= "          placex p";
514                 $sSQL .= "        WHERE s.place_id = min(blub.parent_place_id)";
515                 $sSQL .= "          AND p.place_id = s.address_place_id ";
516                 $sSQL .= "          AND s.isaddress";
517                 $sSQL .= "          AND p.importance is not null";
518                 $sSQL .= "     ) AS addressimportance, ";
519                 $sSQL .= "     null AS extra_place ";
520                 $sSQL .= " FROM (";
521                 $sSQL .= "     SELECT place_id, ";    // interpolate the Tiger housenumbers here
522                 $sSQL .= "         ST_LineInterpolatePoint(linegeo, (housenumber_for_place-startnumber::float)/(endnumber-startnumber)::float) AS centroid, ";
523                 $sSQL .= "         parent_place_id, ";
524                 $sSQL .= "         housenumber_for_place";
525                 $sSQL .= "     FROM (";
526                 $sSQL .= "            location_property_tiger ";
527                 $sSQL .= "            JOIN (values ".$sHousenumbers.") AS housenumbers(place_id, housenumber_for_place) USING(place_id)) ";
528                 $sSQL .= "     WHERE ";
529                 $sSQL .= "         housenumber_for_place>=0";
530                 $sSQL .= "         AND 30 between $this->iMinAddressRank AND $this->iMaxAddressRank";
531                 $sSQL .= " ) AS blub"; //postgres wants an alias here
532                 $sSQL .= " GROUP BY";
533                 $sSQL .= "      place_id, ";
534                 $sSQL .= "      housenumber_for_place"; //is this group by really needed?, place_id + housenumber (in combination) are unique
535                 if (!$this->bDeDupe) $sSQL .= ", place_id ";
536             }
537             // osmline
538             // interpolation line search only if a housenumber was searched and if it was found (i.e. aPlaceIDs[placeID] = housenumber != -1) (realized through a join)
539             $sSQL .= " UNION ";
540             $sSQL .= "SELECT ";
541             $sSQL .= "  'W' AS osm_type, ";
542             $sSQL .= "  osm_id, ";
543             $sSQL .= "  'place' AS class, ";
544             $sSQL .= "  'house' AS type, ";
545             $sSQL .= "  null AS admin_level, ";
546             $sSQL .= "  30 AS rank_search, ";
547             $sSQL .= "  30 AS rank_address, ";
548             $sSQL .= "  min(place_id) as place_id, ";
549             $sSQL .= "  min(parent_place_id) AS parent_place_id, ";
550             $sSQL .= "  calculated_country_code AS country_code, ";
551             $sSQL .= "  get_address_by_language(place_id, housenumber_for_place, $sLanguagePrefArraySQL) AS langaddress, ";
552             $sSQL .= "  null AS placename, ";
553             $sSQL .= "  null AS ref, ";
554             if ($this->bIncludeExtraTags) $sSQL .= "null AS extra, ";
555             if ($this->bIncludeNameDetails) $sSQL .= "null AS names, ";
556             $sSQL .= "  AVG(st_x(centroid)) AS lon, ";
557             $sSQL .= "  AVG(st_y(centroid)) AS lat, ";
558             $sSQL .= "  ".$sImportanceSQL."-0.1 AS importance, ";  // slightly smaller than the importance for normal houses with rank 30, which is 0
559             $sSQL .= "  (";
560             $sSQL .= "     SELECT ";
561             $sSQL .= "       MAX(p.importance*(p.rank_address+2)) ";
562             $sSQL .= "     FROM";
563             $sSQL .= "       place_addressline s, ";
564             $sSQL .= "       placex p";
565             $sSQL .= "     WHERE s.place_id = min(blub.parent_place_id) ";
566             $sSQL .= "       AND p.place_id = s.address_place_id ";
567             $sSQL .= "       AND s.isaddress ";
568             $sSQL .= "       AND p.importance is not null";
569             $sSQL .= "  ) AS addressimportance,";
570             $sSQL .= "  null AS extra_place ";
571             $sSQL .= "  FROM (";
572             $sSQL .= "     SELECT ";
573             $sSQL .= "         osm_id, ";
574             $sSQL .= "         place_id, ";
575             $sSQL .= "         calculated_country_code, ";
576             $sSQL .= "         CASE ";             // interpolate the housenumbers here
577             $sSQL .= "           WHEN startnumber != endnumber ";
578             $sSQL .= "           THEN ST_LineInterpolatePoint(linegeo, (housenumber_for_place-startnumber::float)/(endnumber-startnumber)::float) ";
579             $sSQL .= "           ELSE ST_LineInterpolatePoint(linegeo, 0.5) ";
580             $sSQL .= "         END as centroid, ";
581             $sSQL .= "         parent_place_id, ";
582             $sSQL .= "         housenumber_for_place ";
583             $sSQL .= "     FROM (";
584             $sSQL .= "            location_property_osmline ";
585             $sSQL .= "            JOIN (values ".$sHousenumbers.") AS housenumbers(place_id, housenumber_for_place) USING(place_id)";
586             $sSQL .= "          ) ";
587             $sSQL .= "     WHERE housenumber_for_place>=0 ";
588             $sSQL .= "       AND 30 between $this->iMinAddressRank AND $this->iMaxAddressRank";
589             $sSQL .= "  ) as blub"; //postgres wants an alias here
590             $sSQL .= "  GROUP BY ";
591             $sSQL .= "    osm_id, ";
592             $sSQL .= "    place_id, ";
593             $sSQL .= "    housenumber_for_place, ";
594             $sSQL .= "    calculated_country_code "; //is this group by really needed?, place_id + housenumber (in combination) are unique
595             if (!$this->bDeDupe) $sSQL .= ", place_id ";
596
597             if (CONST_Use_Aux_Location_data) {
598                 $sSQL .= " UNION ";
599                 $sSQL .= "  SELECT ";
600                 $sSQL .= "     'L' AS osm_type, ";
601                 $sSQL .= "     place_id AS osm_id, ";
602                 $sSQL .= "     'place' AS class,";
603                 $sSQL .= "     'house' AS type, ";
604                 $sSQL .= "     null AS admin_level, ";
605                 $sSQL .= "     0 AS rank_search,";
606                 $sSQL .= "     0 AS rank_address, ";
607                 $sSQL .= "     min(place_id) AS place_id,";
608                 $sSQL .= "     min(parent_place_id) AS parent_place_id, ";
609                 $sSQL .= "     'us' AS country_code, ";
610                 $sSQL .= "     get_address_by_language(place_id, -1, $sLanguagePrefArraySQL) AS langaddress, ";
611                 $sSQL .= "     null AS placename, ";
612                 $sSQL .= "     null AS ref, ";
613                 if ($this->bIncludeExtraTags) $sSQL .= "null AS extra, ";
614                 if ($this->bIncludeNameDetails) $sSQL .= "null AS names, ";
615                 $sSQL .= "     avg(ST_X(centroid)) AS lon, ";
616                 $sSQL .= "     avg(ST_Y(centroid)) AS lat, ";
617                 $sSQL .= "     ".$sImportanceSQL."-1.10 AS importance, ";
618                 $sSQL .= "     ( ";
619                 $sSQL .= "       SELECT max(p.importance*(p.rank_address+2))";
620                 $sSQL .= "       FROM ";
621                 $sSQL .= "          place_addressline s, ";
622                 $sSQL .= "          placex p";
623                 $sSQL .= "       WHERE s.place_id = min(location_property_aux.parent_place_id)";
624                 $sSQL .= "         AND p.place_id = s.address_place_id ";
625                 $sSQL .= "         AND s.isaddress";
626                 $sSQL .= "         AND p.importance is not null";
627                 $sSQL .= "     ) AS addressimportance, ";
628                 $sSQL .= "     null AS extra_place ";
629                 $sSQL .= "  FROM location_property_aux ";
630                 $sSQL .= "  WHERE place_id in ($sPlaceIDs) ";
631                 $sSQL .= "    AND 30 between $this->iMinAddressRank and $this->iMaxAddressRank ";
632                 $sSQL .= "  GROUP BY ";
633                 $sSQL .= "     place_id, ";
634                 if (!$this->bDeDupe) $sSQL .= "place_id, ";
635                 $sSQL .= "     get_address_by_language(place_id, -1, $sLanguagePrefArraySQL) ";
636             }
637         }
638
639         $sSQL .= " order by importance desc";
640         if (CONST_Debug) {
641             echo "<hr>";
642             var_dump($sSQL);
643         }
644         $aSearchResults = chksql(
645             $this->oDB->getAll($sSQL),
646             "Could not get details for place."
647         );
648
649         return $aSearchResults;
650     }
651
652     public function getGroupedSearches($aSearches, $aPhraseTypes, $aPhrases, $aValidTokens, $aWordFrequencyScores, $bStructuredPhrases)
653     {
654         /*
655              Calculate all searches using aValidTokens i.e.
656              'Wodsworth Road, Sheffield' =>
657
658              Phrase Wordset
659              0      0       (wodsworth road)
660              0      1       (wodsworth)(road)
661              1      0       (sheffield)
662
663              Score how good the search is so they can be ordered
664          */
665         foreach ($aPhrases as $iPhrase => $sPhrase) {
666             $aNewPhraseSearches = array();
667             if ($bStructuredPhrases) $sPhraseType = $aPhraseTypes[$iPhrase];
668             else $sPhraseType = '';
669
670             foreach ($aPhrases[$iPhrase]['wordsets'] as $iWordSet => $aWordset) {
671                 // Too many permutations - too expensive
672                 if ($iWordSet > 120) break;
673
674                 $aWordsetSearches = $aSearches;
675
676                 // Add all words from this wordset
677                 foreach ($aWordset as $iToken => $sToken) {
678                     //echo "<br><b>$sToken</b>";
679                     $aNewWordsetSearches = array();
680
681                     foreach ($aWordsetSearches as $aCurrentSearch) {
682                         //echo "<i>";
683                         //var_dump($aCurrentSearch);
684                         //echo "</i>";
685
686                         // If the token is valid
687                         if (isset($aValidTokens[' '.$sToken])) {
688                             foreach ($aValidTokens[' '.$sToken] as $aSearchTerm) {
689                                 $aSearch = $aCurrentSearch;
690                                 $aSearch['iSearchRank']++;
691                                 if (($sPhraseType == '' || $sPhraseType == 'country') && !empty($aSearchTerm['country_code']) && $aSearchTerm['country_code'] != '0') {
692                                     if ($aSearch['sCountryCode'] === false) {
693                                         $aSearch['sCountryCode'] = strtolower($aSearchTerm['country_code']);
694                                         // Country is almost always at the end of the string - increase score for finding it anywhere else (optimisation)
695                                         if (($iToken+1 != sizeof($aWordset) || $iPhrase+1 != sizeof($aPhrases))) {
696                                             $aSearch['iSearchRank'] += 5;
697                                         }
698                                         if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
699                                     }
700                                 } elseif (isset($aSearchTerm['lat']) && $aSearchTerm['lat'] !== '' && $aSearchTerm['lat'] !== null) {
701                                     if ($aSearch['fLat'] === '') {
702                                         $aSearch['fLat'] = $aSearchTerm['lat'];
703                                         $aSearch['fLon'] = $aSearchTerm['lon'];
704                                         $aSearch['fRadius'] = $aSearchTerm['radius'];
705                                         if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
706                                     }
707                                 } elseif ($sPhraseType == 'postalcode') {
708                                     // We need to try the case where the postal code is the primary element (i.e. no way to tell if it is (postalcode, city) OR (city, postalcode) so try both
709                                     if (isset($aSearchTerm['word_id']) && $aSearchTerm['word_id']) {
710                                         // If we already have a name try putting the postcode first
711                                         if (sizeof($aSearch['aName'])) {
712                                             $aNewSearch = $aSearch;
713                                             $aNewSearch['aAddress'] = array_merge($aNewSearch['aAddress'], $aNewSearch['aName']);
714                                             $aNewSearch['aName'] = array();
715                                             $aNewSearch['aName'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
716                                             if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aNewSearch;
717                                         }
718
719                                         if (sizeof($aSearch['aName'])) {
720                                             if ((!$bStructuredPhrases || $iPhrase > 0) && $sPhraseType != 'country' && (!isset($aValidTokens[$sToken]) || strpos($sToken, ' ') !== false)) {
721                                                 $aSearch['aAddress'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
722                                             } else {
723                                                 $aCurrentSearch['aFullNameAddress'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
724                                                 $aSearch['iSearchRank'] += 1000; // skip;
725                                             }
726                                         } else {
727                                             $aSearch['aName'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
728                                             //$aSearch['iNamePhrase'] = $iPhrase;
729                                         }
730                                         if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
731                                     }
732                                 } elseif (($sPhraseType == '' || $sPhraseType == 'street') && $aSearchTerm['class'] == 'place' && $aSearchTerm['type'] == 'house') {
733                                     if ($aSearch['sHouseNumber'] === '') {
734                                         $aSearch['sHouseNumber'] = $sToken;
735                                         // sanity check: if the housenumber is not mainly made
736                                         // up of numbers, add a penalty
737                                         if (preg_match_all("/[^0-9]/", $sToken, $aMatches) > 2) $aSearch['iSearchRank']++;
738                                         // also housenumbers should appear in the first or second phrase
739                                         if ($iPhrase > 1) $aSearch['iSearchRank'] += 1;
740                                         if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
741                                         /*
742                                         // Fall back to not searching for this item (better than nothing)
743                                         $aSearch = $aCurrentSearch;
744                                         $aSearch['iSearchRank'] += 1;
745                                         if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
746                                          */
747                                     }
748                                 } elseif ($sPhraseType == '' && $aSearchTerm['class'] !== '' && $aSearchTerm['class'] !== null) {
749                                     if ($aSearch['sClass'] === '') {
750                                         $aSearch['sOperator'] = $aSearchTerm['operator'];
751                                         $aSearch['sClass'] = $aSearchTerm['class'];
752                                         $aSearch['sType'] = $aSearchTerm['type'];
753                                         if (sizeof($aSearch['aName'])) $aSearch['sOperator'] = 'name';
754                                         else $aSearch['sOperator'] = 'near'; // near = in for the moment
755                                         if (strlen($aSearchTerm['operator']) == 0) $aSearch['iSearchRank'] += 1;
756
757                                         if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
758                                     }
759                                 } elseif (isset($aSearchTerm['word_id']) && $aSearchTerm['word_id']) {
760                                     if (sizeof($aSearch['aName'])) {
761                                         if ((!$bStructuredPhrases || $iPhrase > 0) && $sPhraseType != 'country' && (!isset($aValidTokens[$sToken]) || strpos($sToken, ' ') !== false)) {
762                                             $aSearch['aAddress'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
763                                         } else {
764                                             $aCurrentSearch['aFullNameAddress'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
765                                             $aSearch['iSearchRank'] += 1000; // skip;
766                                         }
767                                     } else {
768                                         $aSearch['aName'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
769                                         //$aSearch['iNamePhrase'] = $iPhrase;
770                                     }
771                                     if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
772                                 }
773                             }
774                         }
775                         // Look for partial matches.
776                         // Note that there is no point in adding country terms here
777                         // because country are omitted in the address.
778                         if (isset($aValidTokens[$sToken]) && $sPhraseType != 'country') {
779                             // Allow searching for a word - but at extra cost
780                             foreach ($aValidTokens[$sToken] as $aSearchTerm) {
781                                 if (isset($aSearchTerm['word_id']) && $aSearchTerm['word_id']) {
782                                     if ((!$bStructuredPhrases || $iPhrase > 0) && sizeof($aCurrentSearch['aName']) && strpos($sToken, ' ') === false) {
783                                         $aSearch = $aCurrentSearch;
784                                         $aSearch['iSearchRank'] += 1;
785                                         if ($aWordFrequencyScores[$aSearchTerm['word_id']] < CONST_Max_Word_Frequency) {
786                                             $aSearch['aAddress'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
787                                             if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
788                                         } elseif (isset($aValidTokens[' '.$sToken])) { // revert to the token version?
789                                             $aSearch['aAddressNonSearch'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
790                                             $aSearch['iSearchRank'] += 1;
791                                             if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
792                                             foreach ($aValidTokens[' '.$sToken] as $aSearchTermToken) {
793                                                 if (empty($aSearchTermToken['country_code'])
794                                                     && empty($aSearchTermToken['lat'])
795                                                     && empty($aSearchTermToken['class'])
796                                                 ) {
797                                                     $aSearch = $aCurrentSearch;
798                                                     $aSearch['iSearchRank'] += 1;
799                                                     $aSearch['aAddress'][$aSearchTermToken['word_id']] = $aSearchTermToken['word_id'];
800                                                     if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
801                                                 }
802                                             }
803                                         } else {
804                                             $aSearch['aAddressNonSearch'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
805                                             if (preg_match('#^[0-9]+$#', $sToken)) $aSearch['iSearchRank'] += 2;
806                                             if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
807                                         }
808                                     }
809
810                                     if (!sizeof($aCurrentSearch['aName']) || $aCurrentSearch['iNamePhrase'] == $iPhrase) {
811                                         $aSearch = $aCurrentSearch;
812                                         $aSearch['iSearchRank'] += 1;
813                                         if (!sizeof($aCurrentSearch['aName'])) $aSearch['iSearchRank'] += 1;
814                                         if (preg_match('#^[0-9]+$#', $sToken)) $aSearch['iSearchRank'] += 2;
815                                         if ($aWordFrequencyScores[$aSearchTerm['word_id']] < CONST_Max_Word_Frequency) {
816                                             $aSearch['aName'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
817                                         } else {
818                                             $aSearch['aNameNonSearch'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
819                                         }
820                                         $aSearch['iNamePhrase'] = $iPhrase;
821                                         if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
822                                     }
823                                 }
824                             }
825                         } else {
826                             // Allow skipping a word - but at EXTREAM cost
827                             //$aSearch = $aCurrentSearch;
828                             //$aSearch['iSearchRank']+=100;
829                             //$aNewWordsetSearches[] = $aSearch;
830                         }
831                     }
832                     // Sort and cut
833                     usort($aNewWordsetSearches, 'bySearchRank');
834                     $aWordsetSearches = array_slice($aNewWordsetSearches, 0, 50);
835                 }
836                 //var_Dump('<hr>',sizeof($aWordsetSearches)); exit;
837
838                 $aNewPhraseSearches = array_merge($aNewPhraseSearches, $aNewWordsetSearches);
839                 usort($aNewPhraseSearches, 'bySearchRank');
840
841                 $aSearchHash = array();
842                 foreach ($aNewPhraseSearches as $iSearch => $aSearch) {
843                     $sHash = serialize($aSearch);
844                     if (isset($aSearchHash[$sHash])) unset($aNewPhraseSearches[$iSearch]);
845                     else $aSearchHash[$sHash] = 1;
846                 }
847
848                 $aNewPhraseSearches = array_slice($aNewPhraseSearches, 0, 50);
849             }
850
851             // Re-group the searches by their score, junk anything over 20 as just not worth trying
852             $aGroupedSearches = array();
853             foreach ($aNewPhraseSearches as $aSearch) {
854                 if ($aSearch['iSearchRank'] < $this->iMaxRank) {
855                     if (!isset($aGroupedSearches[$aSearch['iSearchRank']])) $aGroupedSearches[$aSearch['iSearchRank']] = array();
856                     $aGroupedSearches[$aSearch['iSearchRank']][] = $aSearch;
857                 }
858             }
859             ksort($aGroupedSearches);
860
861             $iSearchCount = 0;
862             $aSearches = array();
863             foreach ($aGroupedSearches as $iScore => $aNewSearches) {
864                 $iSearchCount += sizeof($aNewSearches);
865                 $aSearches = array_merge($aSearches, $aNewSearches);
866                 if ($iSearchCount > 50) break;
867             }
868
869             //if (CONST_Debug) _debugDumpGroupedSearches($aGroupedSearches, $aValidTokens);
870         }
871         return $aGroupedSearches;
872     }
873
874     /* Perform the actual query lookup.
875
876         Returns an ordered list of results, each with the following fields:
877             osm_type: type of corresponding OSM object
878                         N - node
879                         W - way
880                         R - relation
881                         P - postcode (internally computed)
882             osm_id: id of corresponding OSM object
883             class: general object class (corresponds to tag key of primary OSM tag)
884             type: subclass of object (corresponds to tag value of primary OSM tag)
885             admin_level: see http://wiki.openstreetmap.org/wiki/Admin_level
886             rank_search: rank in search hierarchy
887                         (see also http://wiki.openstreetmap.org/wiki/Nominatim/Development_overview#Country_to_street_level)
888             rank_address: rank in address hierarchy (determines orer in address)
889             place_id: internal key (may differ between different instances)
890             country_code: ISO country code
891             langaddress: localized full address
892             placename: localized name of object
893             ref: content of ref tag (if available)
894             lon: longitude
895             lat: latitude
896             importance: importance of place based on Wikipedia link count
897             addressimportance: cumulated importance of address elements
898             extra_place: type of place (for admin boundaries, if there is a place tag)
899             aBoundingBox: bounding Box
900             label: short description of the object class/type (English only)
901             name: full name (currently the same as langaddress)
902             foundorder: secondary ordering for places with same importance
903     */
904
905
906     public function lookup()
907     {
908         if (!$this->sQuery && !$this->aStructuredQuery) return false;
909
910         $sLanguagePrefArraySQL = "ARRAY[".join(',', array_map("getDBQuoted", $this->aLangPrefOrder))."]";
911         $sCountryCodesSQL = false;
912         if ($this->aCountryCodes) {
913             $sCountryCodesSQL = join(',', array_map('addQuotes', $this->aCountryCodes));
914         }
915
916         $sQuery = $this->sQuery;
917         if (!preg_match('//u', $sQuery)) {
918             userError("Query string is not UTF-8 encoded.");
919         }
920
921         // Conflicts between US state abreviations and various words for 'the' in different languages
922         if (isset($this->aLangPrefOrder['name:en'])) {
923             $sQuery = preg_replace('/(^|,)\s*il\s*(,|$)/', '\1illinois\2', $sQuery);
924             $sQuery = preg_replace('/(^|,)\s*al\s*(,|$)/', '\1alabama\2', $sQuery);
925             $sQuery = preg_replace('/(^|,)\s*la\s*(,|$)/', '\1louisiana\2', $sQuery);
926         }
927
928         $bBoundingBoxSearch = $this->bBoundedSearch && $this->sViewboxSmallSQL;
929         if ($this->sViewboxCentreSQL) {
930             // For complex viewboxes (routes) precompute the bounding geometry
931             $sGeom = chksql(
932                 $this->oDB->getOne("select ".$this->sViewboxSmallSQL),
933                 "Could not get small viewbox"
934             );
935             $this->sViewboxSmallSQL = "'".$sGeom."'::geometry";
936
937             $sGeom = chksql(
938                 $this->oDB->getOne("select ".$this->sViewboxLargeSQL),
939                 "Could not get large viewbox"
940             );
941             $this->sViewboxLargeSQL = "'".$sGeom."'::geometry";
942         }
943
944         // Do we have anything that looks like a lat/lon pair?
945         if ($aLooksLike = looksLikeLatLonPair($sQuery)) {
946             $this->setNearPoint(array($aLooksLike['lat'], $aLooksLike['lon']));
947             $sQuery = $aLooksLike['query'];
948         }
949
950         $aSearchResults = array();
951         if ($sQuery || $this->aStructuredQuery) {
952             // Start with a blank search
953             $aSearches = array(
954                           array(
955                            'iSearchRank' => 0,
956                            'iNamePhrase' => -1,
957                            'sCountryCode' => false,
958                            'aName' => array(),
959                            'aAddress' => array(),
960                            'aFullNameAddress' => array(),
961                            'aNameNonSearch' => array(),
962                            'aAddressNonSearch' => array(),
963                            'sOperator' => '',
964                            'aFeatureName' => array(),
965                            'sClass' => '',
966                            'sType' => '',
967                            'sHouseNumber' => '',
968                            'fLat' => '',
969                            'fLon' => '',
970                            'fRadius' => ''
971                           )
972                          );
973
974             // Do we have a radius search?
975             $sNearPointSQL = false;
976             if ($this->aNearPoint) {
977                 $sNearPointSQL = "ST_SetSRID(ST_Point(".(float)$this->aNearPoint[1].",".(float)$this->aNearPoint[0]."),4326)";
978                 $aSearches[0]['fLat'] = (float)$this->aNearPoint[0];
979                 $aSearches[0]['fLon'] = (float)$this->aNearPoint[1];
980                 $aSearches[0]['fRadius'] = (float)$this->aNearPoint[2];
981             }
982
983             // Any 'special' terms in the search?
984             $bSpecialTerms = false;
985             preg_match_all('/\\[(.*)=(.*)\\]/', $sQuery, $aSpecialTermsRaw, PREG_SET_ORDER);
986             $aSpecialTerms = array();
987             foreach ($aSpecialTermsRaw as $aSpecialTerm) {
988                 $sQuery = str_replace($aSpecialTerm[0], ' ', $sQuery);
989                 $aSpecialTerms[strtolower($aSpecialTerm[1])] = $aSpecialTerm[2];
990             }
991
992             preg_match_all('/\\[([\\w ]*)\\]/u', $sQuery, $aSpecialTermsRaw, PREG_SET_ORDER);
993             $aSpecialTerms = array();
994             if (isset($this->aStructuredQuery['amenity']) && $this->aStructuredQuery['amenity']) {
995                 $aSpecialTermsRaw[] = array('['.$this->aStructuredQuery['amenity'].']', $this->aStructuredQuery['amenity']);
996                 unset($this->aStructuredQuery['amenity']);
997             }
998
999             foreach ($aSpecialTermsRaw as $aSpecialTerm) {
1000                 $sQuery = str_replace($aSpecialTerm[0], ' ', $sQuery);
1001                 $sToken = chksql($this->oDB->getOne("SELECT make_standard_name('".$aSpecialTerm[1]."') AS string"));
1002                 $sSQL = 'SELECT * ';
1003                 $sSQL .= 'FROM ( ';
1004                 $sSQL .= '   SELECT word_id, word_token, word, class, type, country_code, operator';
1005                 $sSQL .= '   FROM word ';
1006                 $sSQL .= '   WHERE word_token in (\' '.$sToken.'\')';
1007                 $sSQL .= ') AS x ';
1008                 $sSQL .= ' WHERE (class is not null AND class not in (\'place\')) ';
1009                 $sSQL .= ' OR country_code is not null';
1010                 if (CONST_Debug) var_Dump($sSQL);
1011                 $aSearchWords = chksql($this->oDB->getAll($sSQL));
1012                 $aNewSearches = array();
1013                 foreach ($aSearches as $aSearch) {
1014                     foreach ($aSearchWords as $aSearchTerm) {
1015                         $aNewSearch = $aSearch;
1016                         if ($aSearchTerm['country_code']) {
1017                             $aNewSearch['sCountryCode'] = strtolower($aSearchTerm['country_code']);
1018                             $aNewSearches[] = $aNewSearch;
1019                             $bSpecialTerms = true;
1020                         }
1021                         if ($aSearchTerm['class']) {
1022                             $aNewSearch['sClass'] = $aSearchTerm['class'];
1023                             $aNewSearch['sType'] = $aSearchTerm['type'];
1024                             $aNewSearches[] = $aNewSearch;
1025                             $bSpecialTerms = true;
1026                         }
1027                     }
1028                 }
1029                 $aSearches = $aNewSearches;
1030             }
1031
1032             // Split query into phrases
1033             // Commas are used to reduce the search space by indicating where phrases split
1034             if ($this->aStructuredQuery) {
1035                 $aPhrases = $this->aStructuredQuery;
1036                 $bStructuredPhrases = true;
1037             } else {
1038                 $aPhrases = explode(',', $sQuery);
1039                 $bStructuredPhrases = false;
1040             }
1041
1042             // Convert each phrase to standard form
1043             // Create a list of standard words
1044             // Get all 'sets' of words
1045             // Generate a complete list of all
1046             $aTokens = array();
1047             foreach ($aPhrases as $iPhrase => $sPhrase) {
1048                 $aPhrase = chksql(
1049                     $this->oDB->getRow("SELECT make_standard_name('".pg_escape_string($sPhrase)."') as string"),
1050                     "Cannot normalize query string (is it a UTF-8 string?)"
1051                 );
1052                 if (trim($aPhrase['string'])) {
1053                     $aPhrases[$iPhrase] = $aPhrase;
1054                     $aPhrases[$iPhrase]['words'] = explode(' ', $aPhrases[$iPhrase]['string']);
1055                     $aPhrases[$iPhrase]['wordsets'] = getWordSets($aPhrases[$iPhrase]['words'], 0);
1056                     $aTokens = array_merge($aTokens, getTokensFromSets($aPhrases[$iPhrase]['wordsets']));
1057                 } else {
1058                     unset($aPhrases[$iPhrase]);
1059                 }
1060             }
1061
1062             // Reindex phrases - we make assumptions later on that they are numerically keyed in order
1063             $aPhraseTypes = array_keys($aPhrases);
1064             $aPhrases = array_values($aPhrases);
1065
1066             if (sizeof($aTokens)) {
1067                 // Check which tokens we have, get the ID numbers
1068                 $sSQL = 'SELECT word_id, word_token, word, class, type, country_code, operator, search_name_count';
1069                 $sSQL .= ' FROM word ';
1070                 $sSQL .= ' WHERE word_token in ('.join(',', array_map("getDBQuoted", $aTokens)).')';
1071
1072                 if (CONST_Debug) var_Dump($sSQL);
1073
1074                 $aValidTokens = array();
1075                 if (sizeof($aTokens)) {
1076                     $aDatabaseWords = chksql(
1077                         $this->oDB->getAll($sSQL),
1078                         "Could not get word tokens."
1079                     );
1080                 } else {
1081                     $aDatabaseWords = array();
1082                 }
1083                 $aPossibleMainWordIDs = array();
1084                 $aWordFrequencyScores = array();
1085                 foreach ($aDatabaseWords as $aToken) {
1086                     // Very special case - require 2 letter country param to match the country code found
1087                     if ($bStructuredPhrases && $aToken['country_code'] && !empty($this->aStructuredQuery['country'])
1088                         && strlen($this->aStructuredQuery['country']) == 2 && strtolower($this->aStructuredQuery['country']) != $aToken['country_code']
1089                     ) {
1090                         continue;
1091                     }
1092
1093                     if (isset($aValidTokens[$aToken['word_token']])) {
1094                         $aValidTokens[$aToken['word_token']][] = $aToken;
1095                     } else {
1096                         $aValidTokens[$aToken['word_token']] = array($aToken);
1097                     }
1098                     if (!$aToken['class'] && !$aToken['country_code']) $aPossibleMainWordIDs[$aToken['word_id']] = 1;
1099                     $aWordFrequencyScores[$aToken['word_id']] = $aToken['search_name_count'] + 1;
1100                 }
1101                 if (CONST_Debug) var_Dump($aPhrases, $aValidTokens);
1102
1103                 // Try and calculate GB postcodes we might be missing
1104                 foreach ($aTokens as $sToken) {
1105                     // Source of gb postcodes is now definitive - always use
1106                     if (preg_match('/^([A-Z][A-Z]?[0-9][0-9A-Z]? ?[0-9])([A-Z][A-Z])$/', strtoupper(trim($sToken)), $aData)) {
1107                         if (substr($aData[1], -2, 1) != ' ') {
1108                             $aData[0] = substr($aData[0], 0, strlen($aData[1])-1).' '.substr($aData[0], strlen($aData[1])-1);
1109                             $aData[1] = substr($aData[1], 0, -1).' '.substr($aData[1], -1, 1);
1110                         }
1111                         $aGBPostcodeLocation = gbPostcodeCalculate($aData[0], $aData[1], $aData[2], $this->oDB);
1112                         if ($aGBPostcodeLocation) {
1113                             $aValidTokens[$sToken] = $aGBPostcodeLocation;
1114                         }
1115                     } elseif (!isset($aValidTokens[$sToken]) && preg_match('/^([0-9]{5}) [0-9]{4}$/', $sToken, $aData)) {
1116                         // US ZIP+4 codes - if there is no token,
1117                         // merge in the 5-digit ZIP code
1118                         if (isset($aValidTokens[$aData[1]])) {
1119                             foreach ($aValidTokens[$aData[1]] as $aToken) {
1120                                 if (!$aToken['class']) {
1121                                     if (isset($aValidTokens[$sToken])) {
1122                                         $aValidTokens[$sToken][] = $aToken;
1123                                     } else {
1124                                         $aValidTokens[$sToken] = array($aToken);
1125                                     }
1126                                 }
1127                             }
1128                         }
1129                     }
1130                 }
1131
1132                 foreach ($aTokens as $sToken) {
1133                     // Unknown single word token with a number - assume it is a house number
1134                     if (!isset($aValidTokens[' '.$sToken]) && strpos($sToken, ' ') === false && preg_match('/[0-9]/', $sToken)) {
1135                         $aValidTokens[' '.$sToken] = array(array('class' => 'place', 'type' => 'house'));
1136                     }
1137                 }
1138
1139                 // Any words that have failed completely?
1140                 // TODO: suggestions
1141
1142                 // Start the search process
1143                 // array with: placeid => -1 | tiger-housenumber
1144                 $aResultPlaceIDs = array();
1145
1146                 $aGroupedSearches = $this->getGroupedSearches($aSearches, $aPhraseTypes, $aPhrases, $aValidTokens, $aWordFrequencyScores, $bStructuredPhrases);
1147
1148                 if ($this->bReverseInPlan) {
1149                     // Reverse phrase array and also reverse the order of the wordsets in
1150                     // the first and final phrase. Don't bother about phrases in the middle
1151                     // because order in the address doesn't matter.
1152                     $aPhrases = array_reverse($aPhrases);
1153                     $aPhrases[0]['wordsets'] = getInverseWordSets($aPhrases[0]['words'], 0);
1154                     if (sizeof($aPhrases) > 1) {
1155                         $aFinalPhrase = end($aPhrases);
1156                         $aPhrases[sizeof($aPhrases)-1]['wordsets'] = getInverseWordSets($aFinalPhrase['words'], 0);
1157                     }
1158                     $aReverseGroupedSearches = $this->getGroupedSearches($aSearches, null, $aPhrases, $aValidTokens, $aWordFrequencyScores, false);
1159
1160                     foreach ($aGroupedSearches as $aSearches) {
1161                         foreach ($aSearches as $aSearch) {
1162                             if ($aSearch['iSearchRank'] < $this->iMaxRank) {
1163                                 if (!isset($aReverseGroupedSearches[$aSearch['iSearchRank']])) $aReverseGroupedSearches[$aSearch['iSearchRank']] = array();
1164                                 $aReverseGroupedSearches[$aSearch['iSearchRank']][] = $aSearch;
1165                             }
1166                         }
1167                     }
1168
1169                     $aGroupedSearches = $aReverseGroupedSearches;
1170                     ksort($aGroupedSearches);
1171                 }
1172             } else {
1173                 // Re-group the searches by their score, junk anything over 20 as just not worth trying
1174                 $aGroupedSearches = array();
1175                 foreach ($aSearches as $aSearch) {
1176                     if ($aSearch['iSearchRank'] < $this->iMaxRank) {
1177                         if (!isset($aGroupedSearches[$aSearch['iSearchRank']])) $aGroupedSearches[$aSearch['iSearchRank']] = array();
1178                         $aGroupedSearches[$aSearch['iSearchRank']][] = $aSearch;
1179                     }
1180                 }
1181                 ksort($aGroupedSearches);
1182             }
1183
1184             if (CONST_Debug) var_Dump($aGroupedSearches);
1185             if (CONST_Search_TryDroppedAddressTerms && sizeof($this->aStructuredQuery) > 0) {
1186                 $aCopyGroupedSearches = $aGroupedSearches;
1187                 foreach ($aCopyGroupedSearches as $iGroup => $aSearches) {
1188                     foreach ($aSearches as $iSearch => $aSearch) {
1189                         $aReductionsList = array($aSearch['aAddress']);
1190                         $iSearchRank = $aSearch['iSearchRank'];
1191                         while (sizeof($aReductionsList) > 0) {
1192                             $iSearchRank += 5;
1193                             if ($iSearchRank > iMaxRank) break 3;
1194                             $aNewReductionsList = array();
1195                             foreach ($aReductionsList as $aReductionsWordList) {
1196                                 for ($iReductionWord = 0; $iReductionWord < sizeof($aReductionsWordList); $iReductionWord++) {
1197                                     $aReductionsWordListResult = array_merge(array_slice($aReductionsWordList, 0, $iReductionWord), array_slice($aReductionsWordList, $iReductionWord+1));
1198                                     $aReverseSearch = $aSearch;
1199                                     $aSearch['aAddress'] = $aReductionsWordListResult;
1200                                     $aSearch['iSearchRank'] = $iSearchRank;
1201                                     $aGroupedSearches[$iSearchRank][] = $aReverseSearch;
1202                                     if (sizeof($aReductionsWordListResult) > 0) {
1203                                         $aNewReductionsList[] = $aReductionsWordListResult;
1204                                     }
1205                                 }
1206                             }
1207                             $aReductionsList = $aNewReductionsList;
1208                         }
1209                     }
1210                 }
1211                 ksort($aGroupedSearches);
1212             }
1213
1214             // Filter out duplicate searches
1215             $aSearchHash = array();
1216             foreach ($aGroupedSearches as $iGroup => $aSearches) {
1217                 foreach ($aSearches as $iSearch => $aSearch) {
1218                     $sHash = serialize($aSearch);
1219                     if (isset($aSearchHash[$sHash])) {
1220                         unset($aGroupedSearches[$iGroup][$iSearch]);
1221                         if (sizeof($aGroupedSearches[$iGroup]) == 0) unset($aGroupedSearches[$iGroup]);
1222                     } else {
1223                         $aSearchHash[$sHash] = 1;
1224                     }
1225                 }
1226             }
1227
1228             if (CONST_Debug) _debugDumpGroupedSearches($aGroupedSearches, $aValidTokens);
1229
1230             $iGroupLoop = 0;
1231             $iQueryLoop = 0;
1232             foreach ($aGroupedSearches as $iGroupedRank => $aSearches) {
1233                 $iGroupLoop++;
1234                 foreach ($aSearches as $aSearch) {
1235                     $iQueryLoop++;
1236                     $searchedHousenumber = -1;
1237
1238                     if (CONST_Debug) echo "<hr><b>Search Loop, group $iGroupLoop, loop $iQueryLoop</b>";
1239                     if (CONST_Debug) _debugDumpGroupedSearches(array($iGroupedRank => array($aSearch)), $aValidTokens);
1240
1241                     // No location term?
1242                     if (!sizeof($aSearch['aName']) && !sizeof($aSearch['aAddress']) && !$aSearch['fLon']) {
1243                         if ($aSearch['sCountryCode'] && !$aSearch['sClass'] && !$aSearch['sHouseNumber']) {
1244                             // Just looking for a country by code - look it up
1245                             if (4 >= $this->iMinAddressRank && 4 <= $this->iMaxAddressRank) {
1246                                 $sSQL = "SELECT place_id FROM placex WHERE calculated_country_code='".$aSearch['sCountryCode']."' AND rank_search = 4";
1247                                 if ($sCountryCodesSQL) $sSQL .= " AND calculated_country_code in ($sCountryCodesSQL)";
1248                                 if ($bBoundingBoxSearch)
1249                                     $sSQL .= " AND _st_intersects($this->sViewboxSmallSQL, geometry)";
1250                                 $sSQL .= " ORDER BY st_area(geometry) DESC LIMIT 1";
1251                                 if (CONST_Debug) var_dump($sSQL);
1252                                 $aPlaceIDs = chksql($this->oDB->getCol($sSQL));
1253                             } else {
1254                                 $aPlaceIDs = array();
1255                             }
1256                         } else {
1257                             if (!$bBoundingBoxSearch && !$aSearch['fLon']) continue;
1258                             if (!$aSearch['sClass']) continue;
1259
1260                             $sSQL = "SELECT COUNT(*) FROM pg_tables WHERE tablename = 'place_classtype_".$aSearch['sClass']."_".$aSearch['sType']."'";
1261                             if (chksql($this->oDB->getOne($sSQL))) {
1262                                 $sSQL = "SELECT place_id FROM place_classtype_".$aSearch['sClass']."_".$aSearch['sType']." ct";
1263                                 if ($sCountryCodesSQL) $sSQL .= " JOIN placex USING (place_id)";
1264                                 $sSQL .= " WHERE st_contains($this->sViewboxSmallSQL, ct.centroid)";
1265                                 if ($sCountryCodesSQL) $sSQL .= " AND calculated_country_code in ($sCountryCodesSQL)";
1266                                 if (sizeof($this->aExcludePlaceIDs)) {
1267                                     $sSQL .= " AND place_id not in (".join(',', $this->aExcludePlaceIDs).")";
1268                                 }
1269                                 if ($this->sViewboxCentreSQL) $sSQL .= " ORDER BY ST_Distance($this->sViewboxCentreSQL, ct.centroid) ASC";
1270                                 $sSQL .= " limit $this->iLimit";
1271                                 if (CONST_Debug) var_dump($sSQL);
1272                                 $aPlaceIDs = chksql($this->oDB->getCol($sSQL));
1273
1274                                 // If excluded place IDs are given, it is fair to assume that
1275                                 // there have been results in the small box, so no further
1276                                 // expansion in that case.
1277                                 // Also don't expand if bounded results were requested.
1278                                 if (!sizeof($aPlaceIDs) && !sizeof($this->aExcludePlaceIDs) && !$this->bBoundedSearch) {
1279                                     $sSQL = "SELECT place_id FROM place_classtype_".$aSearch['sClass']."_".$aSearch['sType']." ct";
1280                                     if ($sCountryCodesSQL) $sSQL .= " join placex using (place_id)";
1281                                     $sSQL .= " WHERE ST_Contains($this->sViewboxLargeSQL, ct.centroid)";
1282                                     if ($sCountryCodesSQL) $sSQL .= " AND calculated_country_code in ($sCountryCodesSQL)";
1283                                     if ($this->sViewboxCentreSQL) $sSQL .= " ORDER BY ST_Distance($this->sViewboxCentreSQL, ct.centroid) ASC";
1284                                     $sSQL .= " LIMIT $this->iLimit";
1285                                     if (CONST_Debug) var_dump($sSQL);
1286                                     $aPlaceIDs = chksql($this->oDB->getCol($sSQL));
1287                                 }
1288                             } else {
1289                                 $sSQL = "SELECT place_id ";
1290                                 $sSQL .= "FROM placex ";
1291                                 $sSQL .= "WHERE class='".$aSearch['sClass']."' ";
1292                                 $sSQL .= "  AND type='".$aSearch['sType']."'";
1293                                 $sSQL .= "  AND ST_Contains($this->sViewboxSmallSQL, geometry) ";
1294                                 $sSQL .= "  AND linked_place_id is null";
1295                                 if ($sCountryCodesSQL) $sSQL .= " AND calculated_country_code in ($sCountryCodesSQL)";
1296                                 if ($this->sViewboxCentreSQL)   $sSQL .= " ORDER BY ST_Distance($this->sViewboxCentreSQL, centroid) ASC";
1297                                 $sSQL .= " LIMIT $this->iLimit";
1298                                 if (CONST_Debug) var_dump($sSQL);
1299                                 $aPlaceIDs = chksql($this->oDB->getCol($sSQL));
1300                             }
1301                         }
1302                     } elseif ($aSearch['fLon'] && !sizeof($aSearch['aName']) && !sizeof($aSearch['aAddress']) && !$aSearch['sClass']) {
1303                         // If a coordinate is given, the search must either
1304                         // be for a name or a special search. Ignore everythin else.
1305                         $aPlaceIDs = array();
1306                     } else {
1307                         $aPlaceIDs = array();
1308
1309                         // First we need a position, either aName or fLat or both
1310                         $aTerms = array();
1311                         $aOrder = array();
1312
1313                         if ($aSearch['sHouseNumber'] && sizeof($aSearch['aAddress'])) {
1314                             $sHouseNumberRegex = '\\\\m'.$aSearch['sHouseNumber'].'\\\\M';
1315                             $aOrder[] = "";
1316                             $aOrder[0] = "  (";
1317                             $aOrder[0] .= "   EXISTS(";
1318                             $aOrder[0] .= "     SELECT place_id ";
1319                             $aOrder[0] .= "     FROM placex ";
1320                             $aOrder[0] .= "     WHERE parent_place_id = search_name.place_id";
1321                             $aOrder[0] .= "       AND transliteration(housenumber) ~* E'".$sHouseNumberRegex."' ";
1322                             $aOrder[0] .= "     LIMIT 1";
1323                             $aOrder[0] .= "   ) ";
1324                             // also housenumbers from interpolation lines table are needed
1325                             $aOrder[0] .= "   OR EXISTS(";
1326                             $aOrder[0] .= "     SELECT place_id ";
1327                             $aOrder[0] .= "     FROM location_property_osmline ";
1328                             $aOrder[0] .= "     WHERE parent_place_id = search_name.place_id";
1329                             $aOrder[0] .= "       AND ".intval($aSearch['sHouseNumber']).">=startnumber ";
1330                             $aOrder[0] .= "       AND ".intval($aSearch['sHouseNumber'])."<=endnumber ";
1331                             $aOrder[0] .= "     LIMIT 1";
1332                             $aOrder[0] .= "   )";
1333                             $aOrder[0] .= " )";
1334                             $aOrder[0] .= " DESC";
1335                         }
1336
1337                         // TODO: filter out the pointless search terms (2 letter name tokens and less)
1338                         // they might be right - but they are just too darned expensive to run
1339                         if (sizeof($aSearch['aName'])) $aTerms[] = "name_vector @> ARRAY[".join($aSearch['aName'], ",")."]";
1340                         if (sizeof($aSearch['aNameNonSearch'])) $aTerms[] = "array_cat(name_vector,ARRAY[]::integer[]) @> ARRAY[".join($aSearch['aNameNonSearch'], ",")."]";
1341                         if (sizeof($aSearch['aAddress']) && $aSearch['aName'] != $aSearch['aAddress']) {
1342                             // For infrequent name terms disable index usage for address
1343                             if (CONST_Search_NameOnlySearchFrequencyThreshold
1344                                 && sizeof($aSearch['aName']) == 1
1345                                 && $aWordFrequencyScores[$aSearch['aName'][reset($aSearch['aName'])]] < CONST_Search_NameOnlySearchFrequencyThreshold
1346                             ) {
1347                                 $aTerms[] = "array_cat(nameaddress_vector,ARRAY[]::integer[]) @> ARRAY[".join(array_merge($aSearch['aAddress'], $aSearch['aAddressNonSearch']), ",")."]";
1348                             } else {
1349                                 $aTerms[] = "nameaddress_vector @> ARRAY[".join($aSearch['aAddress'], ",")."]";
1350                                 if (sizeof($aSearch['aAddressNonSearch'])) {
1351                                     $aTerms[] = "array_cat(nameaddress_vector,ARRAY[]::integer[]) @> ARRAY[".join($aSearch['aAddressNonSearch'], ",")."]";
1352                                 }
1353                             }
1354                         }
1355                         if ($aSearch['sCountryCode']) $aTerms[] = "country_code = '".pg_escape_string($aSearch['sCountryCode'])."'";
1356                         if ($aSearch['sHouseNumber']) {
1357                             $aTerms[] = "address_rank between 16 and 27";
1358                         } else {
1359                             if ($this->iMinAddressRank > 0) {
1360                                 $aTerms[] = "address_rank >= ".$this->iMinAddressRank;
1361                             }
1362                             if ($this->iMaxAddressRank < 30) {
1363                                 $aTerms[] = "address_rank <= ".$this->iMaxAddressRank;
1364                             }
1365                         }
1366                         if ($aSearch['fLon'] && $aSearch['fLat']) {
1367                             $aTerms[] = sprintf(
1368                                 'ST_DWithin(centroid, ST_SetSRID(ST_Point(%F,%F),4326), %F)',
1369                                 $aSearch['fLon'],
1370                                 $aSearch['fLat'],
1371                                 $aSearch['fRadius']
1372                             );
1373
1374                             $aOrder[] = "ST_Distance(centroid, ST_SetSRID(ST_Point(".$aSearch['fLon'].",".$aSearch['fLat']."),4326)) ASC";
1375                         }
1376                         if (sizeof($this->aExcludePlaceIDs)) {
1377                             $aTerms[] = "place_id not in (".join(',', $this->aExcludePlaceIDs).")";
1378                         }
1379                         if ($sCountryCodesSQL) {
1380                             $aTerms[] = "country_code in ($sCountryCodesSQL)";
1381                         }
1382
1383                         if ($bBoundingBoxSearch) $aTerms[] = "centroid && $this->sViewboxSmallSQL";
1384                         if ($sNearPointSQL) $aOrder[] = "ST_Distance($sNearPointSQL, centroid) ASC";
1385
1386                         if ($aSearch['sHouseNumber']) {
1387                             $sImportanceSQL = '- abs(26 - address_rank) + 3';
1388                         } else {
1389                             $sImportanceSQL = '(CASE WHEN importance = 0 OR importance IS NULL THEN 0.75-(search_rank::float/40) ELSE importance END)';
1390                         }
1391                         if ($this->sViewboxSmallSQL) $sImportanceSQL .= " * CASE WHEN ST_Contains($this->sViewboxSmallSQL, centroid) THEN 1 ELSE 0.5 END";
1392                         if ($this->sViewboxLargeSQL) $sImportanceSQL .= " * CASE WHEN ST_Contains($this->sViewboxLargeSQL, centroid) THEN 1 ELSE 0.5 END";
1393
1394                         $aOrder[] = "$sImportanceSQL DESC";
1395                         if (sizeof($aSearch['aFullNameAddress'])) {
1396                             $sExactMatchSQL = ' ( ';
1397                             $sExactMatchSQL .= '   SELECT count(*) FROM ( ';
1398                             $sExactMatchSQL .= '      SELECT unnest(ARRAY['.join($aSearch['aFullNameAddress'], ",").']) ';
1399                             $sExactMatchSQL .= '      INTERSECT ';
1400                             $sExactMatchSQL .= '      SELECT unnest(nameaddress_vector)';
1401                             $sExactMatchSQL .= '   ) s';
1402                             $sExactMatchSQL .= ') as exactmatch';
1403                             $aOrder[] = 'exactmatch DESC';
1404                         } else {
1405                             $sExactMatchSQL = '0::int as exactmatch';
1406                         }
1407
1408                         if (sizeof($aTerms)) {
1409                             $sSQL = "SELECT place_id, ";
1410                             $sSQL .= $sExactMatchSQL;
1411                             $sSQL .= " FROM search_name";
1412                             $sSQL .= " WHERE ".join(' and ', $aTerms);
1413                             $sSQL .= " ORDER BY ".join(', ', $aOrder);
1414                             if ($aSearch['sHouseNumber'] || $aSearch['sClass']) {
1415                                 $sSQL .= " LIMIT 20";
1416                             } elseif (!sizeof($aSearch['aName']) && !sizeof($aSearch['aAddress']) && $aSearch['sClass']) {
1417                                 $sSQL .= " LIMIT 1";
1418                             } else {
1419                                 $sSQL .= " LIMIT ".$this->iLimit;
1420                             }
1421
1422                             if (CONST_Debug) var_dump($sSQL);
1423                             $aViewBoxPlaceIDs = chksql(
1424                                 $this->oDB->getAll($sSQL),
1425                                 "Could not get places for search terms."
1426                             );
1427                             //var_dump($aViewBoxPlaceIDs);
1428                             // Did we have an viewbox matches?
1429                             $aPlaceIDs = array();
1430                             $bViewBoxMatch = false;
1431                             foreach ($aViewBoxPlaceIDs as $aViewBoxRow) {
1432                                 //if ($bViewBoxMatch == 1 && $aViewBoxRow['in_small'] == 'f') break;
1433                                 //if ($bViewBoxMatch == 2 && $aViewBoxRow['in_large'] == 'f') break;
1434                                 //if ($aViewBoxRow['in_small'] == 't') $bViewBoxMatch = 1;
1435                                 //else if ($aViewBoxRow['in_large'] == 't') $bViewBoxMatch = 2;
1436                                 $aPlaceIDs[] = $aViewBoxRow['place_id'];
1437                                 $this->exactMatchCache[$aViewBoxRow['place_id']] = $aViewBoxRow['exactmatch'];
1438                             }
1439                         }
1440                         //var_Dump($aPlaceIDs);
1441                         //exit;
1442
1443                         //now search for housenumber, if housenumber provided
1444                         if ($aSearch['sHouseNumber'] && sizeof($aPlaceIDs)) {
1445                             $searchedHousenumber = intval($aSearch['sHouseNumber']);
1446                             $aRoadPlaceIDs = $aPlaceIDs;
1447                             $sPlaceIDs = join(',', $aPlaceIDs);
1448
1449                             // Now they are indexed, look for a house attached to a street we found
1450                             $sHouseNumberRegex = '\\\\m'.$aSearch['sHouseNumber'].'\\\\M';
1451                             $sSQL = "SELECT place_id FROM placex ";
1452                             $sSQL .= "WHERE parent_place_id in (".$sPlaceIDs.") and transliteration(housenumber) ~* E'".$sHouseNumberRegex."'";
1453                             if (sizeof($this->aExcludePlaceIDs)) {
1454                                 $sSQL .= " AND place_id not in (".join(',', $this->aExcludePlaceIDs).")";
1455                             }
1456                             $sSQL .= " LIMIT $this->iLimit";
1457                             if (CONST_Debug) var_dump($sSQL);
1458                             $aPlaceIDs = chksql($this->oDB->getCol($sSQL));
1459
1460                             // if nothing found, search in the interpolation line table
1461                             if (!sizeof($aPlaceIDs)) {
1462                                 // do we need to use transliteration and the regex for housenumbers???
1463                                 //new query for lines, not housenumbers anymore
1464                                 $sSQL = "SELECT distinct place_id FROM location_property_osmline";
1465                                 $sSQL .= " WHERE parent_place_id in (".$sPlaceIDs.") and (";
1466                                 if ($searchedHousenumber%2 == 0) {
1467                                     //if housenumber is even, look for housenumber in streets with interpolationtype even or all
1468                                     $sSQL .= "interpolationtype='even'";
1469                                 } else {
1470                                     //look for housenumber in streets with interpolationtype odd or all
1471                                     $sSQL .= "interpolationtype='odd'";
1472                                 }
1473                                 $sSQL .= " or interpolationtype='all') and ";
1474                                 $sSQL .= $searchedHousenumber.">=startnumber and ";
1475                                 $sSQL .= $searchedHousenumber."<=endnumber";
1476
1477                                 if (sizeof($this->aExcludePlaceIDs)) {
1478                                     $sSQL .= " AND place_id not in (".join(',', $this->aExcludePlaceIDs).")";
1479                                 }
1480                                 //$sSQL .= " limit $this->iLimit";
1481                                 if (CONST_Debug) var_dump($sSQL);
1482                                 //get place IDs
1483                                 $aPlaceIDs = chksql($this->oDB->getCol($sSQL, 0));
1484                             }
1485
1486                             // If nothing found try the aux fallback table
1487                             if (CONST_Use_Aux_Location_data && !sizeof($aPlaceIDs)) {
1488                                 $sSQL = "SELECT place_id FROM location_property_aux ";
1489                                 $sSQL .= " WHERE parent_place_id in (".$sPlaceIDs.") ";
1490                                 $sSQL .= " AND housenumber = '".pg_escape_string($aSearch['sHouseNumber'])."'";
1491                                 if (sizeof($this->aExcludePlaceIDs)) {
1492                                     $sSQL .= " AND parent_place_id not in (".join(',', $this->aExcludePlaceIDs).")";
1493                                 }
1494                                 //$sSQL .= " limit $this->iLimit";
1495                                 if (CONST_Debug) var_dump($sSQL);
1496                                 $aPlaceIDs = chksql($this->oDB->getCol($sSQL));
1497                             }
1498
1499                             //if nothing was found in placex or location_property_aux, then search in Tiger data for this housenumber(location_property_tiger)
1500                             if (CONST_Use_US_Tiger_Data && !sizeof($aPlaceIDs)) {
1501                                 $sSQL = "SELECT distinct place_id FROM location_property_tiger";
1502                                 $sSQL .= " WHERE parent_place_id in (".$sPlaceIDs.") and (";
1503                                 if ($searchedHousenumber%2 == 0) {
1504                                     $sSQL .= "interpolationtype='even'";
1505                                 } else {
1506                                     $sSQL .= "interpolationtype='odd'";
1507                                 }
1508                                 $sSQL .= " or interpolationtype='all') and ";
1509                                 $sSQL .= $searchedHousenumber.">=startnumber and ";
1510                                 $sSQL .= $searchedHousenumber."<=endnumber";
1511
1512                                 if (sizeof($this->aExcludePlaceIDs)) {
1513                                     $sSQL .= " AND place_id not in (".join(',', $this->aExcludePlaceIDs).")";
1514                                 }
1515                                 //$sSQL .= " limit $this->iLimit";
1516                                 if (CONST_Debug) var_dump($sSQL);
1517                                 //get place IDs
1518                                 $aPlaceIDs = chksql($this->oDB->getCol($sSQL, 0));
1519                             }
1520
1521                             // Fallback to the road (if no housenumber was found)
1522                             if (!sizeof($aPlaceIDs) && preg_match('/[0-9]+/', $aSearch['sHouseNumber'])) {
1523                                 $aPlaceIDs = $aRoadPlaceIDs;
1524                                 //set to -1, if no housenumbers were found
1525                                 $searchedHousenumber = -1;
1526                             }
1527                             //else: housenumber was found, remains saved in searchedHousenumber
1528                         }
1529
1530
1531                         if ($aSearch['sClass'] && sizeof($aPlaceIDs)) {
1532                             $sPlaceIDs = join(',', $aPlaceIDs);
1533                             $aClassPlaceIDs = array();
1534
1535                             if (!$aSearch['sOperator'] || $aSearch['sOperator'] == 'name') {
1536                                 // If they were searching for a named class (i.e. 'Kings Head pub') then we might have an extra match
1537                                 $sSQL = "SELECT place_id ";
1538                                 $sSQL .= " FROM placex ";
1539                                 $sSQL .= " WHERE place_id in ($sPlaceIDs) ";
1540                                 $sSQL .= "   AND class='".$aSearch['sClass']."' ";
1541                                 $sSQL .= "   AND type='".$aSearch['sType']."'";
1542                                 $sSQL .= "   AND linked_place_id is null";
1543                                 if ($sCountryCodesSQL) $sSQL .= " AND calculated_country_code in ($sCountryCodesSQL)";
1544                                 $sSQL .= " ORDER BY rank_search ASC ";
1545                                 $sSQL .= " LIMIT $this->iLimit";
1546                                 if (CONST_Debug) var_dump($sSQL);
1547                                 $aClassPlaceIDs = chksql($this->oDB->getCol($sSQL));
1548                             }
1549
1550                             if (!$aSearch['sOperator'] || $aSearch['sOperator'] == 'near') { // & in
1551                                 $sSQL = "SELECT count(*) FROM pg_tables ";
1552                                 $sSQL .= "WHERE tablename = 'place_classtype_".$aSearch['sClass']."_".$aSearch['sType']."'";
1553                                 $bCacheTable = chksql($this->oDB->getOne($sSQL));
1554
1555                                 $sSQL = "SELECT min(rank_search) FROM placex WHERE place_id in ($sPlaceIDs)";
1556
1557                                 if (CONST_Debug) var_dump($sSQL);
1558                                 $this->iMaxRank = ((int)chksql($this->oDB->getOne($sSQL)));
1559
1560                                 // For state / country level searches the normal radius search doesn't work very well
1561                                 $sPlaceGeom = false;
1562                                 if ($this->iMaxRank < 9 && $bCacheTable) {
1563                                     // Try and get a polygon to search in instead
1564                                     $sSQL = "SELECT geometry ";
1565                                     $sSQL .= " FROM placex";
1566                                     $sSQL .= " WHERE place_id in ($sPlaceIDs)";
1567                                     $sSQL .= "   AND rank_search < $this->iMaxRank + 5";
1568                                     $sSQL .= "   AND ST_Geometrytype(geometry) in ('ST_Polygon','ST_MultiPolygon')";
1569                                     $sSQL .= " ORDER BY rank_search ASC ";
1570                                     $sSQL .= " LIMIT 1";
1571                                     if (CONST_Debug) var_dump($sSQL);
1572                                     $sPlaceGeom = chksql($this->oDB->getOne($sSQL));
1573                                 }
1574
1575                                 if ($sPlaceGeom) {
1576                                     $sPlaceIDs = false;
1577                                 } else {
1578                                     $this->iMaxRank += 5;
1579                                     $sSQL = "SELECT place_id FROM placex WHERE place_id in ($sPlaceIDs) and rank_search < $this->iMaxRank";
1580                                     if (CONST_Debug) var_dump($sSQL);
1581                                     $aPlaceIDs = chksql($this->oDB->getCol($sSQL));
1582                                     $sPlaceIDs = join(',', $aPlaceIDs);
1583                                 }
1584
1585                                 if ($sPlaceIDs || $sPlaceGeom) {
1586                                     $fRange = 0.01;
1587                                     if ($bCacheTable) {
1588                                         // More efficient - can make the range bigger
1589                                         $fRange = 0.05;
1590
1591                                         $sOrderBySQL = '';
1592                                         if ($sNearPointSQL) $sOrderBySQL = "ST_Distance($sNearPointSQL, l.centroid)";
1593                                         elseif ($sPlaceIDs) $sOrderBySQL = "ST_Distance(l.centroid, f.geometry)";
1594                                         elseif ($sPlaceGeom) $sOrderBysSQL = "ST_Distance(st_centroid('".$sPlaceGeom."'), l.centroid)";
1595
1596                                         $sSQL = "select distinct l.place_id".($sOrderBySQL?','.$sOrderBySQL:'')." from place_classtype_".$aSearch['sClass']."_".$aSearch['sType']." as l";
1597                                         if ($sCountryCodesSQL) $sSQL .= " join placex as lp using (place_id)";
1598                                         if ($sPlaceIDs) {
1599                                             $sSQL .= ",placex as f where ";
1600                                             $sSQL .= "f.place_id in ($sPlaceIDs) and ST_DWithin(l.centroid, f.centroid, $fRange) ";
1601                                         }
1602                                         if ($sPlaceGeom) {
1603                                             $sSQL .= " where ";
1604                                             $sSQL .= "ST_Contains('".$sPlaceGeom."', l.centroid) ";
1605                                         }
1606                                         if (sizeof($this->aExcludePlaceIDs)) {
1607                                             $sSQL .= " and l.place_id not in (".join(',', $this->aExcludePlaceIDs).")";
1608                                         }
1609                                         if ($sCountryCodesSQL) $sSQL .= " and lp.calculated_country_code in ($sCountryCodesSQL)";
1610                                         if ($sOrderBySQL) $sSQL .= "order by ".$sOrderBySQL." asc";
1611                                         if ($this->iOffset) $sSQL .= " offset $this->iOffset";
1612                                         $sSQL .= " limit $this->iLimit";
1613                                         if (CONST_Debug) var_dump($sSQL);
1614                                         $aClassPlaceIDs = array_merge($aClassPlaceIDs, chksql($this->oDB->getCol($sSQL)));
1615                                     } else {
1616                                         if (isset($aSearch['fRadius']) && $aSearch['fRadius']) $fRange = $aSearch['fRadius'];
1617
1618                                         $sOrderBySQL = '';
1619                                         if ($sNearPointSQL) $sOrderBySQL = "ST_Distance($sNearPointSQL, l.geometry)";
1620                                         else $sOrderBySQL = "ST_Distance(l.geometry, f.geometry)";
1621
1622                                         $sSQL = "SELECT distinct l.place_id".($sOrderBysSQL?','.$sOrderBysSQL:'');
1623                                         $sSQL .= " FROM placex as l, placex as f ";
1624                                         $sSQL .= " WHERE f.place_id in ($sPlaceIDs) ";
1625                                         $sSQL .= "  AND ST_DWithin(l.geometry, f.centroid, $fRange) ";
1626                                         $sSQL .= "  AND l.class='".$aSearch['sClass']."' ";
1627                                         $sSQL .= "  AND l.type='".$aSearch['sType']."' ";
1628                                         if (sizeof($this->aExcludePlaceIDs)) {
1629                                             $sSQL .= " AND l.place_id not in (".join(',', $this->aExcludePlaceIDs).")";
1630                                         }
1631                                         if ($sCountryCodesSQL) $sSQL .= " AND l.calculated_country_code in ($sCountryCodesSQL)";
1632                                         if ($sOrderBy) $sSQL .= "ORDER BY ".$OrderBysSQL." ASC";
1633                                         if ($this->iOffset) $sSQL .= " OFFSET $this->iOffset";
1634                                         $sSQL .= " limit $this->iLimit";
1635                                         if (CONST_Debug) var_dump($sSQL);
1636                                         $aClassPlaceIDs = array_merge($aClassPlaceIDs, chksql($this->oDB->getCol($sSQL)));
1637                                     }
1638                                 }
1639                             }
1640                             $aPlaceIDs = $aClassPlaceIDs;
1641                         }
1642                     }
1643
1644                     if (CONST_Debug) {
1645                         echo "<br><b>Place IDs:</b> ";
1646                         var_Dump($aPlaceIDs);
1647                     }
1648
1649                     foreach ($aPlaceIDs as $iPlaceID) {
1650                         // array for placeID => -1 | Tiger housenumber
1651                         $aResultPlaceIDs[$iPlaceID] = $searchedHousenumber;
1652                     }
1653                     if ($iQueryLoop > 20) break;
1654                 }
1655
1656                 if (isset($aResultPlaceIDs) && sizeof($aResultPlaceIDs) && ($this->iMinAddressRank != 0 || $this->iMaxAddressRank != 30)) {
1657                     // Need to verify passes rank limits before dropping out of the loop (yuk!)
1658                     // reduces the number of place ids, like a filter
1659                     // rank_address is 30 for interpolated housenumbers
1660                     $sSQL = "SELECT place_id ";
1661                     $sSQL .= "FROM placex ";
1662                     $sSQL .= "WHERE place_id in (".join(',', array_keys($aResultPlaceIDs)).") ";
1663                     $sSQL .= "  AND (";
1664                     $sSQL .= "         placex.rank_address between $this->iMinAddressRank and $this->iMaxAddressRank ";
1665                     if (14 >= $this->iMinAddressRank && 14 <= $this->iMaxAddressRank) {
1666                         $sSQL .= "     OR (extratags->'place') = 'city'";
1667                     }
1668                     if ($this->aAddressRankList) {
1669                         $sSQL .= "     OR placex.rank_address in (".join(',', $this->aAddressRankList).")";
1670                     }
1671                     if (CONST_Use_US_Tiger_Data) {
1672                         $sSQL .= "  ) ";
1673                         $sSQL .= "UNION ";
1674                         $sSQL .= "  SELECT place_id ";
1675                         $sSQL .= "  FROM location_property_tiger ";
1676                         $sSQL .= "  WHERE place_id in (".join(',', array_keys($aResultPlaceIDs)).") ";
1677                         $sSQL .= "    AND (30 between $this->iMinAddressRank and $this->iMaxAddressRank ";
1678                         if ($this->aAddressRankList) $sSQL .= " OR 30 in (".join(',', $this->aAddressRankList).")";
1679                     }
1680                     $sSQL .= ") UNION ";
1681                     $sSQL .= "  SELECT place_id ";
1682                     $sSQL .= "  FROM location_property_osmline ";
1683                     $sSQL .= "  WHERE place_id in (".join(',', array_keys($aResultPlaceIDs)).")";
1684                     $sSQL .= "    AND (30 between $this->iMinAddressRank and $this->iMaxAddressRank)";
1685                     if (CONST_Debug) var_dump($sSQL);
1686                     $aFilteredPlaceIDs = chksql($this->oDB->getCol($sSQL));
1687                     $tempIDs = array();
1688                     foreach ($aFilteredPlaceIDs as $placeID) {
1689                         $tempIDs[$placeID] = $aResultPlaceIDs[$placeID];  //assign housenumber to placeID
1690                     }
1691                     $aResultPlaceIDs = $tempIDs;
1692                 }
1693
1694                 //exit;
1695                 if (isset($aResultPlaceIDs) && sizeof($aResultPlaceIDs)) break;
1696                 if ($iGroupLoop > 4) break;
1697                 if ($iQueryLoop > 30) break;
1698             }
1699
1700             // Did we find anything?
1701             if (isset($aResultPlaceIDs) && sizeof($aResultPlaceIDs)) {
1702                 $aSearchResults = $this->getDetails($aResultPlaceIDs);
1703             }
1704         } else {
1705             // Just interpret as a reverse geocode
1706             $oReverse = new ReverseGeocode($this->oDB);
1707             $oReverse->setZoom(18);
1708
1709             $aLookup = $oReverse->lookup(
1710                 (float)$this->aNearPoint[0],
1711                 (float)$this->aNearPoint[1],
1712                 false
1713             );
1714
1715             if (CONST_Debug) var_dump("Reverse search", $aLookup);
1716
1717             if ($aLookup['place_id']) {
1718                 $aSearchResults = $this->getDetails(array($aLookup['place_id'] => -1));
1719                 $aResultPlaceIDs[$aLookup['place_id']] = -1;
1720             } else {
1721                 $aSearchResults = array();
1722             }
1723         }
1724
1725         // No results? Done
1726         if (!sizeof($aSearchResults)) {
1727             if ($this->bFallback) {
1728                 if ($this->fallbackStructuredQuery()) {
1729                     return $this->lookup();
1730                 }
1731             }
1732
1733             return array();
1734         }
1735
1736         $aClassType = getClassTypesWithImportance();
1737         $aRecheckWords = preg_split('/\b[\s,\\-]*/u', $sQuery);
1738         foreach ($aRecheckWords as $i => $sWord) {
1739             if (!preg_match('/\pL/', $sWord)) unset($aRecheckWords[$i]);
1740         }
1741
1742         if (CONST_Debug) {
1743             echo '<i>Recheck words:<\i>';
1744             var_dump($aRecheckWords);
1745         }
1746
1747         $oPlaceLookup = new PlaceLookup($this->oDB);
1748         $oPlaceLookup->setIncludePolygonAsPoints($this->bIncludePolygonAsPoints);
1749         $oPlaceLookup->setIncludePolygonAsText($this->bIncludePolygonAsText);
1750         $oPlaceLookup->setIncludePolygonAsGeoJSON($this->bIncludePolygonAsGeoJSON);
1751         $oPlaceLookup->setIncludePolygonAsKML($this->bIncludePolygonAsKML);
1752         $oPlaceLookup->setIncludePolygonAsSVG($this->bIncludePolygonAsSVG);
1753         $oPlaceLookup->setPolygonSimplificationThreshold($this->fPolygonSimplificationThreshold);
1754
1755         foreach ($aSearchResults as $iResNum => $aResult) {
1756             // Default
1757             $fDiameter = getResultDiameter($aResult);
1758
1759             $aOutlineResult = $oPlaceLookup->getOutlines($aResult['place_id'], $aResult['lon'], $aResult['lat'], $fDiameter/2);
1760             if ($aOutlineResult) {
1761                 $aResult = array_merge($aResult, $aOutlineResult);
1762             }
1763             
1764             if ($aResult['extra_place'] == 'city') {
1765                 $aResult['class'] = 'place';
1766                 $aResult['type'] = 'city';
1767                 $aResult['rank_search'] = 16;
1768             }
1769
1770             // Is there an icon set for this type of result?
1771             if (isset($aClassType[$aResult['class'].':'.$aResult['type']]['icon'])
1772                 && $aClassType[$aResult['class'].':'.$aResult['type']]['icon']
1773             ) {
1774                 $aResult['icon'] = CONST_Website_BaseURL.'images/mapicons/'.$aClassType[$aResult['class'].':'.$aResult['type']]['icon'].'.p.20.png';
1775             }
1776
1777             if (isset($aClassType[$aResult['class'].':'.$aResult['type'].':'.$aResult['admin_level']]['label'])
1778                 && $aClassType[$aResult['class'].':'.$aResult['type'].':'.$aResult['admin_level']]['label']
1779             ) {
1780                 $aResult['label'] = $aClassType[$aResult['class'].':'.$aResult['type'].':'.$aResult['admin_level']]['label'];
1781             } elseif (isset($aClassType[$aResult['class'].':'.$aResult['type']]['label'])
1782                 && $aClassType[$aResult['class'].':'.$aResult['type']]['label']
1783             ) {
1784                 $aResult['label'] = $aClassType[$aResult['class'].':'.$aResult['type']]['label'];
1785             }
1786             // if tag '&addressdetails=1' is set in query
1787             if ($this->bIncludeAddressDetails) {
1788                 // getAddressDetails() is defined in lib.php and uses the SQL function get_addressdata in functions.sql
1789                 $aResult['address'] = getAddressDetails($this->oDB, $sLanguagePrefArraySQL, $aResult['place_id'], $aResult['country_code'], $aResultPlaceIDs[$aResult['place_id']]);
1790                 if ($aResult['extra_place'] == 'city' && !isset($aResult['address']['city'])) {
1791                     $aResult['address'] = array_merge(array('city' => array_values($aResult['address'])[0]), $aResult['address']);
1792                 }
1793             }
1794
1795             if ($this->bIncludeExtraTags) {
1796                 if ($aResult['extra']) {
1797                     $aResult['sExtraTags'] = json_decode($aResult['extra']);
1798                 } else {
1799                     $aResult['sExtraTags'] = (object) array();
1800                 }
1801             }
1802
1803             if ($this->bIncludeNameDetails) {
1804                 if ($aResult['names']) {
1805                     $aResult['sNameDetails'] = json_decode($aResult['names']);
1806                 } else {
1807                     $aResult['sNameDetails'] = (object) array();
1808                 }
1809             }
1810
1811             // Adjust importance for the number of exact string matches in the result
1812             $aResult['importance'] = max(0.001, $aResult['importance']);
1813             $iCountWords = 0;
1814             $sAddress = $aResult['langaddress'];
1815             foreach ($aRecheckWords as $i => $sWord) {
1816                 if (stripos($sAddress, $sWord)!==false) {
1817                     $iCountWords++;
1818                     if (preg_match("/(^|,)\s*".preg_quote($sWord, '/')."\s*(,|$)/", $sAddress)) $iCountWords += 0.1;
1819                 }
1820             }
1821
1822             $aResult['importance'] = $aResult['importance'] + ($iCountWords*0.1); // 0.1 is a completely arbitrary number but something in the range 0.1 to 0.5 would seem right
1823
1824             $aResult['name'] = $aResult['langaddress'];
1825             // secondary ordering (for results with same importance (the smaller the better):
1826             // - approximate importance of address parts
1827             $aResult['foundorder'] = -$aResult['addressimportance']/10;
1828             // - number of exact matches from the query
1829             if (isset($this->exactMatchCache[$aResult['place_id']])) {
1830                 $aResult['foundorder'] -= $this->exactMatchCache[$aResult['place_id']];
1831             } elseif (isset($this->exactMatchCache[$aResult['parent_place_id']])) {
1832                 $aResult['foundorder'] -= $this->exactMatchCache[$aResult['parent_place_id']];
1833             }
1834             // - importance of the class/type
1835             if (isset($aClassType[$aResult['class'].':'.$aResult['type']]['importance'])
1836                 && $aClassType[$aResult['class'].':'.$aResult['type']]['importance']
1837             ) {
1838                 $aResult['foundorder'] += 0.0001 * $aClassType[$aResult['class'].':'.$aResult['type']]['importance'];
1839             } else {
1840                 $aResult['foundorder'] += 0.01;
1841             }
1842             if (CONST_Debug) var_dump($aResult);
1843             $aSearchResults[$iResNum] = $aResult;
1844         }
1845         uasort($aSearchResults, 'byImportance');
1846
1847         $aOSMIDDone = array();
1848         $aClassTypeNameDone = array();
1849         $aToFilter = $aSearchResults;
1850         $aSearchResults = array();
1851
1852         $bFirst = true;
1853         foreach ($aToFilter as $iResNum => $aResult) {
1854             $this->aExcludePlaceIDs[$aResult['place_id']] = $aResult['place_id'];
1855             if ($bFirst) {
1856                 $fLat = $aResult['lat'];
1857                 $fLon = $aResult['lon'];
1858                 if (isset($aResult['zoom'])) $iZoom = $aResult['zoom'];
1859                 $bFirst = false;
1860             }
1861             if (!$this->bDeDupe || (!isset($aOSMIDDone[$aResult['osm_type'].$aResult['osm_id']])
1862                 && !isset($aClassTypeNameDone[$aResult['osm_type'].$aResult['class'].$aResult['type'].$aResult['name'].$aResult['admin_level']]))
1863             ) {
1864                 $aOSMIDDone[$aResult['osm_type'].$aResult['osm_id']] = true;
1865                 $aClassTypeNameDone[$aResult['osm_type'].$aResult['class'].$aResult['type'].$aResult['name'].$aResult['admin_level']] = true;
1866                 $aSearchResults[] = $aResult;
1867             }
1868
1869             // Absolute limit on number of results
1870             if (sizeof($aSearchResults) >= $this->iFinalLimit) break;
1871         }
1872
1873         return $aSearchResults;
1874     } // end lookup()
1875 } // end class