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. Remeber that with ordering
 585         // every single result has to be checked.
 586         if ($this->sHouseNumber && ($this->bRareName || !empty($this->aAddress) || $this->sPostcode)) {
 587             $sHouseNumberRegex = '\\\\m'.$this->sHouseNumber.'\\\\M';
 588             $aOrder[] = ' (';
 589             $aOrder[0] .= 'EXISTS(';
 590             $aOrder[0] .= '  SELECT place_id';
 591             $aOrder[0] .= '  FROM placex';
 592             $aOrder[0] .= '  WHERE parent_place_id = search_name.place_id';
 593             $aOrder[0] .= "    AND housenumber ~* E'".$sHouseNumberRegex."'";
 594             $aOrder[0] .= '  LIMIT 1';
 595             $aOrder[0] .= ') ';
 596             // also housenumbers from interpolation lines table are needed
 597             if (preg_match('/[0-9]+/', $this->sHouseNumber)) {
 598                 $iHouseNumber = intval($this->sHouseNumber);
 599                 $aOrder[0] .= 'OR EXISTS(';
 600                 $aOrder[0] .= '  SELECT place_id ';
 601                 $aOrder[0] .= '  FROM location_property_osmline ';
 602                 $aOrder[0] .= '  WHERE parent_place_id = search_name.place_id';
 603                 $aOrder[0] .= '    AND startnumber is not NULL';
 604                 $aOrder[0] .= '    AND '.$iHouseNumber.'>=startnumber ';
 605                 $aOrder[0] .= '    AND '.$iHouseNumber.'<=endnumber ';
 606                 $aOrder[0] .= '  LIMIT 1';
 607                 $aOrder[0] .= ')';
 608             }
 609             $aOrder[0] .= ') DESC';
 610         }
 611
 612         if (!empty($this->aName)) {
 613             $aTerms[] = 'name_vector @> '.$oDB->getArraySQL($this->aName);
 614         }
 615         if (!empty($this->aAddress)) {
 616             // For infrequent name terms disable index usage for address
 617             if ($this->bRareName) {
 618                 $aTerms[] = 'array_cat(nameaddress_vector,ARRAY[]::integer[]) @> '.$oDB->getArraySQL($this->aAddress);
 619             } else {
 620                 $aTerms[] = 'nameaddress_vector @> '.$oDB->getArraySQL($this->aAddress);
 621             }
 622         }
 623
 624         $sCountryTerm = $this->countryCodeSQL('country_code');
 625         if ($sCountryTerm) {
 626             $aTerms[] = $sCountryTerm;
 627         }
 628
 629         if ($this->sHouseNumber) {
 630             $aTerms[] = 'address_rank between 16 and 30';
 631         } elseif (!$this->sClass || $this->iOperator == Operator::NAME) {
 632             if ($iMinAddressRank > 0) {
 633                 $aTerms[] = "((address_rank between $iMinAddressRank and $iMaxAddressRank) or (search_rank between $iMinAddressRank and $iMaxAddressRank))";
 634             }
 635         }
 636
 637         if ($this->oContext->hasNearPoint()) {
 638             $aTerms[] = $this->oContext->withinSQL('centroid');
 639             $aOrder[] = $this->oContext->distanceSQL('centroid');
 640         } elseif ($this->sPostcode) {
 641             if (empty($this->aAddress)) {
 642                 $aTerms[] = "EXISTS(SELECT place_id FROM location_postcode p WHERE p.postcode = '".$this->sPostcode."' AND ST_DWithin(search_name.centroid, p.geometry, 0.12))";
 643             } else {
 644                 $aOrder[] = "(SELECT min(ST_Distance(search_name.centroid, p.geometry)) FROM location_postcode p WHERE p.postcode = '".$this->sPostcode."')";
 645             }
 646         }
 647
 648         $sExcludeSQL = $this->oContext->excludeSQL('place_id');
 649         if ($sExcludeSQL) {
 650             $aTerms[] = $sExcludeSQL;
 651         }
 652
 653         if ($this->oContext->bViewboxBounded) {
 654             $aTerms[] = 'centroid && '.$this->oContext->sqlViewboxSmall;
 655         }
 656
 657         if ($this->oContext->hasNearPoint()) {
 658             $aOrder[] = $this->oContext->distanceSQL('centroid');
 659         }
 660
 661         if ($this->sHouseNumber) {
 662             $sImportanceSQL = '- abs(26 - address_rank) + 3';
 663         } else {
 664             $sImportanceSQL = '(CASE WHEN importance = 0 OR importance IS NULL THEN 0.75001-(search_rank::float/40) ELSE importance END)';
 665         }
 666         $sImportanceSQL .= $this->oContext->viewboxImportanceSQL('centroid');
 667         $aOrder[] = "$sImportanceSQL DESC";
 668
 669         $aFullNameAddress = $this->oContext->getFullNameTerms();
 670         if (!empty($aFullNameAddress)) {
 671             $sExactMatchSQL = ' ( ';
 672             $sExactMatchSQL .= ' SELECT count(*) FROM ( ';
 673             $sExactMatchSQL .= '  SELECT unnest('.$oDB->getArraySQL($aFullNameAddress).')';
 674             $sExactMatchSQL .= '    INTERSECT ';
 675             $sExactMatchSQL .= '  SELECT unnest(nameaddress_vector)';
 676             $sExactMatchSQL .= ' ) s';
 677             $sExactMatchSQL .= ') as exactmatch';
 678             $aOrder[] = 'exactmatch DESC';
 679         } else {
 680             $sExactMatchSQL = '0::int as exactmatch';
 681         }
 682
 683         if ($this->sHouseNumber || $this->sClass) {
 684             $iLimit = 40;
 685         }
 686
 687         $aResults = array();
 688
 689         if (!empty($aTerms)) {
 690             $sSQL = 'SELECT place_id, address_rank,'.$sExactMatchSQL;
 691             $sSQL .= ' FROM search_name';
 692             $sSQL .= ' WHERE '.join(' and ', $aTerms);
 693             $sSQL .= ' ORDER BY '.join(', ', $aOrder);
 694             $sSQL .= ' LIMIT '.$iLimit;
 695
 696             Debug::printSQL($sSQL);
 697
 698             $aDBResults = $oDB->getAll($sSQL, null, 'Could not get places for search terms.');
 699
 700             foreach ($aDBResults as $aResult) {
 701                 $oResult = new Result($aResult['place_id']);
 702                 $oResult->iExactMatches = $aResult['exactmatch'];
 703                 $oResult->iAddressRank = $aResult['address_rank'];
 704                 $aResults[$aResult['place_id']] = $oResult;
 705             }
 706         }
 707
 708         return $aResults;
 709     }
 710
 711     private function queryHouseNumber(&$oDB, $aRoadPlaceIDs)
 712     {
 713         $aResults = array();
 714         $sRoadPlaceIDs = Result::joinIdsByTableMaxRank(
 715             $aRoadPlaceIDs,
 716             Result::TABLE_PLACEX,
 717             27
 718         );
 719         $sPOIPlaceIDs = Result::joinIdsByTableMinRank(
 720             $aRoadPlaceIDs,
 721             Result::TABLE_PLACEX,
 722             30
 723         );
 724
 725         $aIDCondition = array();
 726         if ($sRoadPlaceIDs) {
 727             $aIDCondition[] = 'parent_place_id in ('.$sRoadPlaceIDs.')';
 728         }
 729         if ($sPOIPlaceIDs) {
 730             $aIDCondition[] = 'place_id in ('.$sPOIPlaceIDs.')';
 731         }
 732
 733         if (empty($aIDCondition)) {
 734             return $aResults;
 735         }
 736
 737         $sHouseNumberRegex = '\\\\m'.$this->sHouseNumber.'\\\\M';
 738         $sSQL = 'SELECT place_id FROM placex WHERE';
 739         $sSQL .= "  housenumber ~* E'".$sHouseNumberRegex."'";
 740         $sSQL .= ' AND ('.join(' OR ', $aIDCondition).')';
 741         $sSQL .= $this->oContext->excludeSQL(' AND place_id');
 742
 743         Debug::printSQL($sSQL);
 744
 745         // XXX should inherit the exactMatches from its parent
 746         foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 747             $aResults[$iPlaceId] = new Result($iPlaceId);
 748         }
 749
 750         $bIsIntHouseNumber= (bool) preg_match('/[0-9]+/', $this->sHouseNumber);
 751         $iHousenumber = intval($this->sHouseNumber);
 752         if ($bIsIntHouseNumber && $sRoadPlaceIDs && empty($aResults)) {
 753             // if nothing found, search in the interpolation line table
 754             $sSQL = 'SELECT distinct place_id FROM location_property_osmline';
 755             $sSQL .= ' WHERE startnumber is not NULL';
 756             $sSQL .= '  AND parent_place_id in ('.$sRoadPlaceIDs.') AND (';
 757             if ($iHousenumber % 2 == 0) {
 758                 // If housenumber is even, look for housenumber in streets
 759                 // with interpolationtype even or all.
 760                 $sSQL .= "interpolationtype='even'";
 761             } else {
 762                 // Else look for housenumber with interpolationtype odd or all.
 763                 $sSQL .= "interpolationtype='odd'";
 764             }
 765             $sSQL .= " or interpolationtype='all') and ";
 766             $sSQL .= $iHousenumber.'>=startnumber and ';
 767             $sSQL .= $iHousenumber.'<=endnumber';
 768             $sSQL .= $this->oContext->excludeSQL(' AND place_id');
 769
 770             Debug::printSQL($sSQL);
 771
 772             foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 773                 $oResult = new Result($iPlaceId, Result::TABLE_OSMLINE);
 774                 $oResult->iHouseNumber = $iHousenumber;
 775                 $aResults[$iPlaceId] = $oResult;
 776             }
 777         }
 778
 779         // If nothing found then search in Tiger data (location_property_tiger)
 780         if (CONST_Use_US_Tiger_Data && $sRoadPlaceIDs && $bIsIntHouseNumber && empty($aResults)) {
 781             $sSQL = 'SELECT place_id FROM location_property_tiger';
 782             $sSQL .= ' WHERE parent_place_id in ('.$sRoadPlaceIDs.') and (';
 783             if ($iHousenumber % 2 == 0) {
 784                 $sSQL .= "interpolationtype='even'";
 785             } else {
 786                 $sSQL .= "interpolationtype='odd'";
 787             }
 788             $sSQL .= " or interpolationtype='all') and ";
 789             $sSQL .= $iHousenumber.'>=startnumber and ';
 790             $sSQL .= $iHousenumber.'<=endnumber';
 791             $sSQL .= $this->oContext->excludeSQL(' AND place_id');
 792
 793             Debug::printSQL($sSQL);
 794
 795             foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 796                 $oResult = new Result($iPlaceId, Result::TABLE_TIGER);
 797                 $oResult->iHouseNumber = $iHousenumber;
 798                 $aResults[$iPlaceId] = $oResult;
 799             }
 800         }
 801
 802         return $aResults;
 803     }
 804
 805
 806     private function queryPoiByOperator(&$oDB, $aParentIDs, $iLimit)
 807     {
 808         $aResults = array();
 809         $sPlaceIDs = Result::joinIdsByTable($aParentIDs, Result::TABLE_PLACEX);
 810
 811         if (!$sPlaceIDs) {
 812             return $aResults;
 813         }
 814
 815         if ($this->iOperator == Operator::TYPE || $this->iOperator == Operator::NAME) {
 816             // If they were searching for a named class (i.e. 'Kings Head pub')
 817             // then we might have an extra match
 818             $sSQL = 'SELECT place_id FROM placex ';
 819             $sSQL .= " WHERE place_id in ($sPlaceIDs)";
 820             $sSQL .= "   AND class='".$this->sClass."' ";
 821             $sSQL .= "   AND type='".$this->sType."'";
 822             $sSQL .= '   AND linked_place_id is null';
 823             $sSQL .= $this->oContext->excludeSQL(' AND place_id');
 824             $sSQL .= ' ORDER BY rank_search ASC ';
 825             $sSQL .= " LIMIT $iLimit";
 826
 827             Debug::printSQL($sSQL);
 828
 829             foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 830                 $aResults[$iPlaceId] = new Result($iPlaceId);
 831             }
 832         }
 833
 834         // NEAR and IN are handled the same
 835         if ($this->iOperator == Operator::TYPE || $this->iOperator == Operator::NEAR) {
 836             $sClassTable = $this->poiTable();
 837             $bCacheTable = $oDB->tableExists($sClassTable);
 838
 839             $sSQL = "SELECT min(rank_search) FROM placex WHERE place_id in ($sPlaceIDs)";
 840             Debug::printSQL($sSQL);
 841             $iMaxRank = (int) $oDB->getOne($sSQL);
 842
 843             // For state / country level searches the normal radius search doesn't work very well
 844             $sPlaceGeom = false;
 845             if ($iMaxRank < 9 && $bCacheTable) {
 846                 // Try and get a polygon to search in instead
 847                 $sSQL = 'SELECT geometry FROM placex';
 848                 $sSQL .= " WHERE place_id in ($sPlaceIDs)";
 849                 $sSQL .= "   AND rank_search < $iMaxRank + 5";
 850                 $sSQL .= "   AND ST_GeometryType(geometry) in ('ST_Polygon','ST_MultiPolygon')";
 851                 $sSQL .= ' ORDER BY rank_search ASC ';
 852                 $sSQL .= ' LIMIT 1';
 853                 Debug::printSQL($sSQL);
 854                 $sPlaceGeom = $oDB->getOne($sSQL);
 855             }
 856
 857             if ($sPlaceGeom) {
 858                 $sPlaceIDs = false;
 859             } else {
 860                 $iMaxRank += 5;
 861                 $sSQL = 'SELECT place_id FROM placex';
 862                 $sSQL .= " WHERE place_id in ($sPlaceIDs) and rank_search < $iMaxRank";
 863                 Debug::printSQL($sSQL);
 864                 $aPlaceIDs = $oDB->getCol($sSQL);
 865                 $sPlaceIDs = join(',', $aPlaceIDs);
 866             }
 867
 868             if ($sPlaceIDs || $sPlaceGeom) {
 869                 $fRange = 0.01;
 870                 if ($bCacheTable) {
 871                     // More efficient - can make the range bigger
 872                     $fRange = 0.05;
 873
 874                     $sOrderBySQL = '';
 875                     if ($this->oContext->hasNearPoint()) {
 876                         $sOrderBySQL = $this->oContext->distanceSQL('l.centroid');
 877                     } elseif ($sPlaceIDs) {
 878                         $sOrderBySQL = 'ST_Distance(l.centroid, f.geometry)';
 879                     } elseif ($sPlaceGeom) {
 880                         $sOrderBySQL = "ST_Distance(st_centroid('".$sPlaceGeom."'), l.centroid)";
 881                     }
 882
 883                     $sSQL = 'SELECT distinct i.place_id';
 884                     if ($sOrderBySQL) {
 885                         $sSQL .= ', i.order_term';
 886                     }
 887                     $sSQL .= ' from (SELECT l.place_id';
 888                     if ($sOrderBySQL) {
 889                         $sSQL .= ','.$sOrderBySQL.' as order_term';
 890                     }
 891                     $sSQL .= ' from '.$sClassTable.' as l';
 892
 893                     if ($sPlaceIDs) {
 894                         $sSQL .= ',placex as f WHERE ';
 895                         $sSQL .= "f.place_id in ($sPlaceIDs) ";
 896                         $sSQL .= " AND ST_DWithin(l.centroid, f.centroid, $fRange)";
 897                     } elseif ($sPlaceGeom) {
 898                         $sSQL .= " WHERE ST_Contains('$sPlaceGeom', l.centroid)";
 899                     }
 900
 901                     $sSQL .= $this->oContext->excludeSQL(' AND l.place_id');
 902                     $sSQL .= 'limit 300) i ';
 903                     if ($sOrderBySQL) {
 904                         $sSQL .= 'order by order_term asc';
 905                     }
 906                     $sSQL .= " limit $iLimit";
 907
 908                     Debug::printSQL($sSQL);
 909
 910                     foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 911                         $aResults[$iPlaceId] = new Result($iPlaceId);
 912                     }
 913                 } else {
 914                     if ($this->oContext->hasNearPoint()) {
 915                         $fRange = $this->oContext->nearRadius();
 916                     }
 917
 918                     $sOrderBySQL = '';
 919                     if ($this->oContext->hasNearPoint()) {
 920                         $sOrderBySQL = $this->oContext->distanceSQL('l.geometry');
 921                     } else {
 922                         $sOrderBySQL = 'ST_Distance(l.geometry, f.geometry)';
 923                     }
 924
 925                     $sSQL = 'SELECT distinct l.place_id';
 926                     if ($sOrderBySQL) {
 927                         $sSQL .= ','.$sOrderBySQL.' as orderterm';
 928                     }
 929                     $sSQL .= ' FROM placex as l, placex as f';
 930                     $sSQL .= " WHERE f.place_id in ($sPlaceIDs)";
 931                     $sSQL .= "  AND ST_DWithin(l.geometry, f.centroid, $fRange)";
 932                     $sSQL .= "  AND l.class='".$this->sClass."'";
 933                     $sSQL .= "  AND l.type='".$this->sType."'";
 934                     $sSQL .= $this->oContext->excludeSQL(' AND l.place_id');
 935                     if ($sOrderBySQL) {
 936                         $sSQL .= 'ORDER BY orderterm ASC';
 937                     }
 938                     $sSQL .= " limit $iLimit";
 939
 940                     Debug::printSQL($sSQL);
 941
 942                     foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 943                         $aResults[$iPlaceId] = new Result($iPlaceId);
 944                     }
 945                 }
 946             }
 947         }
 948
 949         return $aResults;
 950     }
 951
 952     private function poiTable()
 953     {
 954         return 'place_classtype_'.$this->sClass.'_'.$this->sType;
 955     }
 956
 957     private function countryCodeSQL($sVar)
 958     {
 959         if ($this->sCountryCode) {
 960             return $sVar.' = \''.$this->sCountryCode."'";
 961         }
 962         if ($this->oContext->sqlCountryList) {
 963             return $sVar.' in '.$this->oContext->sqlCountryList;
 964         }
 965
 966         return '';
 967     }
 968
 969     /////////// Sort functions
 970
 971
 972     public static function bySearchRank($a, $b)
 973     {
 974         if ($a->iSearchRank == $b->iSearchRank) {
 975             return $a->iOperator + strlen($a->sHouseNumber)
 976                      - $b->iOperator - strlen($b->sHouseNumber);
 977         }
 978
 979         return $a->iSearchRank < $b->iSearchRank ? -1 : 1;
 980     }
 981
 982     //////////// Debugging functions
 983
 984
 985     public function debugInfo()
 986     {
 987         return array(
 988                 'Search rank' => $this->iSearchRank,
 989                 'Country code' => $this->sCountryCode,
 990                 'Name terms' => $this->aName,
 991                 'Name terms (stop words)' => $this->aNameNonSearch,
 992                 'Address terms' => $this->aAddress,
 993                 'Address terms (stop words)' => $this->aAddressNonSearch,
 994                 'Address terms (full words)' => $this->aFullNameAddress ?? '',
 995                 'Special search' => $this->iOperator,
 996                 'Class' => $this->sClass,
 997                 'Type' => $this->sType,
 998                 'House number' => $this->sHouseNumber,
 999                 'Postcode' => $this->sPostcode
1000                );
1001     }
1002
1003     public function dumpAsHtmlTableRow(&$aWordIDs)
1004     {
1005         $kf = function ($k) use (&$aWordIDs) {
1006             return $aWordIDs[$k] ?? '['.$k.']';
1007         };
1008
1009         echo '<tr>';
1010         echo "<td>$this->iSearchRank</td>";
1011         echo '<td>'.join(', ', array_map($kf, $this->aName)).'</td>';
1012         echo '<td>'.join(', ', array_map($kf, $this->aNameNonSearch)).'</td>';
1013         echo '<td>'.join(', ', array_map($kf, $this->aAddress)).'</td>';
1014         echo '<td>'.join(', ', array_map($kf, $this->aAddressNonSearch)).'</td>';
1015         echo '<td>'.$this->sCountryCode.'</td>';
1016         echo '<td>'.Operator::toString($this->iOperator).'</td>';
1017         echo '<td>'.$this->sClass.'</td>';
1018         echo '<td>'.$this->sType.'</td>';
1019         echo '<td>'.$this->sPostcode.'</td>';
1020         echo '<td>'.$this->sHouseNumber.'</td>';
1021
1022         echo '</tr>';
1023     }
1024 }