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->bNeedsAddress = 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->aName = array($iId => $iId);
 328         $this->iNamePhrase = -1;
 329     }
 330
 331     /**
 332      * Make this search a POI search.
 333      *
 334      * In a POI search, objects are not (only) searched by their name
 335      * but also by the primary OSM key/value pair (class and type in Nominatim).
 336      *
 337      * @param integer $iOperator Type of POI search
 338      * @param string  $sClass    Class (or OSM tag key) of POI.
 339      * @param string  $sType     Type (or OSM tag value) of POI.
 340      *
 341      * @return void
 342      */
 343     public function setPoiSearch($iOperator, $sClass, $sType)
 344     {
 345         $this->iOperator = $iOperator;
 346         $this->sClass = $sClass;
 347         $this->sType = $sType;
 348         $this->iNamePhrase = -1;
 349     }
 350
 351     public function getNamePhrase()
 352     {
 353         return $this->iNamePhrase;
 354     }
 355
 356     /**
 357      * Get the global search context.
 358      *
 359      * @return object  Objects of global search constraints.
 360      */
 361     public function getContext()
 362     {
 363         return $this->oContext;
 364     }
 365
 366     /////////// Query functions
 367
 368
 369     /**
 370      * Query database for places that match this search.
 371      *
 372      * @param object  $oDB      Nominatim::DB instance to use.
 373      * @param integer $iMinRank Minimum address rank to restrict search to.
 374      * @param integer $iMaxRank Maximum address rank to restrict search to.
 375      * @param integer $iLimit   Maximum number of results.
 376      *
 377      * @return mixed[] An array with two fields: IDs contains the list of
 378      *                 matching place IDs and houseNumber the houseNumber
 379      *                 if appicable or -1 if not.
 380      */
 381     public function query(&$oDB, $iMinRank, $iMaxRank, $iLimit)
 382     {
 383         $aResults = array();
 384
 385         if ($this->sCountryCode
 386             && empty($this->aName)
 387             && !$this->iOperator
 388             && !$this->sClass
 389             && !$this->oContext->hasNearPoint()
 390         ) {
 391             // Just looking for a country - look it up
 392             if (4 >= $iMinRank && 4 <= $iMaxRank) {
 393                 $aResults = $this->queryCountry($oDB);
 394             }
 395         } elseif (empty($this->aName) && empty($this->aAddress)) {
 396             // Neither name nor address? Then we must be
 397             // looking for a POI in a geographic area.
 398             if ($this->oContext->isBoundedSearch()) {
 399                 $aResults = $this->queryNearbyPoi($oDB, $iLimit);
 400             }
 401         } elseif ($this->iOperator == Operator::POSTCODE) {
 402             // looking for postcode
 403             $aResults = $this->queryPostcode($oDB, $iLimit);
 404         } else {
 405             // Ordinary search:
 406             // First search for places according to name and address.
 407             $aResults = $this->queryNamedPlace(
 408                 $oDB,
 409                 $iMinRank,
 410                 $iMaxRank,
 411                 $iLimit
 412             );
 413
 414             // Now search for housenumber, if housenumber provided. Can be zero.
 415             if (($this->sHouseNumber || $this->sHouseNumber === '0') && !empty($aResults)) {
 416                 $aHnResults = $this->queryHouseNumber($oDB, $aResults);
 417
 418                 // Downgrade the rank of the street results, they are missing
 419                 // the housenumber. Also drop POI places (rank 30) here, they
 420                 // cannot be a parent place and therefore must not be shown
 421                 // as a result for a search with a missing housenumber.
 422                 foreach ($aResults as $oRes) {
 423                     if ($oRes->iAddressRank < 28) {
 424                         if ($oRes->iAddressRank >= 26) {
 425                             $oRes->iResultRank++;
 426                         } else {
 427                             $oRes->iResultRank += 2;
 428                         }
 429                         $aHnResults[$oRes->iId] = $oRes;
 430                     }
 431                 }
 432
 433                 $aResults = $aHnResults;
 434             }
 435
 436             // finally get POIs if requested
 437             if ($this->sClass && !empty($aResults)) {
 438                 $aResults = $this->queryPoiByOperator($oDB, $aResults, $iLimit);
 439             }
 440         }
 441
 442         Debug::printDebugTable('Place IDs', $aResults);
 443
 444         if (!empty($aResults) && $this->sPostcode) {
 445             $sPlaceIds = Result::joinIdsByTable($aResults, Result::TABLE_PLACEX);
 446             if ($sPlaceIds) {
 447                 $sSQL = 'SELECT place_id FROM placex';
 448                 $sSQL .= ' WHERE place_id in ('.$sPlaceIds.')';
 449                 $sSQL .= " AND postcode != '".$this->sPostcode."'";
 450                 Debug::printSQL($sSQL);
 451                 $aFilteredPlaceIDs = $oDB->getCol($sSQL);
 452                 if ($aFilteredPlaceIDs) {
 453                     foreach ($aFilteredPlaceIDs as $iPlaceId) {
 454                         $aResults[$iPlaceId]->iResultRank++;
 455                     }
 456                 }
 457             }
 458         }
 459
 460         return $aResults;
 461     }
 462
 463
 464     private function queryCountry(&$oDB)
 465     {
 466         $sSQL = 'SELECT place_id FROM placex ';
 467         $sSQL .= "WHERE country_code='".$this->sCountryCode."'";
 468         $sSQL .= ' AND rank_search = 4';
 469         if ($this->oContext->bViewboxBounded) {
 470             $sSQL .= ' AND ST_Intersects('.$this->oContext->sqlViewboxSmall.', geometry)';
 471         }
 472         $sSQL .= ' ORDER BY st_area(geometry) DESC LIMIT 1';
 473
 474         Debug::printSQL($sSQL);
 475
 476         $iPlaceId = $oDB->getOne($sSQL);
 477
 478         $aResults = array();
 479         if ($iPlaceId) {
 480             $aResults[$iPlaceId] = new Result($iPlaceId);
 481         }
 482
 483         return $aResults;
 484     }
 485
 486     private function queryNearbyPoi(&$oDB, $iLimit)
 487     {
 488         if (!$this->sClass) {
 489             return array();
 490         }
 491
 492         $aDBResults = array();
 493         $sPoiTable = $this->poiTable();
 494
 495         if ($oDB->tableExists($sPoiTable)) {
 496             $sSQL = 'SELECT place_id FROM '.$sPoiTable.' ct';
 497             if ($this->oContext->sqlCountryList) {
 498                 $sSQL .= ' JOIN placex USING (place_id)';
 499             }
 500             if ($this->oContext->hasNearPoint()) {
 501                 $sSQL .= ' WHERE '.$this->oContext->withinSQL('ct.centroid');
 502             } elseif ($this->oContext->bViewboxBounded) {
 503                 $sSQL .= ' WHERE ST_Contains('.$this->oContext->sqlViewboxSmall.', ct.centroid)';
 504             }
 505             if ($this->oContext->sqlCountryList) {
 506                 $sSQL .= ' AND country_code in '.$this->oContext->sqlCountryList;
 507             }
 508             $sSQL .= $this->oContext->excludeSQL(' AND place_id');
 509             if ($this->oContext->sqlViewboxCentre) {
 510                 $sSQL .= ' ORDER BY ST_Distance(';
 511                 $sSQL .= $this->oContext->sqlViewboxCentre.', ct.centroid) ASC';
 512             } elseif ($this->oContext->hasNearPoint()) {
 513                 $sSQL .= ' ORDER BY '.$this->oContext->distanceSQL('ct.centroid').' ASC';
 514             }
 515             $sSQL .= " LIMIT $iLimit";
 516             Debug::printSQL($sSQL);
 517             $aDBResults = $oDB->getCol($sSQL);
 518         }
 519
 520         if ($this->oContext->hasNearPoint()) {
 521             $sSQL = 'SELECT place_id FROM placex WHERE ';
 522             $sSQL .= 'class = :class and type = :type';
 523             $sSQL .= ' AND '.$this->oContext->withinSQL('geometry');
 524             $sSQL .= ' AND linked_place_id is null';
 525             if ($this->oContext->sqlCountryList) {
 526                 $sSQL .= ' AND country_code in '.$this->oContext->sqlCountryList;
 527             }
 528             $sSQL .= ' ORDER BY '.$this->oContext->distanceSQL('centroid').' ASC';
 529             $sSQL .= " LIMIT $iLimit";
 530             Debug::printSQL($sSQL);
 531             $aDBResults = $oDB->getCol(
 532                 $sSQL,
 533                 array(':class' => $this->sClass, ':type' => $this->sType)
 534             );
 535         }
 536
 537         $aResults = array();
 538         foreach ($aDBResults as $iPlaceId) {
 539             $aResults[$iPlaceId] = new Result($iPlaceId);
 540         }
 541
 542         return $aResults;
 543     }
 544
 545     private function queryPostcode(&$oDB, $iLimit)
 546     {
 547         $sSQL = 'SELECT p.place_id FROM location_postcode p ';
 548
 549         if (!empty($this->aAddress)) {
 550             $sSQL .= ', search_name s ';
 551             $sSQL .= 'WHERE s.place_id = p.parent_place_id ';
 552             $sSQL .= 'AND array_cat(s.nameaddress_vector, s.name_vector)';
 553             $sSQL .= '      @> '.$oDB->getArraySQL($this->aAddress).' AND ';
 554         } else {
 555             $sSQL .= 'WHERE ';
 556         }
 557
 558         $sSQL .= "p.postcode = '".reset($this->aName)."'";
 559         $sSQL .= $this->countryCodeSQL(' AND p.country_code');
 560         if ($this->oContext->bViewboxBounded) {
 561             $sSQL .= ' AND ST_Intersects('.$this->oContext->sqlViewboxSmall.', geometry)';
 562         }
 563         $sSQL .= $this->oContext->excludeSQL(' AND p.place_id');
 564         $sSQL .= " LIMIT $iLimit";
 565
 566         Debug::printSQL($sSQL);
 567
 568         $aResults = array();
 569         foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 570             $aResults[$iPlaceId] = new Result($iPlaceId, Result::TABLE_POSTCODE);
 571         }
 572
 573         return $aResults;
 574     }
 575
 576     private function queryNamedPlace(&$oDB, $iMinAddressRank, $iMaxAddressRank, $iLimit)
 577     {
 578         $aTerms = array();
 579         $aOrder = array();
 580
 581         // Sort by existence of the requested house number but only if not
 582         // too many results are expected for the street, i.e. if the result
 583         // will be narrowed down by an address. Remeber that with ordering
 584         // every single result has to be checked.
 585         if ($this->sHouseNumber && ($this->bRareName || !empty($this->aAddress) || $this->sPostcode)) {
 586             $sHouseNumberRegex = '\\\\m'.$this->sHouseNumber.'\\\\M';
 587             $aOrder[] = ' (';
 588             $aOrder[0] .= 'EXISTS(';
 589             $aOrder[0] .= '  SELECT place_id';
 590             $aOrder[0] .= '  FROM placex';
 591             $aOrder[0] .= '  WHERE parent_place_id = search_name.place_id';
 592             $aOrder[0] .= "    AND housenumber ~* E'".$sHouseNumberRegex."'";
 593             $aOrder[0] .= '  LIMIT 1';
 594             $aOrder[0] .= ') ';
 595             // also housenumbers from interpolation lines table are needed
 596             if (preg_match('/[0-9]+/', $this->sHouseNumber)) {
 597                 $iHouseNumber = intval($this->sHouseNumber);
 598                 $aOrder[0] .= 'OR EXISTS(';
 599                 $aOrder[0] .= '  SELECT place_id ';
 600                 $aOrder[0] .= '  FROM location_property_osmline ';
 601                 $aOrder[0] .= '  WHERE parent_place_id = search_name.place_id';
 602                 $aOrder[0] .= '    AND startnumber is not NULL';
 603                 $aOrder[0] .= '    AND '.$iHouseNumber.'>=startnumber ';
 604                 $aOrder[0] .= '    AND '.$iHouseNumber.'<=endnumber ';
 605                 $aOrder[0] .= '  LIMIT 1';
 606                 $aOrder[0] .= ')';
 607             }
 608             $aOrder[0] .= ') DESC';
 609         }
 610
 611         if (!empty($this->aName)) {
 612             $aTerms[] = 'name_vector @> '.$oDB->getArraySQL($this->aName);
 613         }
 614         if (!empty($this->aAddress)) {
 615             // For infrequent name terms disable index usage for address
 616             if ($this->bRareName) {
 617                 $aTerms[] = 'array_cat(nameaddress_vector,ARRAY[]::integer[]) @> '.$oDB->getArraySQL($this->aAddress);
 618             } else {
 619                 $aTerms[] = 'nameaddress_vector @> '.$oDB->getArraySQL($this->aAddress);
 620             }
 621         }
 622
 623         $sCountryTerm = $this->countryCodeSQL('country_code');
 624         if ($sCountryTerm) {
 625             $aTerms[] = $sCountryTerm;
 626         }
 627
 628         if ($this->sHouseNumber) {
 629             $aTerms[] = 'address_rank between 16 and 30';
 630         } elseif (!$this->sClass || $this->iOperator == Operator::NAME) {
 631             if ($iMinAddressRank > 0) {
 632                 $aTerms[] = "((address_rank between $iMinAddressRank and $iMaxAddressRank) or (search_rank between $iMinAddressRank and $iMaxAddressRank))";
 633             }
 634         }
 635
 636         if ($this->oContext->hasNearPoint()) {
 637             $aTerms[] = $this->oContext->withinSQL('centroid');
 638             $aOrder[] = $this->oContext->distanceSQL('centroid');
 639         } elseif ($this->sPostcode) {
 640             if (empty($this->aAddress)) {
 641                 $aTerms[] = "EXISTS(SELECT place_id FROM location_postcode p WHERE p.postcode = '".$this->sPostcode."' AND ST_DWithin(search_name.centroid, p.geometry, 0.12))";
 642             } else {
 643                 $aOrder[] = "(SELECT min(ST_Distance(search_name.centroid, p.geometry)) FROM location_postcode p WHERE p.postcode = '".$this->sPostcode."')";
 644             }
 645         }
 646
 647         $sExcludeSQL = $this->oContext->excludeSQL('place_id');
 648         if ($sExcludeSQL) {
 649             $aTerms[] = $sExcludeSQL;
 650         }
 651
 652         if ($this->oContext->bViewboxBounded) {
 653             $aTerms[] = 'centroid && '.$this->oContext->sqlViewboxSmall;
 654         }
 655
 656         if ($this->oContext->hasNearPoint()) {
 657             $aOrder[] = $this->oContext->distanceSQL('centroid');
 658         }
 659
 660         if ($this->sHouseNumber) {
 661             $sImportanceSQL = '- abs(26 - address_rank) + 3';
 662         } else {
 663             $sImportanceSQL = '(CASE WHEN importance = 0 OR importance IS NULL THEN 0.75001-(search_rank::float/40) ELSE importance END)';
 664         }
 665         $sImportanceSQL .= $this->oContext->viewboxImportanceSQL('centroid');
 666         $aOrder[] = "$sImportanceSQL DESC";
 667
 668         $aFullNameAddress = $this->oContext->getFullNameTerms();
 669         if (!empty($aFullNameAddress)) {
 670             $sExactMatchSQL = ' ( ';
 671             $sExactMatchSQL .= ' SELECT count(*) FROM ( ';
 672             $sExactMatchSQL .= '  SELECT unnest('.$oDB->getArraySQL($aFullNameAddress).')';
 673             $sExactMatchSQL .= '    INTERSECT ';
 674             $sExactMatchSQL .= '  SELECT unnest(nameaddress_vector)';
 675             $sExactMatchSQL .= ' ) s';
 676             $sExactMatchSQL .= ') as exactmatch';
 677             $aOrder[] = 'exactmatch DESC';
 678         } else {
 679             $sExactMatchSQL = '0::int as exactmatch';
 680         }
 681
 682         if ($this->sHouseNumber || $this->sClass) {
 683             $iLimit = 40;
 684         }
 685
 686         $aResults = array();
 687
 688         if (!empty($aTerms)) {
 689             $sSQL = 'SELECT place_id, address_rank,'.$sExactMatchSQL;
 690             $sSQL .= ' FROM search_name';
 691             $sSQL .= ' WHERE '.join(' and ', $aTerms);
 692             $sSQL .= ' ORDER BY '.join(', ', $aOrder);
 693             $sSQL .= ' LIMIT '.$iLimit;
 694
 695             Debug::printSQL($sSQL);
 696
 697             $aDBResults = $oDB->getAll($sSQL, null, 'Could not get places for search terms.');
 698
 699             foreach ($aDBResults as $aResult) {
 700                 $oResult = new Result($aResult['place_id']);
 701                 $oResult->iExactMatches = $aResult['exactmatch'];
 702                 $oResult->iAddressRank = $aResult['address_rank'];
 703                 $aResults[$aResult['place_id']] = $oResult;
 704             }
 705         }
 706
 707         return $aResults;
 708     }
 709
 710     private function queryHouseNumber(&$oDB, $aRoadPlaceIDs)
 711     {
 712         $aResults = array();
 713         $sRoadPlaceIDs = Result::joinIdsByTableMaxRank(
 714             $aRoadPlaceIDs,
 715             Result::TABLE_PLACEX,
 716             27
 717         );
 718         $sPOIPlaceIDs = Result::joinIdsByTableMinRank(
 719             $aRoadPlaceIDs,
 720             Result::TABLE_PLACEX,
 721             30
 722         );
 723
 724         $aIDCondition = array();
 725         if ($sRoadPlaceIDs) {
 726             $aIDCondition[] = 'parent_place_id in ('.$sRoadPlaceIDs.')';
 727         }
 728         if ($sPOIPlaceIDs) {
 729             $aIDCondition[] = 'place_id in ('.$sPOIPlaceIDs.')';
 730         }
 731
 732         if (empty($aIDCondition)) {
 733             return $aResults;
 734         }
 735
 736         $sHouseNumberRegex = '\\\\m'.$this->sHouseNumber.'\\\\M';
 737         $sSQL = 'SELECT place_id FROM placex WHERE';
 738         $sSQL .= "  housenumber ~* E'".$sHouseNumberRegex."'";
 739         $sSQL .= ' AND ('.join(' OR ', $aIDCondition).')';
 740         $sSQL .= $this->oContext->excludeSQL(' AND place_id');
 741
 742         Debug::printSQL($sSQL);
 743
 744         // XXX should inherit the exactMatches from its parent
 745         foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 746             $aResults[$iPlaceId] = new Result($iPlaceId);
 747         }
 748
 749         $bIsIntHouseNumber= (bool) preg_match('/[0-9]+/', $this->sHouseNumber);
 750         $iHousenumber = intval($this->sHouseNumber);
 751         if ($bIsIntHouseNumber && $sRoadPlaceIDs && empty($aResults)) {
 752             // if nothing found, search in the interpolation line table
 753             $sSQL = 'SELECT distinct place_id FROM location_property_osmline';
 754             $sSQL .= ' WHERE startnumber is not NULL';
 755             $sSQL .= '  AND parent_place_id in ('.$sRoadPlaceIDs.') AND (';
 756             if ($iHousenumber % 2 == 0) {
 757                 // If housenumber is even, look for housenumber in streets
 758                 // with interpolationtype even or all.
 759                 $sSQL .= "interpolationtype='even'";
 760             } else {
 761                 // Else look for housenumber with interpolationtype odd or all.
 762                 $sSQL .= "interpolationtype='odd'";
 763             }
 764             $sSQL .= " or interpolationtype='all') and ";
 765             $sSQL .= $iHousenumber.'>=startnumber and ';
 766             $sSQL .= $iHousenumber.'<=endnumber';
 767             $sSQL .= $this->oContext->excludeSQL(' AND place_id');
 768
 769             Debug::printSQL($sSQL);
 770
 771             foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 772                 $oResult = new Result($iPlaceId, Result::TABLE_OSMLINE);
 773                 $oResult->iHouseNumber = $iHousenumber;
 774                 $aResults[$iPlaceId] = $oResult;
 775             }
 776         }
 777
 778         // If nothing found then search in Tiger data (location_property_tiger)
 779         if (CONST_Use_US_Tiger_Data && $sRoadPlaceIDs && $bIsIntHouseNumber && empty($aResults)) {
 780             $sSQL = 'SELECT place_id FROM location_property_tiger';
 781             $sSQL .= ' WHERE parent_place_id in ('.$sRoadPlaceIDs.') and (';
 782             if ($iHousenumber % 2 == 0) {
 783                 $sSQL .= "interpolationtype='even'";
 784             } else {
 785                 $sSQL .= "interpolationtype='odd'";
 786             }
 787             $sSQL .= " or interpolationtype='all') and ";
 788             $sSQL .= $iHousenumber.'>=startnumber and ';
 789             $sSQL .= $iHousenumber.'<=endnumber';
 790             $sSQL .= $this->oContext->excludeSQL(' AND place_id');
 791
 792             Debug::printSQL($sSQL);
 793
 794             foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 795                 $oResult = new Result($iPlaceId, Result::TABLE_TIGER);
 796                 $oResult->iHouseNumber = $iHousenumber;
 797                 $aResults[$iPlaceId] = $oResult;
 798             }
 799         }
 800
 801         return $aResults;
 802     }
 803
 804
 805     private function queryPoiByOperator(&$oDB, $aParentIDs, $iLimit)
 806     {
 807         $aResults = array();
 808         $sPlaceIDs = Result::joinIdsByTable($aParentIDs, Result::TABLE_PLACEX);
 809
 810         if (!$sPlaceIDs) {
 811             return $aResults;
 812         }
 813
 814         if ($this->iOperator == Operator::TYPE || $this->iOperator == Operator::NAME) {
 815             // If they were searching for a named class (i.e. 'Kings Head pub')
 816             // then we might have an extra match
 817             $sSQL = 'SELECT place_id FROM placex ';
 818             $sSQL .= " WHERE place_id in ($sPlaceIDs)";
 819             $sSQL .= "   AND class='".$this->sClass."' ";
 820             $sSQL .= "   AND type='".$this->sType."'";
 821             $sSQL .= '   AND linked_place_id is null';
 822             $sSQL .= $this->oContext->excludeSQL(' AND place_id');
 823             $sSQL .= ' ORDER BY rank_search ASC ';
 824             $sSQL .= " LIMIT $iLimit";
 825
 826             Debug::printSQL($sSQL);
 827
 828             foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 829                 $aResults[$iPlaceId] = new Result($iPlaceId);
 830             }
 831         }
 832
 833         // NEAR and IN are handled the same
 834         if ($this->iOperator == Operator::TYPE || $this->iOperator == Operator::NEAR) {
 835             $sClassTable = $this->poiTable();
 836             $bCacheTable = $oDB->tableExists($sClassTable);
 837
 838             $sSQL = "SELECT min(rank_search) FROM placex WHERE place_id in ($sPlaceIDs)";
 839             Debug::printSQL($sSQL);
 840             $iMaxRank = (int) $oDB->getOne($sSQL);
 841
 842             // For state / country level searches the normal radius search doesn't work very well
 843             $sPlaceGeom = false;
 844             if ($iMaxRank < 9 && $bCacheTable) {
 845                 // Try and get a polygon to search in instead
 846                 $sSQL = 'SELECT geometry FROM placex';
 847                 $sSQL .= " WHERE place_id in ($sPlaceIDs)";
 848                 $sSQL .= "   AND rank_search < $iMaxRank + 5";
 849                 $sSQL .= "   AND ST_GeometryType(geometry) in ('ST_Polygon','ST_MultiPolygon')";
 850                 $sSQL .= ' ORDER BY rank_search ASC ';
 851                 $sSQL .= ' LIMIT 1';
 852                 Debug::printSQL($sSQL);
 853                 $sPlaceGeom = $oDB->getOne($sSQL);
 854             }
 855
 856             if ($sPlaceGeom) {
 857                 $sPlaceIDs = false;
 858             } else {
 859                 $iMaxRank += 5;
 860                 $sSQL = 'SELECT place_id FROM placex';
 861                 $sSQL .= " WHERE place_id in ($sPlaceIDs) and rank_search < $iMaxRank";
 862                 Debug::printSQL($sSQL);
 863                 $aPlaceIDs = $oDB->getCol($sSQL);
 864                 $sPlaceIDs = join(',', $aPlaceIDs);
 865             }
 866
 867             if ($sPlaceIDs || $sPlaceGeom) {
 868                 $fRange = 0.01;
 869                 if ($bCacheTable) {
 870                     // More efficient - can make the range bigger
 871                     $fRange = 0.05;
 872
 873                     $sOrderBySQL = '';
 874                     if ($this->oContext->hasNearPoint()) {
 875                         $sOrderBySQL = $this->oContext->distanceSQL('l.centroid');
 876                     } elseif ($sPlaceIDs) {
 877                         $sOrderBySQL = 'ST_Distance(l.centroid, f.geometry)';
 878                     } elseif ($sPlaceGeom) {
 879                         $sOrderBySQL = "ST_Distance(st_centroid('".$sPlaceGeom."'), l.centroid)";
 880                     }
 881
 882                     $sSQL = 'SELECT distinct i.place_id';
 883                     if ($sOrderBySQL) {
 884                         $sSQL .= ', i.order_term';
 885                     }
 886                     $sSQL .= ' from (SELECT l.place_id';
 887                     if ($sOrderBySQL) {
 888                         $sSQL .= ','.$sOrderBySQL.' as order_term';
 889                     }
 890                     $sSQL .= ' from '.$sClassTable.' as l';
 891
 892                     if ($sPlaceIDs) {
 893                         $sSQL .= ',placex as f WHERE ';
 894                         $sSQL .= "f.place_id in ($sPlaceIDs) ";
 895                         $sSQL .= " AND ST_DWithin(l.centroid, f.centroid, $fRange)";
 896                     } elseif ($sPlaceGeom) {
 897                         $sSQL .= " WHERE ST_Contains('$sPlaceGeom', l.centroid)";
 898                     }
 899
 900                     $sSQL .= $this->oContext->excludeSQL(' AND l.place_id');
 901                     $sSQL .= 'limit 300) i ';
 902                     if ($sOrderBySQL) {
 903                         $sSQL .= 'order by order_term asc';
 904                     }
 905                     $sSQL .= " limit $iLimit";
 906
 907                     Debug::printSQL($sSQL);
 908
 909                     foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 910                         $aResults[$iPlaceId] = new Result($iPlaceId);
 911                     }
 912                 } else {
 913                     if ($this->oContext->hasNearPoint()) {
 914                         $fRange = $this->oContext->nearRadius();
 915                     }
 916
 917                     $sOrderBySQL = '';
 918                     if ($this->oContext->hasNearPoint()) {
 919                         $sOrderBySQL = $this->oContext->distanceSQL('l.geometry');
 920                     } else {
 921                         $sOrderBySQL = 'ST_Distance(l.geometry, f.geometry)';
 922                     }
 923
 924                     $sSQL = 'SELECT distinct l.place_id';
 925                     if ($sOrderBySQL) {
 926                         $sSQL .= ','.$sOrderBySQL.' as orderterm';
 927                     }
 928                     $sSQL .= ' FROM placex as l, placex as f';
 929                     $sSQL .= " WHERE f.place_id in ($sPlaceIDs)";
 930                     $sSQL .= "  AND ST_DWithin(l.geometry, f.centroid, $fRange)";
 931                     $sSQL .= "  AND l.class='".$this->sClass."'";
 932                     $sSQL .= "  AND l.type='".$this->sType."'";
 933                     $sSQL .= $this->oContext->excludeSQL(' AND l.place_id');
 934                     if ($sOrderBySQL) {
 935                         $sSQL .= 'ORDER BY orderterm ASC';
 936                     }
 937                     $sSQL .= " limit $iLimit";
 938
 939                     Debug::printSQL($sSQL);
 940
 941                     foreach ($oDB->getCol($sSQL) as $iPlaceId) {
 942                         $aResults[$iPlaceId] = new Result($iPlaceId);
 943                     }
 944                 }
 945             }
 946         }
 947
 948         return $aResults;
 949     }
 950
 951     private function poiTable()
 952     {
 953         return 'place_classtype_'.$this->sClass.'_'.$this->sType;
 954     }
 955
 956     private function countryCodeSQL($sVar)
 957     {
 958         if ($this->sCountryCode) {
 959             return $sVar.' = \''.$this->sCountryCode."'";
 960         }
 961         if ($this->oContext->sqlCountryList) {
 962             return $sVar.' in '.$this->oContext->sqlCountryList;
 963         }
 964
 965         return '';
 966     }
 967
 968     /////////// Sort functions
 969
 970
 971     public static function bySearchRank($a, $b)
 972     {
 973         if ($a->iSearchRank == $b->iSearchRank) {
 974             return $a->iOperator + strlen($a->sHouseNumber)
 975                      - $b->iOperator - strlen($b->sHouseNumber);
 976         }
 977
 978         return $a->iSearchRank < $b->iSearchRank ? -1 : 1;
 979     }
 980
 981     //////////// Debugging functions
 982
 983
 984     public function debugInfo()
 985     {
 986         return array(
 987                 'Search rank' => $this->iSearchRank,
 988                 'Country code' => $this->sCountryCode,
 989                 'Name terms' => $this->aName,
 990                 'Name terms (stop words)' => $this->aNameNonSearch,
 991                 'Address terms' => $this->aAddress,
 992                 'Address terms (stop words)' => $this->aAddressNonSearch,
 993                 'Address terms (full words)' => $this->aFullNameAddress ?? '',
 994                 'Special search' => $this->iOperator,
 995                 'Class' => $this->sClass,
 996                 'Type' => $this->sType,
 997                 'House number' => $this->sHouseNumber,
 998                 'Postcode' => $this->sPostcode
 999                );
1000     }
1001
1002     public function dumpAsHtmlTableRow(&$aWordIDs)
1003     {
1004         $kf = function ($k) use (&$aWordIDs) {
1005             return $aWordIDs[$k] ?? '['.$k.']';
1006         };
1007
1008         echo '<tr>';
1009         echo "<td>$this->iSearchRank</td>";
1010         echo '<td>'.join(', ', array_map($kf, $this->aName)).'</td>';
1011         echo '<td>'.join(', ', array_map($kf, $this->aNameNonSearch)).'</td>';
1012         echo '<td>'.join(', ', array_map($kf, $this->aAddress)).'</td>';
1013         echo '<td>'.join(', ', array_map($kf, $this->aAddressNonSearch)).'</td>';
1014         echo '<td>'.$this->sCountryCode.'</td>';
1015         echo '<td>'.Operator::toString($this->iOperator).'</td>';
1016         echo '<td>'.$this->sClass.'</td>';
1017         echo '<td>'.$this->sType.'</td>';
1018         echo '<td>'.$this->sPostcode.'</td>';
1019         echo '<td>'.$this->sHouseNumber.'</td>';
1020
1021         echo '</tr>';
1022     }
1023 }