lib-php/SearchDescription.php

   1 <?php
   2
   3 namespace Nominatim;
   4
   5 require_once(CONST_LibDir.'/SpecialSearchOperator.php');
   6 require_once(CONST_LibDir.'/SearchContext.php');
   7 require_once(CONST_LibDir.'/Result.php');
   8
   9 /**
  10  * Description of a single interpretation of a search query.
  11  */
  12 class SearchDescription
  13 {
  14     /// Ranking how well the description fits the query.
  15     private $iSearchRank = 0;
  16     /// Country code of country the result must belong to.
  17     private $sCountryCode = '';
  18     /// List of word ids making up the name of the object.
  19     private $aName = array();
  20     /// True if the name is rare enough to force index use on name.
  21     private $bRareName = false;
  22     /// True if the name requires to be accompanied by address terms.
  23     private $bNameNeedsAddress = false;
  24     /// List of word ids making up the address of the object.
  25     private $aAddress = array();
  26     /// List of word ids that appear in the name but should be ignored.
  27     private $aNameNonSearch = array();
  28     /// List of word ids that appear in the address but should be ignored.
  29     private $aAddressNonSearch = array();
  30     /// Kind of search for special searches, see Nominatim::Operator.
  31     private $iOperator = Operator::NONE;
  32     /// Class of special feature to search for.
  33     private $sClass = '';
  34     /// Type of special feature to search for.
  35     private $sType = '';
  36     /// Housenumber of the object.
  37     private $sHouseNumber = '';
  38     /// Postcode for the object.
  39     private $sPostcode = '';
  40     /// Global search constraints.
  41     private $oContext;
  42
  43     // Temporary values used while creating the search description.
  44
  45     /// Index of phrase currently processed.
  46     private $iNamePhrase = -1;
  47
  48     /**
  49      * Create an empty search description.
  50      *
  51      * @param object $oContext Global context to use. Will be inherited by
  52      *                         all derived search objects.
  53      */
  54     public function __construct($oContext)
  55     {
  56         $this->oContext = $oContext;
  57     }
  58
  59     /**
  60      * Get current search rank.
  61      *
  62      * The higher the search rank the lower the likelihood that the
  63      * search is a correct interpretation of the search query.
  64      *
  65      * @return integer Search rank.
  66      */
  67     public function getRank()
  68     {
  69         return $this->iSearchRank;
  70     }
  71
  72     /**
  73      * Extract key/value pairs from a query.
  74      *
  75      * Key/value pairs are recognised if they are of the form [<key>=<value>].
  76      * If multiple terms of this kind are found then all terms are removed
  77      * but only the first is used for search.
  78      *
  79      * @param string $sQuery Original query string.
  80      *
  81      * @return string The query string with the special search patterns removed.
  82      */
  83     public function extractKeyValuePairs($sQuery)
  84     {
  85         // Search for terms of kind [<key>=<value>].
  86         preg_match_all(
  87             '/\\[([\\w_]*)=([\\w_]*)\\]/',
  88             $sQuery,
  89             $aSpecialTermsRaw,
  90             PREG_SET_ORDER
  91         );
  92
  93         foreach ($aSpecialTermsRaw as $aTerm) {
  94             $sQuery = str_replace($aTerm[0], ' ', $sQuery);
  95             if (!$this->hasOperator()) {
  96                 $this->setPoiSearch(Operator::TYPE, $aTerm[1], $aTerm[2]);
  97             }
  98         }
  99
 100         return $sQuery;
 101     }
 102
 103     /**
 104      * Check if the combination of parameters is sensible.
 105      *
 106      * @return bool True, if the search looks valid.
 107      */
 108     public function isValidSearch()
 109     {
 110         if (empty($this->aName)) {
 111             if ($this->sHouseNumber) {
 112                 return false;
 113             }
 114             if (!$this->sClass && !$this->sCountryCode) {
 115                 return false;
 116             }
 117         }
 118         if ($this->bNameNeedsAddress && empty($this->aAddress)) {
 119             return false;
 120         }
 121
 122         return true;
 123     }
 124
 125     /////////// Search building functions
 126
 127     /**
 128      * Create a copy of this search description adding to search rank.
 129      *
 130      * @param integer $iTermCost  Cost to add to the current search rank.
 131      *
 132      * @return object Cloned search description.
 133      */
 134     public function clone($iTermCost)
 135     {
 136         $oSearch = clone $this;
 137         $oSearch->iSearchRank += $iTermCost;
 138
 139         return $oSearch;
 140     }
 141
 142     /**
 143      * Check if the search currently includes a name.
 144      *
 145      * @param bool bIncludeNonNames  If true stop-word tokens are taken into
 146      *                               account, too.
 147      *
 148      * @return bool True, if search has a name.
 149      */
 150     public function hasName($bIncludeNonNames = false)
 151     {
 152         return !empty($this->aName)
 153                || (!empty($this->aNameNonSearch) && $bIncludeNonNames);
 154     }
 155
 156     /**
 157      * Check if the search currently includes an address term.
 158      *
 159      * @return bool True, if any address term is included, including stop-word
 160      *              terms.
 161      */
 162     public function hasAddress()
 163     {
 164         return !empty($this->aAddress) || !empty($this->aAddressNonSearch);
 165     }
 166
 167     /**
 168      * Check if a country restriction is currently included in the search.
 169      *
 170      * @return bool True, if a country restriction is set.
 171      */
 172     public function hasCountry()
 173     {
 174         return $this->sCountryCode !== '';
 175     }
 176
 177     /**
 178      * Check if a postcode is currently included in the search.
 179      *
 180      * @return bool True, if a postcode is set.
 181      */
 182     public function hasPostcode()
 183     {
 184         return $this->sPostcode !== '';
 185     }
 186
 187     /**
 188      * Check if a house number is set for the search.
 189      *
 190      * @return bool True, if a house number is set.
 191      */
 192     public function hasHousenumber()
 193     {
 194         return $this->sHouseNumber !== '';
 195     }
 196
 197     /**
 198      * Check if a special type of place is requested.
 199      *
 200      * param integer iOperator  When set, check for the particular
 201      *                          operator used for the special type.
 202      *
 203      * @return bool True, if speial type is requested or, if requested,
 204      *              a special type with the given operator.
 205      */
 206     public function hasOperator($iOperator = null)
 207     {
 208         return $iOperator === null ? $this->iOperator != Operator::NONE : $this->iOperator == $iOperator;
 209     }
 210
 211     /**
 212      * Add the given token to the list of terms to search for in the address.
 213      *
 214      * @param integer iID       ID of term to add.
 215      * @param bool bSearchable  Term should be used to search for result
 216      *                          (i.e. term is not a stop word).
 217      */
 218     public function addAddressToken($iId, $bSearchable = true)
 219     {
 220         if ($bSearchable) {
 221             $this->aAddress[$iId] = $iId;
 222         } else {
 223             $this->aAddressNonSearch[$iId] = $iId;
 224         }
 225     }
 226
 227     /**
 228      * Add the given full-word token to the list of terms to search for in the
 229      * name.
 230      *
 231      * @param interger iId    ID of term to add.
 232      * @param bool bRareName  True if the term is infrequent enough to not
 233      *                        require other constraints for efficient search.
 234      */
 235     public function addNameToken($iId, $bRareName)
 236     {
 237         $this->aName[$iId] = $iId;
 238         $this->bRareName = $bRareName;
 239         $this->bNameNeedsAddress = false;
 240     }
 241
 242     /**
 243      * Add the given partial token to the list of terms to search for in
 244      * the name.
 245      *
 246      * @param integer iID            ID of term to add.
 247      * @param bool bSearchable       Term should be used to search for result
 248      *                               (i.e. term is not a stop word).
 249      * @param bool bNeedsAddress     True if the term is too unspecific to be used
 250      *                               in a stand-alone search without an address
 251      *                               to narrow down the search.
 252      * @param integer iPhraseNumber  Index of phrase, where the partial term
 253      *                               appears.
 254      */
 255     public function addPartialNameToken($iId, $bSearchable, $bNeedsAddress, $iPhraseNumber)
 256     {
 257         if (empty($this->aName)) {
 258             $this->bNameNeedsAddress = $bNeedsAddress;
 259         } else {
 260             $this->bNameNeedsAddress &= $bNeedsAddress;
 261         }
 262         if ($bSearchable) {
 263             $this->aName[$iId] = $iId;
 264         } else {
 265             $this->aNameNonSearch[$iId] = $iId;
 266         }
 267         $this->iNamePhrase = $iPhraseNumber;
 268     }
 269
 270     /**
 271      * Set country restriction for the search.
 272      *
 273      * @param string sCountryCode  Country code of country to restrict search to.
 274      */
 275     public function setCountry($sCountryCode)
 276     {
 277         $this->sCountryCode = $sCountryCode;
 278         $this->iNamePhrase = -1;
 279     }
 280
 281     /**
 282      * Set postcode search constraint.
 283      *
 284      * @param string sPostcode  Postcode the result should have.
 285      */
 286     public function setPostcode($sPostcode)
 287     {
 288         $this->sPostcode = $sPostcode;
 289         $this->iNamePhrase = -1;
 290     }
 291
 292     /**
 293      * Make this search a search for a postcode object.
 294      *
 295      * @param integer iId       Token Id for the postcode.
 296      * @param string sPostcode  Postcode to look for.
 297      */
 298     public function setPostcodeAsName($iId, $sPostcode)
 299     {
 300         $this->iOperator = Operator::POSTCODE;
 301         $this->aAddress = array_merge($this->aAddress, $this->aName);
 302         $this->aName = array($iId => $sPostcode);
 303         $this->bRareName = true;
 304         $this->iNamePhrase = -1;
 305     }
 306
 307     /**
 308      * Set house number search cnstraint.
 309      *
 310      * @param string sNumber  House number the result should have.
 311      */
 312     public function setHousenumber($sNumber)
 313     {
 314         $this->sHouseNumber = $sNumber;
 315         $this->iNamePhrase = -1;
 316     }
 317
 318     /**
 319      * Make this search a search for a house number.
 320      *
 321      * @param integer iId  Token Id for the house number.
 322      */
 323     public function setHousenumberAsName($iId)
 324     {
 325         $this->aAddress = array_merge($this->aAddress, $this->aName);
 326         $this->bRareName = false;
 327         $this->bNameNeedsAddress = true;
 328         $this->aName = array($iId => $iId);
 329         $this->iNamePhrase = -1;
 330     }
 331
 332     /**
 333      * Make this search a POI search.
 334      *
 335      * In a POI search, objects are not (only) searched by their name
 336      * but also by the primary OSM key/value pair (class and type in Nominatim).
 337      *
 338      * @param integer $iOperator Type of POI search
 339      * @param string  $sClass    Class (or OSM tag key) of POI.
 340      * @param string  $sType     Type (or OSM tag value) of POI.
 341      *
 342      * @return void
 343      */
 344     public function setPoiSearch($iOperator, $sClass, $sType)
 345     {
 346         $this->iOperator = $iOperator;
 347         $this->sClass = $sClass;
 348         $this->sType = $sType;
 349         $this->iNamePhrase = -1;
 350     }
 351
 352     public function getNamePhrase()
 353     {
 354         return $this->iNamePhrase;
 355     }
 356
 357     /**
 358      * Get the global search context.
 359      *
 360      * @return object  Objects of global search constraints.
 361      */
 362     public function getContext()
 363     {
 364         return $this->oContext;
 365     }
 366
 367     /////////// Query functions
 368
 369
 370     /**
 371      * Query database for places that match this search.
 372      *
 373      * @param object  $oDB      Nominatim::DB instance to use.
 374      * @param integer $iMinRank Minimum address rank to restrict search to.
 375      * @param integer $iMaxRank Maximum address rank to restrict search to.
 376      * @param integer $iLimit   Maximum number of results.
 377      *
 378      * @return mixed[] An array with two fields: IDs contains the list of
 379      *                 matching place IDs and houseNumber the houseNumber
 380      *                 if appicable or -1 if not.
 381      */
 382     public function query(&$oDB, $iMinRank, $iMaxRank, $iLimit)
 383     {
 384         $aResults = array();
 385
 386         if ($this->sCountryCode
 387             && empty($this->aName)
 388             && !$this->iOperator
 389             && !$this->sClass
 390             && !$this->oContext->hasNearPoint()
 391         ) {
 392             // Just looking for a country - look it up
 393             if (4 >= $iMinRank && 4 <= $iMaxRank) {
 394                 $aResults = $this->queryCountry($oDB);
 395             }
 396         } elseif (empty($this->aName) && empty($this->aAddress)) {
 397             // Neither name nor address? Then we must be
 398             // looking for a POI in a geographic area.
 399             if ($this->oContext->isBoundedSearch()) {
 400                 $aResults = $this->queryNearbyPoi($oDB, $iLimit);
 401             }
 402         } elseif ($this->iOperator == Operator::POSTCODE) {
 403             // looking for postcode
 404             $aResults = $this->queryPostcode($oDB, $iLimit);
 405         } else {
 406             // Ordinary search:
 407             // First search for places according to name and address.
 408             $aResults = $this->queryNamedPlace(
 409                 $oDB,
 410                 $iMinRank,
 411                 $iMaxRank,
 412                 $iLimit
 413             );
 414
 415             // Now search for housenumber, if housenumber provided. Can be zero.
 416             if (($this->sHouseNumber || $this->sHouseNumber === '0') && !empty($aResults)) {
 417                 $aHnResults = $this->queryHouseNumber($oDB, $aResults);
 418
 419                 // Downgrade the rank of the street results, they are missing
 420                 // the housenumber. Also drop POI places (rank 30) here, they
 421                 // cannot be a parent place and therefore must not be shown
 422                 // as a result for a search with a missing housenumber.
 423                 foreach ($aResults as $oRes) {
 424                     if ($oRes->iAddressRank < 28) {
 425                         if ($oRes->iAddressRank >= 26) {
 426                             $oRes->iResultRank++;
 427                         } else {
 428                             $oRes->iResultRank += 2;
 429                         }
 430                         $aHnResults[$oRes->iId] = $oRes;
 431                     }
 432                 }
 433
 434                 $aResults = $aHnResults;
 435             }
 436
 437             // finally get POIs if requested
 438             if ($this->sClass && !empty($aResults)) {
 439                 $aResults = $this->queryPoiByOperator($oDB, $aResults, $iLimit);
 440             }
 441         }
 442
 443         Debug::printDebugTable('Place IDs', $aResults);
 444
 445         if (!empty($aResults) && $this->sPostcode) {
 446             $sPlaceIds = Result::joinIdsByTable($aResults, Result::TABLE_PLACEX);
 447             if ($sPlaceIds) {
 448                 $sSQL = 'SELECT place_id FROM placex';
 449                 $sSQL .= ' WHERE place_id in ('.$sPlaceIds.')';
 450                 $sSQL .= " AND postcode != '".$this->sPostcode."'";
 451                 Debug::printSQL($sSQL);
 452                 $aFilteredPlaceIDs = $oDB->getCol($sSQL);
 453                 if ($aFilteredPlaceIDs) {
 454                     foreach ($aFilteredPlaceIDs as $iPlaceId) {
 455                         $aResults[$iPlaceId]->iResultRank++;
 456                     }
 457                 }
 458             }
 459         }
 460
 461         return $aResults;
 462     }
 463
 464
 465     private function queryCountry(&$oDB)
 466     {
 467         $sSQL = 'SELECT place_id FROM placex ';
 468         $sSQL .= "WHERE country_code='".$this->sCountryCode."'";
 469         $sSQL .= ' AND rank_search = 4';
 470         if ($this->oContext->bViewboxBounded) {
 471             $sSQL .= ' AND ST_Intersects('.$this->oContext->sqlViewboxSmall.', geometry)';
 472         }
 473         $sSQL .= ' ORDER BY st_area(geometry) DESC LIMIT 1';
 474
 475         Debug::printSQL($sSQL);
 476
 477         $iPlaceId = $oDB->getOne($sSQL);
 478
 479         $aResults = array();
 480         if ($iPlaceId) {
 481             $aResults[$iPlaceId] = new Result($iPlaceId);
 482         }
 483
 484         return $aResults;
 485     }
 486
 487     private function queryNearbyPoi(&$oDB, $iLimit)
 488     {
 489         if (!$this->sClass) {
 490             return array();
 491         }
 492
 493         $aDBResults = array();
 494         $sPoiTable = $this->poiTable();
 495
 496         if ($oDB->tableExists($sPoiTable)) {
 497             $sSQL = 'SELECT place_id FROM '.$sPoiTable.' ct';
 498             if ($this->oContext->sqlCountryList) {
 499                 $sSQL .= ' JOIN placex USING (place_id)';
 500             }
 501             if ($this->oContext->hasNearPoint()) {
 502                 $sSQL .= ' WHERE '.$this->oContext->withinSQL('ct.centroid');
 503             } elseif ($this->oContext->bViewboxBounded) {
 504                 $sSQL .= ' WHERE ST_Contains('.$this->oContext->sqlViewboxSmall.', ct.centroid)';
 505             }
 506             if ($this->oContext->sqlCountryList) {
 507                 $sSQL .= ' AND country_code in '.$this->oContext->sqlCountryList;
 508             }
 509             $sSQL .= $this->oContext->excludeSQL(' AND place_id');
 510             if ($this->oContext->sqlViewboxCentre) {
 511                 $sSQL .= ' ORDER BY ST_Distance(';
 512                 $sSQL .= $this->oContext->sqlViewboxCentre.', ct.centroid) ASC';
 513             } elseif ($this->oContext->hasNearPoint()) {
 514                 $sSQL .= ' ORDER BY '.$this->oContext->distanceSQL('ct.centroid').' ASC';
 515             }
 516             $sSQL .= " LIMIT $iLimit";
 517             Debug::printSQL($sSQL);
 518             $aDBResults = $oDB->getCol($sSQL);
 519         }
 520
 521         if ($this->oContext->hasNearPoint()) {
 522             $sSQL = 'SELECT place_id FROM placex WHERE ';
 523             $sSQL .= 'class = :class and type = :type';
 524             $sSQL .= ' AND '.$this->oContext->withinSQL('geometry');
 525             $sSQL .= ' AND linked_place_id is null';
 526             if ($this->oContext->sqlCountryList) {
 527                 $sSQL .= ' AND country_code in '.$this->oContext->sqlCountryList;
 528             }
 529             $sSQL .= ' ORDER BY '.$this->oContext->distanceSQL('centroid').' ASC';
 530             $sSQL .= " LIMIT $iLimit";
 531             Debug::printSQL($sSQL);
 532             $aDBResults = $oDB->getCol(
 533                 $sSQL,
 534                 array(':class' => $this->sClass, ':type' => $this->sType)
 535             );
 536         }
 537
 538         $aResults = array();
 539         foreach ($aDBResults as $iPlaceId) {
 540             $aResults[$iPlaceId] = new Result($iPlaceId);
 541         }
 542
 543         return $aResults;
 544     }
 545
 546     private function queryPostcode(&$oDB, $iLimit)
 547     {
 548         $sSQL = 'SELECT p.place_id FROM location_postcode p ';
 549
 550         if (!empty($this->aAddress)) {
 551             $sSQL .= ', search_name s ';
 552             $sSQL .= 'WHERE s.place_id = p.parent_place_id ';
 553             $sSQL .= 'AND array_cat(s.nameaddress_vector, s.name_vector)';
 554             $sSQL .= '      @> '.$oDB->getArraySQL($this->aAddress).' AND ';
 555         } else {
 556             $sSQL .= 'WHERE ';
 557         }
 558
 559         $sSQL .= "p.postcode = '".reset($this->aName)."'";
 560         $sSQL .= $this->countryCodeSQL(' AND p.country_code');
 561         if ($this->oContext->bViewboxBounded) {
 562             $sSQL .= ' AND ST_Intersects('.$this->oContext->sqlViewboxSmall.', geometry)';
 563         }
 564         $sSQL .= $this->oContext->excludeSQL(' AND p.place_id');
 565         $sSQL .= " LIMIT $iLimit";
 566
 567         Debug::printSQL($sSQL);
 568
 569         $aResults = array();
 570         foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 571             $aResults[$iPlaceId] = new Result($iPlaceId, Result::TABLE_POSTCODE);
 572         }
 573
 574         return $aResults;
 575     }
 576
 577     private function queryNamedPlace(&$oDB, $iMinAddressRank, $iMaxAddressRank, $iLimit)
 578     {
 579         $aTerms = array();
 580         $aOrder = array();
 581
 582         // Sort by existence of the requested house number but only if not
 583         // too many results are expected for the street, i.e. if the result
 584         // will be narrowed down by an address. Remember that with ordering
 585         // every single result has to be checked.
 586         if ($this->sHouseNumber && ($this->bRareName || !empty($this->aAddress) || $this->sPostcode)) {
 587             $sHouseNumberRegex = $oDB->getDBQuoted('\\\\m'.$this->sHouseNumber.'\\\\M');
 588
 589             // Housenumbers on streets and places.
 590             $sChildHnr = 'SELECT * FROM placex WHERE parent_place_id = search_name.place_id';
 591             $sChildHnr .= '    AND housenumber ~* E'.$sHouseNumberRegex;
 592             // Interpolations on streets and places.
 593             if (preg_match('/^[0-9]+$/', $this->sHouseNumber)) {
 594                 $sIpolHnr = 'WHERE parent_place_id = search_name.place_id ';
 595                 $sIpolHnr .= '  AND startnumber is not NULL';
 596                 $sIpolHnr .= '    AND '.$this->sHouseNumber.'>=startnumber ';
 597                 $sIpolHnr .= '    AND '.$this->sHouseNumber.'<=endnumber ';
 598             } else {
 599                 $sIpolHnr = false;
 600             }
 601             // Housenumbers on the object iteself for unlisted places.
 602             $sSelfHnr = 'SELECT * FROM placex WHERE place_id = search_name.place_id';
 603             $sSelfHnr .= '    AND housenumber ~* E'.$sHouseNumberRegex;
 604
 605             $sSql = '(CASE WHEN address_rank = 30 THEN EXISTS('.$sSelfHnr.') ';
 606             $sSql .= ' ELSE EXISTS('.$sChildHnr.') ';
 607             if ($sIpolHnr) {
 608                 $sSql .= 'OR EXISTS(SELECT * FROM location_property_osmline '.$sIpolHnr.') ';
 609                 if (CONST_Use_US_Tiger_Data) {
 610                     $sSql .= "OR (country_code = 'us' AND ";
 611                     $sSql .= '    EXISTS(SELECT * FROM location_property_tiger '.$sIpolHnr.')) ';
 612                 }
 613             }
 614             $sSql .= 'END) DESC';
 615
 616
 617             $aOrder[] = $sSql;
 618         }
 619
 620         if (!empty($this->aName)) {
 621             $aTerms[] = 'name_vector @> '.$oDB->getArraySQL($this->aName);
 622         }
 623         if (!empty($this->aAddress)) {
 624             // For infrequent name terms disable index usage for address
 625             if ($this->bRareName) {
 626                 $aTerms[] = 'array_cat(nameaddress_vector,ARRAY[]::integer[]) @> '.$oDB->getArraySQL($this->aAddress);
 627             } else {
 628                 $aTerms[] = 'nameaddress_vector @> '.$oDB->getArraySQL($this->aAddress);
 629             }
 630         }
 631
 632         $sCountryTerm = $this->countryCodeSQL('country_code');
 633         if ($sCountryTerm) {
 634             $aTerms[] = $sCountryTerm;
 635         }
 636
 637         if ($this->sHouseNumber) {
 638             $aTerms[] = 'address_rank between 16 and 30';
 639         } elseif (!$this->sClass || $this->iOperator == Operator::NAME) {
 640             if ($iMinAddressRank > 0) {
 641                 $aTerms[] = "((address_rank between $iMinAddressRank and $iMaxAddressRank) or (search_rank between $iMinAddressRank and $iMaxAddressRank))";
 642             }
 643         }
 644
 645         if ($this->oContext->hasNearPoint()) {
 646             $aTerms[] = $this->oContext->withinSQL('centroid');
 647             $aOrder[] = $this->oContext->distanceSQL('centroid');
 648         } elseif ($this->sPostcode) {
 649             if (empty($this->aAddress)) {
 650                 $aTerms[] = "EXISTS(SELECT place_id FROM location_postcode p WHERE p.postcode = '".$this->sPostcode."' AND ST_DWithin(search_name.centroid, p.geometry, 0.12))";
 651             } else {
 652                 $aOrder[] = "(SELECT min(ST_Distance(search_name.centroid, p.geometry)) FROM location_postcode p WHERE p.postcode = '".$this->sPostcode."')";
 653             }
 654         }
 655
 656         $sExcludeSQL = $this->oContext->excludeSQL('place_id');
 657         if ($sExcludeSQL) {
 658             $aTerms[] = $sExcludeSQL;
 659         }
 660
 661         if ($this->oContext->bViewboxBounded) {
 662             $aTerms[] = 'centroid && '.$this->oContext->sqlViewboxSmall;
 663         }
 664
 665         if ($this->oContext->hasNearPoint()) {
 666             $aOrder[] = $this->oContext->distanceSQL('centroid');
 667         }
 668
 669         if ($this->sHouseNumber) {
 670             $sImportanceSQL = '- abs(26 - address_rank) + 3';
 671         } else {
 672             $sImportanceSQL = '(CASE WHEN importance = 0 OR importance IS NULL THEN 0.75001-(search_rank::float/40) ELSE importance END)';
 673         }
 674         $sImportanceSQL .= $this->oContext->viewboxImportanceSQL('centroid');
 675         $aOrder[] = "$sImportanceSQL DESC";
 676
 677         $aFullNameAddress = $this->oContext->getFullNameTerms();
 678         if (!empty($aFullNameAddress)) {
 679             $sExactMatchSQL = ' ( ';
 680             $sExactMatchSQL .= ' SELECT count(*) FROM ( ';
 681             $sExactMatchSQL .= '  SELECT unnest('.$oDB->getArraySQL($aFullNameAddress).')';
 682             $sExactMatchSQL .= '    INTERSECT ';
 683             $sExactMatchSQL .= '  SELECT unnest(nameaddress_vector)';
 684             $sExactMatchSQL .= ' ) s';
 685             $sExactMatchSQL .= ') as exactmatch';
 686             $aOrder[] = 'exactmatch DESC';
 687         } else {
 688             $sExactMatchSQL = '0::int as exactmatch';
 689         }
 690
 691         if ($this->sHouseNumber || $this->sClass) {
 692             $iLimit = 40;
 693         }
 694
 695         $aResults = array();
 696
 697         if (!empty($aTerms)) {
 698             $sSQL = 'SELECT place_id, address_rank,'.$sExactMatchSQL;
 699             $sSQL .= ' FROM search_name';
 700             $sSQL .= ' WHERE '.join(' and ', $aTerms);
 701             $sSQL .= ' ORDER BY '.join(', ', $aOrder);
 702             $sSQL .= ' LIMIT '.$iLimit;
 703
 704             Debug::printSQL($sSQL);
 705
 706             $aDBResults = $oDB->getAll($sSQL, null, 'Could not get places for search terms.');
 707
 708             foreach ($aDBResults as $aResult) {
 709                 $oResult = new Result($aResult['place_id']);
 710                 $oResult->iExactMatches = $aResult['exactmatch'];
 711                 $oResult->iAddressRank = $aResult['address_rank'];
 712                 $aResults[$aResult['place_id']] = $oResult;
 713             }
 714         }
 715
 716         return $aResults;
 717     }
 718
 719     private function queryHouseNumber(&$oDB, $aRoadPlaceIDs)
 720     {
 721         $aResults = array();
 722         $sRoadPlaceIDs = Result::joinIdsByTableMaxRank(
 723             $aRoadPlaceIDs,
 724             Result::TABLE_PLACEX,
 725             27
 726         );
 727         $sPOIPlaceIDs = Result::joinIdsByTableMinRank(
 728             $aRoadPlaceIDs,
 729             Result::TABLE_PLACEX,
 730             30
 731         );
 732
 733         $aIDCondition = array();
 734         if ($sRoadPlaceIDs) {
 735             $aIDCondition[] = 'parent_place_id in ('.$sRoadPlaceIDs.')';
 736         }
 737         if ($sPOIPlaceIDs) {
 738             $aIDCondition[] = 'place_id in ('.$sPOIPlaceIDs.')';
 739         }
 740
 741         if (empty($aIDCondition)) {
 742             return $aResults;
 743         }
 744
 745         $sHouseNumberRegex = $oDB->getDBQuoted('\\\\m'.$this->sHouseNumber.'\\\\M');
 746         $sSQL = 'SELECT place_id FROM placex WHERE';
 747         $sSQL .= '  housenumber ~* E'.$sHouseNumberRegex;
 748         $sSQL .= ' AND ('.join(' OR ', $aIDCondition).')';
 749         $sSQL .= $this->oContext->excludeSQL(' AND place_id');
 750
 751         Debug::printSQL($sSQL);
 752
 753         // XXX should inherit the exactMatches from its parent
 754         foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 755             $aResults[$iPlaceId] = new Result($iPlaceId);
 756         }
 757
 758         $bIsIntHouseNumber= (bool) preg_match('/[0-9]+/', $this->sHouseNumber);
 759         $iHousenumber = intval($this->sHouseNumber);
 760         if ($bIsIntHouseNumber && $sRoadPlaceIDs && empty($aResults)) {
 761             // if nothing found, search in the interpolation line table
 762             $sSQL = 'SELECT distinct place_id FROM location_property_osmline';
 763             $sSQL .= ' WHERE startnumber is not NULL';
 764             $sSQL .= '  AND parent_place_id in ('.$sRoadPlaceIDs.') AND (';
 765             if ($iHousenumber % 2 == 0) {
 766                 // If housenumber is even, look for housenumber in streets
 767                 // with interpolationtype even or all.
 768                 $sSQL .= "interpolationtype='even'";
 769             } else {
 770                 // Else look for housenumber with interpolationtype odd or all.
 771                 $sSQL .= "interpolationtype='odd'";
 772             }
 773             $sSQL .= " or interpolationtype='all') and ";
 774             $sSQL .= $iHousenumber.'>=startnumber and ';
 775             $sSQL .= $iHousenumber.'<=endnumber';
 776             $sSQL .= $this->oContext->excludeSQL(' AND place_id');
 777
 778             Debug::printSQL($sSQL);
 779
 780             foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 781                 $oResult = new Result($iPlaceId, Result::TABLE_OSMLINE);
 782                 $oResult->iHouseNumber = $iHousenumber;
 783                 $aResults[$iPlaceId] = $oResult;
 784             }
 785         }
 786
 787         // If nothing found then search in Tiger data (location_property_tiger)
 788         if (CONST_Use_US_Tiger_Data && $sRoadPlaceIDs && $bIsIntHouseNumber && empty($aResults)) {
 789             $sSQL = 'SELECT place_id FROM location_property_tiger';
 790             $sSQL .= ' WHERE parent_place_id in ('.$sRoadPlaceIDs.') and (';
 791             if ($iHousenumber % 2 == 0) {
 792                 $sSQL .= "interpolationtype='even'";
 793             } else {
 794                 $sSQL .= "interpolationtype='odd'";
 795             }
 796             $sSQL .= " or interpolationtype='all') and ";
 797             $sSQL .= $iHousenumber.'>=startnumber and ';
 798             $sSQL .= $iHousenumber.'<=endnumber';
 799             $sSQL .= $this->oContext->excludeSQL(' AND place_id');
 800
 801             Debug::printSQL($sSQL);
 802
 803             foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 804                 $oResult = new Result($iPlaceId, Result::TABLE_TIGER);
 805                 $oResult->iHouseNumber = $iHousenumber;
 806                 $aResults[$iPlaceId] = $oResult;
 807             }
 808         }
 809
 810         return $aResults;
 811     }
 812
 813
 814     private function queryPoiByOperator(&$oDB, $aParentIDs, $iLimit)
 815     {
 816         $aResults = array();
 817         $sPlaceIDs = Result::joinIdsByTable($aParentIDs, Result::TABLE_PLACEX);
 818
 819         if (!$sPlaceIDs) {
 820             return $aResults;
 821         }
 822
 823         if ($this->iOperator == Operator::TYPE || $this->iOperator == Operator::NAME) {
 824             // If they were searching for a named class (i.e. 'Kings Head pub')
 825             // then we might have an extra match
 826             $sSQL = 'SELECT place_id FROM placex ';
 827             $sSQL .= " WHERE place_id in ($sPlaceIDs)";
 828             $sSQL .= "   AND class='".$this->sClass."' ";
 829             $sSQL .= "   AND type='".$this->sType."'";
 830             $sSQL .= '   AND linked_place_id is null';
 831             $sSQL .= $this->oContext->excludeSQL(' AND place_id');
 832             $sSQL .= ' ORDER BY rank_search ASC ';
 833             $sSQL .= " LIMIT $iLimit";
 834
 835             Debug::printSQL($sSQL);
 836
 837             foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 838                 $aResults[$iPlaceId] = new Result($iPlaceId);
 839             }
 840         }
 841
 842         // NEAR and IN are handled the same
 843         if ($this->iOperator == Operator::TYPE || $this->iOperator == Operator::NEAR) {
 844             $sClassTable = $this->poiTable();
 845             $bCacheTable = $oDB->tableExists($sClassTable);
 846
 847             $sSQL = "SELECT min(rank_search) FROM placex WHERE place_id in ($sPlaceIDs)";
 848             Debug::printSQL($sSQL);
 849             $iMaxRank = (int) $oDB->getOne($sSQL);
 850
 851             // For state / country level searches the normal radius search doesn't work very well
 852             $sPlaceGeom = false;
 853             if ($iMaxRank < 9 && $bCacheTable) {
 854                 // Try and get a polygon to search in instead
 855                 $sSQL = 'SELECT geometry FROM placex';
 856                 $sSQL .= " WHERE place_id in ($sPlaceIDs)";
 857                 $sSQL .= "   AND rank_search < $iMaxRank + 5";
 858                 $sSQL .= "   AND ST_GeometryType(geometry) in ('ST_Polygon','ST_MultiPolygon')";
 859                 $sSQL .= ' ORDER BY rank_search ASC ';
 860                 $sSQL .= ' LIMIT 1';
 861                 Debug::printSQL($sSQL);
 862                 $sPlaceGeom = $oDB->getOne($sSQL);
 863             }
 864
 865             if ($sPlaceGeom) {
 866                 $sPlaceIDs = false;
 867             } else {
 868                 $iMaxRank += 5;
 869                 $sSQL = 'SELECT place_id FROM placex';
 870                 $sSQL .= " WHERE place_id in ($sPlaceIDs) and rank_search < $iMaxRank";
 871                 Debug::printSQL($sSQL);
 872                 $aPlaceIDs = $oDB->getCol($sSQL);
 873                 $sPlaceIDs = join(',', $aPlaceIDs);
 874             }
 875
 876             if ($sPlaceIDs || $sPlaceGeom) {
 877                 $fRange = 0.01;
 878                 if ($bCacheTable) {
 879                     // More efficient - can make the range bigger
 880                     $fRange = 0.05;
 881
 882                     $sOrderBySQL = '';
 883                     if ($this->oContext->hasNearPoint()) {
 884                         $sOrderBySQL = $this->oContext->distanceSQL('l.centroid');
 885                     } elseif ($sPlaceIDs) {
 886                         $sOrderBySQL = 'ST_Distance(l.centroid, f.geometry)';
 887                     } elseif ($sPlaceGeom) {
 888                         $sOrderBySQL = "ST_Distance(st_centroid('".$sPlaceGeom."'), l.centroid)";
 889                     }
 890
 891                     $sSQL = 'SELECT distinct i.place_id';
 892                     if ($sOrderBySQL) {
 893                         $sSQL .= ', i.order_term';
 894                     }
 895                     $sSQL .= ' from (SELECT l.place_id';
 896                     if ($sOrderBySQL) {
 897                         $sSQL .= ','.$sOrderBySQL.' as order_term';
 898                     }
 899                     $sSQL .= ' from '.$sClassTable.' as l';
 900
 901                     if ($sPlaceIDs) {
 902                         $sSQL .= ',placex as f WHERE ';
 903                         $sSQL .= "f.place_id in ($sPlaceIDs) ";
 904                         $sSQL .= " AND ST_DWithin(l.centroid, f.centroid, $fRange)";
 905                     } elseif ($sPlaceGeom) {
 906                         $sSQL .= " WHERE ST_Contains('$sPlaceGeom', l.centroid)";
 907                     }
 908
 909                     $sSQL .= $this->oContext->excludeSQL(' AND l.place_id');
 910                     $sSQL .= 'limit 300) i ';
 911                     if ($sOrderBySQL) {
 912                         $sSQL .= 'order by order_term asc';
 913                     }
 914                     $sSQL .= " limit $iLimit";
 915
 916                     Debug::printSQL($sSQL);
 917
 918                     foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 919                         $aResults[$iPlaceId] = new Result($iPlaceId);
 920                     }
 921                 } else {
 922                     if ($this->oContext->hasNearPoint()) {
 923                         $fRange = $this->oContext->nearRadius();
 924                     }
 925
 926                     $sOrderBySQL = '';
 927                     if ($this->oContext->hasNearPoint()) {
 928                         $sOrderBySQL = $this->oContext->distanceSQL('l.geometry');
 929                     } else {
 930                         $sOrderBySQL = 'ST_Distance(l.geometry, f.geometry)';
 931                     }
 932
 933                     $sSQL = 'SELECT distinct l.place_id';
 934                     if ($sOrderBySQL) {
 935                         $sSQL .= ','.$sOrderBySQL.' as orderterm';
 936                     }
 937                     $sSQL .= ' FROM placex as l, placex as f';
 938                     $sSQL .= " WHERE f.place_id in ($sPlaceIDs)";
 939                     $sSQL .= "  AND ST_DWithin(l.geometry, f.centroid, $fRange)";
 940                     $sSQL .= "  AND l.class='".$this->sClass."'";
 941                     $sSQL .= "  AND l.type='".$this->sType."'";
 942                     $sSQL .= $this->oContext->excludeSQL(' AND l.place_id');
 943                     if ($sOrderBySQL) {
 944                         $sSQL .= 'ORDER BY orderterm ASC';
 945                     }
 946                     $sSQL .= " limit $iLimit";
 947
 948                     Debug::printSQL($sSQL);
 949
 950                     foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 951                         $aResults[$iPlaceId] = new Result($iPlaceId);
 952                     }
 953                 }
 954             }
 955         }
 956
 957         return $aResults;
 958     }
 959
 960     private function poiTable()
 961     {
 962         return 'place_classtype_'.$this->sClass.'_'.$this->sType;
 963     }
 964
 965     private function countryCodeSQL($sVar)
 966     {
 967         if ($this->sCountryCode) {
 968             return $sVar.' = \''.$this->sCountryCode."'";
 969         }
 970         if ($this->oContext->sqlCountryList) {
 971             return $sVar.' in '.$this->oContext->sqlCountryList;
 972         }
 973
 974         return '';
 975     }
 976
 977     /////////// Sort functions
 978
 979
 980     public static function bySearchRank($a, $b)
 981     {
 982         if ($a->iSearchRank == $b->iSearchRank) {
 983             return $a->iOperator + strlen($a->sHouseNumber)
 984                      - $b->iOperator - strlen($b->sHouseNumber);
 985         }
 986
 987         return $a->iSearchRank < $b->iSearchRank ? -1 : 1;
 988     }
 989
 990     //////////// Debugging functions
 991
 992
 993     public function debugInfo()
 994     {
 995         return array(
 996                 'Search rank' => $this->iSearchRank,
 997                 'Country code' => $this->sCountryCode,
 998                 'Name terms' => $this->aName,
 999                 'Name terms (stop words)' => $this->aNameNonSearch,
1000                 'Address terms' => $this->aAddress,
1001                 'Address terms (stop words)' => $this->aAddressNonSearch,
1002                 'Address terms (full words)' => $this->aFullNameAddress ?? '',
1003                 'Special search' => $this->iOperator,
1004                 'Class' => $this->sClass,
1005                 'Type' => $this->sType,
1006                 'House number' => $this->sHouseNumber,
1007                 'Postcode' => $this->sPostcode
1008                );
1009     }
1010
1011     public function dumpAsHtmlTableRow(&$aWordIDs)
1012     {
1013         $kf = function ($k) use (&$aWordIDs) {
1014             return $aWordIDs[$k] ?? '['.$k.']';
1015         };
1016
1017         echo '<tr>';
1018         echo "<td>$this->iSearchRank</td>";
1019         echo '<td>'.join(', ', array_map($kf, $this->aName)).'</td>';
1020         echo '<td>'.join(', ', array_map($kf, $this->aNameNonSearch)).'</td>';
1021         echo '<td>'.join(', ', array_map($kf, $this->aAddress)).'</td>';
1022         echo '<td>'.join(', ', array_map($kf, $this->aAddressNonSearch)).'</td>';
1023         echo '<td>'.$this->sCountryCode.'</td>';
1024         echo '<td>'.Operator::toString($this->iOperator).'</td>';
1025         echo '<td>'.$this->sClass.'</td>';
1026         echo '<td>'.$this->sType.'</td>';
1027         echo '<td>'.$this->sPostcode.'</td>';
1028         echo '<td>'.$this->sHouseNumber.'</td>';
1029
1030         echo '</tr>';
1031     }
1032 }