lib/classes/SetupClass.php

   1 <?php
   2
   3 namespace Nominatim\Setup;
   4
   5 class SetupFunctions
   6 {
   7     protected $iCacheMemory;            // set in constructor
   8     protected $iInstances;              // set in constructor
   9     protected $sModulePath;             // set in constructor
  10     protected $aDSNInfo;                // set in constructor = DB::parseDSN(CONST_Database_DSN);
  11     protected $sVerbose;                // set in constructor
  12     protected $sIgnoreErrors;           // set in constructor
  13     protected $bEnableDiffUpdates;      // set in constructor
  14     protected $bEnableDebugStatements;  // set in constructor
  15     protected $bNoPartitions;           // set in constructor
  16     protected $oDB = null;              // set in setupDB (earliest) or later in loadData, importData, drop, createSqlFunctions, importTigerData
  17                                                 // pgsqlRunPartitionScript, calculatePostcodes, ..if no already set
  18
  19     public function __construct($aCMDResult)
  20     {
  21         // by default, use all but one processor, but never more than 15.
  22         $this->iInstances = isset($aCMDResult['threads'])
  23             ? $aCMDResult['threads']
  24             : (min(16, getProcessorCount()) - 1);
  25
  26
  27         if ($this->iInstances < 1) {
  28             $this->iInstances = 1;
  29             warn('resetting threads to '.$this->iInstances);
  30         }
  31
  32         // Assume we can steal all the cache memory in the box (unless told otherwise)
  33         if (isset($aCMDResult['osm2pgsql-cache'])) {
  34             $this->iCacheMemory = $aCMDResult['osm2pgsql-cache'];
  35         } else {
  36             $this->iCacheMemory = getCacheMemoryMB();
  37         }
  38
  39         $this->sModulePath = CONST_Database_Module_Path;
  40         info('module path: ' . $this->sModulePath);
  41
  42         // prepares DB for import or update, sets the Data Source Name
  43         $this->aDSNInfo = \DB::parseDSN(CONST_Database_DSN);
  44         if (!isset($this->aDSNInfo['port']) || !$this->aDSNInfo['port']) $this->aDSNInfo['port'] = 5432;
  45
  46         // setting member variables based on command line options stored in $aCMDResult
  47         $this->sVerbose = $aCMDResult['verbose'];
  48         $this->bEnableDiffUpdates = $aCMDResult['enable-diff-updates'];
  49
  50         //setting default values which are not set by the update.php array
  51         if (isset($aCMDResult['ignore-errors'])) {
  52             $this->sIgnoreErrors = $aCMDResult['ignore-errors'];
  53         } else {
  54             $this->sIgnoreErrors = false;
  55         }
  56         if (isset($aCMDResult['enable-debug-statements'])) {
  57             $this->bEnableDebugStatements = $aCMDResult['enable-debug-statements'];
  58         } else {
  59             $this->bEnableDebugStatements = false;
  60         }
  61         if (isset($aCMDResult['no-partitions'])) {
  62             $this->bNoPartitions = $aCMDResult['no-partitions'];
  63         } else {
  64             $this->bNoPartitions = false;
  65         }
  66     }
  67
  68     public function createDB()
  69     {
  70         info('Create DB');
  71         $sDB = \DB::connect(CONST_Database_DSN, false);
  72         if (!\PEAR::isError($sDB)) {
  73             fail('database already exists ('.CONST_Database_DSN.')');
  74         }
  75
  76         $sCreateDBCmd = 'createdb -E UTF-8 -p '.$this->aDSNInfo['port'].' '.$this->aDSNInfo['database'];
  77         if (isset($this->aDSNInfo['username']) && $this->aDSNInfo['username']) {
  78             $sCreateDBCmd .= ' -U '.$this->aDSNInfo['username'];
  79         }
  80
  81         if (isset($this->aDSNInfo['hostspec']) && $this->aDSNInfo['hostspec']) {
  82             $sCreateDBCmd .= ' -h '.$this->aDSNInfo['hostspec'];
  83         }
  84
  85         $aProcEnv = null;
  86         if (isset($this->aDSNInfo['password']) && $this->aDSNInfo['password']) {
  87             $aProcEnv = array_merge(array('PGPASSWORD' => $this->aDSNInfo['password']), $_ENV);
  88         }
  89
  90         $result = runWithEnv($sCreateDBCmd, $aProcEnv);
  91         if ($result != 0) fail('Error executing external command: '.$sCreateDBCmd);
  92     }
  93
  94     public function setupDB()
  95     {
  96         info('Setup DB');
  97         $this->oDB =& getDB();
  98
  99         $fPostgresVersion = getPostgresVersion($this->oDB);
 100         echo 'Postgres version found: '.$fPostgresVersion."\n";
 101
 102         if ($fPostgresVersion < 9.1) {
 103             fail('Minimum supported version of Postgresql is 9.1.');
 104         }
 105
 106         $this->pgsqlRunScript('CREATE EXTENSION IF NOT EXISTS hstore');
 107         $this->pgsqlRunScript('CREATE EXTENSION IF NOT EXISTS postgis');
 108
 109         // For extratags and namedetails the hstore_to_json converter is
 110         // needed which is only available from Postgresql 9.3+. For older
 111         // versions add a dummy function that returns nothing.
 112         $iNumFunc = chksql($this->oDB->getOne("select count(*) from pg_proc where proname = 'hstore_to_json'"));
 113
 114         if ($iNumFunc == 0) {
 115             $this->pgsqlRunScript("create function hstore_to_json(dummy hstore) returns text AS 'select null::text' language sql immutable");
 116             warn('Postgresql is too old. extratags and namedetails API not available.');
 117         }
 118
 119
 120         $fPostgisVersion = getPostgisVersion($this->oDB);
 121         echo 'Postgis version found: '.$fPostgisVersion."\n";
 122
 123         if ($fPostgisVersion < 2.1) {
 124             // Functions were renamed in 2.1 and throw an annoying deprecation warning
 125             $this->pgsqlRunScript('ALTER FUNCTION st_line_interpolate_point(geometry, double precision) RENAME TO ST_LineInterpolatePoint');
 126             $this->pgsqlRunScript('ALTER FUNCTION ST_Line_Locate_Point(geometry, geometry) RENAME TO ST_LineLocatePoint');
 127         }
 128         if ($fPostgisVersion < 2.2) {
 129             $this->pgsqlRunScript('ALTER FUNCTION ST_Distance_Spheroid(geometry, geometry, spheroid) RENAME TO ST_DistanceSpheroid');
 130         }
 131
 132         $i = chksql($this->oDB->getOne("select count(*) from pg_user where usename = '".CONST_Database_Web_User."'"));
 133         if ($i == 0) {
 134             echo "\nERROR: Web user '".CONST_Database_Web_User."' does not exist. Create it with:\n";
 135             echo "\n          createuser ".CONST_Database_Web_User."\n\n";
 136             exit(1);
 137         }
 138
 139         // Try accessing the C module, so we know early if something is wrong
 140         if (!checkModulePresence()) {
 141             fail('error loading nominatim.so module');
 142         }
 143
 144         if (!file_exists(CONST_ExtraDataPath.'/country_osm_grid.sql.gz')) {
 145             echo 'Error: you need to download the country_osm_grid first:';
 146             echo "\n    wget -O ".CONST_ExtraDataPath."/country_osm_grid.sql.gz https://www.nominatim.org/data/country_grid.sql.gz\n";
 147             exit(1);
 148         }
 149         $this->pgsqlRunScriptFile(CONST_BasePath.'/data/country_name.sql');
 150         $this->pgsqlRunScriptFile(CONST_BasePath.'/data/country_naturalearthdata.sql');
 151         $this->pgsqlRunScriptFile(CONST_BasePath.'/data/country_osm_grid.sql.gz');
 152         $this->pgsqlRunScriptFile(CONST_BasePath.'/data/gb_postcode_table.sql');
 153
 154
 155         if (file_exists(CONST_BasePath.'/data/gb_postcode_data.sql.gz')) {
 156             $this->pgsqlRunScriptFile(CONST_BasePath.'/data/gb_postcode_data.sql.gz');
 157         } else {
 158             warn('external UK postcode table not found.');
 159         }
 160
 161         if (CONST_Use_Extra_US_Postcodes) {
 162             $this->pgsqlRunScriptFile(CONST_BasePath.'/data/us_postcode.sql');
 163         }
 164
 165         if ($this->bNoPartitions) {
 166             $this->pgsqlRunScript('update country_name set partition = 0');
 167         }
 168
 169         // the following will be needed by create_functions later but
 170         // is only defined in the subsequently called T
 171         // Create dummies here that will be overwritten by the proper
 172         // versions in create-tables.
 173         $this->pgsqlRunScript('CREATE TABLE IF NOT EXISTS place_boundingbox ()');
 174         $this->pgsqlRunScript('CREATE TYPE wikipedia_article_match AS ()', false);
 175     }
 176
 177     public function importData($sOSMFile)
 178     {
 179         info('Import data');
 180
 181         $osm2pgsql = CONST_Osm2pgsql_Binary;
 182         if (!file_exists($osm2pgsql)) {
 183             echo "Check CONST_Osm2pgsql_Binary in your local settings file.\n";
 184             echo "Normally you should not need to set this manually.\n";
 185             fail("osm2pgsql not found in '$osm2pgsql'");
 186         }
 187
 188
 189
 190         if (!is_null(CONST_Osm2pgsql_Flatnode_File) && CONST_Osm2pgsql_Flatnode_File) {
 191             $osm2pgsql .= ' --flat-nodes '.CONST_Osm2pgsql_Flatnode_File;
 192         }
 193
 194         if (CONST_Tablespace_Osm2pgsql_Data)
 195             $osm2pgsql .= ' --tablespace-slim-data '.CONST_Tablespace_Osm2pgsql_Data;
 196         if (CONST_Tablespace_Osm2pgsql_Index)
 197             $osm2pgsql .= ' --tablespace-slim-index '.CONST_Tablespace_Osm2pgsql_Index;
 198         if (CONST_Tablespace_Place_Data)
 199             $osm2pgsql .= ' --tablespace-main-data '.CONST_Tablespace_Place_Data;
 200         if (CONST_Tablespace_Place_Index)
 201             $osm2pgsql .= ' --tablespace-main-index '.CONST_Tablespace_Place_Index;
 202         $osm2pgsql .= ' -lsc -O gazetteer --hstore --number-processes 1';
 203         $osm2pgsql .= ' -C '.$this->iCacheMemory;
 204         $osm2pgsql .= ' -P '.$this->aDSNInfo['port'];
 205         if (isset($this->aDSNInfo['username']) && $this->aDSNInfo['username']) {
 206             $osm2pgsql .= ' -U '.$this->aDSNInfo['username'];
 207         }
 208         if (isset($this->aDSNInfo['hostspec']) && $this->aDSNInfo['hostspec']) {
 209             $osm2pgsql .= ' -H '.$this->aDSNInfo['hostspec'];
 210         }
 211         $aProcEnv = null;
 212         if (isset($this->aDSNInfo['password']) && $this->aDSNInfo['password']) {
 213             $aProcEnv = array_merge(array('PGPASSWORD' => $this->aDSNInfo['password']), $_ENV);
 214         }
 215         $osm2pgsql .= ' -d '.$this->aDSNInfo['database'].' '.$sOSMFile;
 216         runWithEnv($osm2pgsql, $aProcEnv);
 217         if ($this->oDB == null) $this->oDB =& getDB();
 218         if (!$this->sIgnoreErrors && !chksql($this->oDB->getRow('select * from place limit 1'))) {
 219             fail('No Data');
 220         }
 221     }
 222
 223     public function createFunctions()
 224     {
 225         info('Create Functions');
 226
 227         // Try accessing the C module, so we know eif something is wrong
 228         // update.php calls this function
 229         if (!checkModulePresence()) {
 230             fail('error loading nominatim.so module');
 231         }
 232         $this->createSqlFunctions();
 233     }
 234
 235     public function createTables()
 236     {
 237         info('Create Tables');
 238
 239         $sTemplate = file_get_contents(CONST_BasePath.'/sql/tables.sql');
 240         $sTemplate = str_replace('{www-user}', CONST_Database_Web_User, $sTemplate);
 241         $sTemplate = $this->replaceTablespace(
 242             '{ts:address-data}',
 243             CONST_Tablespace_Address_Data,
 244             $sTemplate
 245         );
 246         $sTemplate = $this->replaceTablespace(
 247             '{ts:address-index}',
 248             CONST_Tablespace_Address_Index,
 249             $sTemplate
 250         );
 251         $sTemplate = $this->replaceTablespace(
 252             '{ts:search-data}',
 253             CONST_Tablespace_Search_Data,
 254             $sTemplate
 255         );
 256         $sTemplate = $this->replaceTablespace(
 257             '{ts:search-index}',
 258             CONST_Tablespace_Search_Index,
 259             $sTemplate
 260         );
 261         $sTemplate = $this->replaceTablespace(
 262             '{ts:aux-data}',
 263             CONST_Tablespace_Aux_Data,
 264             $sTemplate
 265         );
 266         $sTemplate = $this->replaceTablespace(
 267             '{ts:aux-index}',
 268             CONST_Tablespace_Aux_Index,
 269             $sTemplate
 270         );
 271
 272         $this->pgsqlRunScript($sTemplate, false);
 273     }
 274
 275     public function createPartitionTables()
 276     {
 277         info('Create Partition Tables');
 278
 279         $sTemplate = file_get_contents(CONST_BasePath.'/sql/partition-tables.src.sql');
 280         $sTemplate = $this->replaceTablespace(
 281             '{ts:address-data}',
 282             CONST_Tablespace_Address_Data,
 283             $sTemplate
 284         );
 285
 286         $sTemplate = $this->replaceTablespace(
 287             '{ts:address-index}',
 288             CONST_Tablespace_Address_Index,
 289             $sTemplate
 290         );
 291
 292         $sTemplate = $this->replaceTablespace(
 293             '{ts:search-data}',
 294             CONST_Tablespace_Search_Data,
 295             $sTemplate
 296         );
 297
 298         $sTemplate = $this->replaceTablespace(
 299             '{ts:search-index}',
 300             CONST_Tablespace_Search_Index,
 301             $sTemplate
 302         );
 303
 304         $sTemplate = $this->replaceTablespace(
 305             '{ts:aux-data}',
 306             CONST_Tablespace_Aux_Data,
 307             $sTemplate
 308         );
 309
 310         $sTemplate = $this->replaceTablespace(
 311             '{ts:aux-index}',
 312             CONST_Tablespace_Aux_Index,
 313             $sTemplate
 314         );
 315
 316         $this->pgsqlRunPartitionScript($sTemplate);
 317     }
 318
 319     public function createPartitionFunctions()
 320     {
 321         info('Create Partition Functions');
 322
 323         $sTemplate = file_get_contents(CONST_BasePath.'/sql/partition-functions.src.sql');
 324         $this->pgsqlRunPartitionScript($sTemplate);
 325     }
 326
 327     public function importWikipediaArticles()
 328     {
 329         $sWikiArticlesFile = CONST_Wikipedia_Data_Path.'/wikipedia_article.sql.bin';
 330         $sWikiRedirectsFile = CONST_Wikipedia_Data_Path.'/wikipedia_redirect.sql.bin';
 331         if (file_exists($sWikiArticlesFile)) {
 332             info('Importing wikipedia articles');
 333             $this->pgsqlRunDropAndRestore($sWikiArticlesFile);
 334         } else {
 335             warn('wikipedia article dump file not found - places will have default importance');
 336         }
 337         if (file_exists($sWikiRedirectsFile)) {
 338             info('Importing wikipedia redirects');
 339             $this->pgsqlRunDropAndRestore($sWikiRedirectsFile);
 340         } else {
 341             warn('wikipedia redirect dump file not found - some place importance values may be missing');
 342         }
 343     }
 344
 345     public function loadData($bDisableTokenPrecalc)
 346     {
 347         info('Drop old Data');
 348
 349         if ($this->oDB == null) $this->oDB =& getDB();
 350
 351         if (!pg_query($this->oDB->connection, 'TRUNCATE word')) fail(pg_last_error($this->oDB->connection));
 352         echo '.';
 353         if (!pg_query($this->oDB->connection, 'TRUNCATE placex')) fail(pg_last_error($this->oDB->connection));
 354         echo '.';
 355         if (!pg_query($this->oDB->connection, 'TRUNCATE location_property_osmline')) fail(pg_last_error($this->oDB->connection));
 356         echo '.';
 357         if (!pg_query($this->oDB->connection, 'TRUNCATE place_addressline')) fail(pg_last_error($this->oDB->connection));
 358         echo '.';
 359         if (!pg_query($this->oDB->connection, 'TRUNCATE place_boundingbox')) fail(pg_last_error($this->oDB->connection));
 360         echo '.';
 361         if (!pg_query($this->oDB->connection, 'TRUNCATE location_area')) fail(pg_last_error($this->oDB->connection));
 362         echo '.';
 363         if (!pg_query($this->oDB->connection, 'TRUNCATE search_name')) fail(pg_last_error($this->oDB->connection));
 364         echo '.';
 365         if (!pg_query($this->oDB->connection, 'TRUNCATE search_name_blank')) fail(pg_last_error($this->oDB->connection));
 366         echo '.';
 367         if (!pg_query($this->oDB->connection, 'DROP SEQUENCE seq_place')) fail(pg_last_error($this->oDB->connection));
 368         echo '.';
 369         if (!pg_query($this->oDB->connection, 'CREATE SEQUENCE seq_place start 100000')) fail(pg_last_error($this->oDB->connection));
 370         echo '.';
 371
 372         $sSQL = 'select distinct partition from country_name';
 373         $aPartitions = chksql($this->oDB->getCol($sSQL));
 374         if (!$this->bNoPartitions) $aPartitions[] = 0;
 375         foreach ($aPartitions as $sPartition) {
 376             if (!pg_query($this->oDB->connection, 'TRUNCATE location_road_'.$sPartition)) fail(pg_last_error($this->oDB->connection));
 377             echo '.';
 378         }
 379
 380         // used by getorcreate_word_id to ignore frequent partial words
 381         $sSQL = 'CREATE OR REPLACE FUNCTION get_maxwordfreq() RETURNS integer AS ';
 382         $sSQL .= '$$ SELECT '.CONST_Max_Word_Frequency.' as maxwordfreq; $$ LANGUAGE SQL IMMUTABLE';
 383         if (!pg_query($this->oDB->connection, $sSQL)) {
 384             fail(pg_last_error($this->oDB->connection));
 385         }
 386         echo ".\n";
 387
 388         // pre-create the word list
 389         if (!$bDisableTokenPrecalc) {
 390             info('Loading word list');
 391             $this->pgsqlRunScriptFile(CONST_BasePath.'/data/words.sql');
 392         }
 393
 394         info('Load Data');
 395         $sColumns = 'osm_type, osm_id, class, type, name, admin_level, address, extratags, geometry';
 396         $aDBInstances = array();
 397         $iLoadThreads = max(1, $this->iInstances - 1);
 398         for ($i = 0; $i < $iLoadThreads; $i++) {
 399             $aDBInstances[$i] =& getDB(true);
 400             $sSQL = "INSERT INTO placex ($sColumns) SELECT $sColumns FROM place WHERE osm_id % $iLoadThreads = $i";
 401             $sSQL .= " and not (class='place' and type='houses' and osm_type='W'";
 402             $sSQL .= "          and ST_GeometryType(geometry) = 'ST_LineString')";
 403             $sSQL .= ' and ST_IsValid(geometry)';
 404             if ($this->sVerbose) echo "$sSQL\n";
 405             if (!pg_send_query($aDBInstances[$i]->connection, $sSQL)) {
 406                 fail(pg_last_error($aDBInstances[$i]->connection));
 407             }
 408         }
 409
 410         // last thread for interpolation lines
 411         $aDBInstances[$iLoadThreads] =& getDB(true);
 412         $sSQL = 'insert into location_property_osmline';
 413         $sSQL .= ' (osm_id, address, linegeo)';
 414         $sSQL .= ' SELECT osm_id, address, geometry from place where ';
 415         $sSQL .= "class='place' and type='houses' and osm_type='W' and ST_GeometryType(geometry) = 'ST_LineString'";
 416         if ($this->sVerbose) echo "$sSQL\n";
 417         if (!pg_send_query($aDBInstances[$iLoadThreads]->connection, $sSQL)) {
 418             fail(pg_last_error($aDBInstances[$iLoadThreads]->connection));
 419         }
 420
 421         $bFailed = false;
 422         for ($i = 0; $i <= $iLoadThreads; $i++) {
 423             while (($hPGresult = pg_get_result($aDBInstances[$i]->connection)) !== false) {
 424                 $resultStatus = pg_result_status($hPGresult);
 425                 // PGSQL_EMPTY_QUERY, PGSQL_COMMAND_OK, PGSQL_TUPLES_OK,
 426                 // PGSQL_COPY_OUT, PGSQL_COPY_IN, PGSQL_BAD_RESPONSE,
 427                 // PGSQL_NONFATAL_ERROR and PGSQL_FATAL_ERROR
 428                 // echo 'Query result ' . $i . ' is: ' . $resultStatus . "\n";
 429                 if ($resultStatus != PGSQL_COMMAND_OK && $resultStatus != PGSQL_TUPLES_OK) {
 430                     $resultError = pg_result_error($hPGresult);
 431                     echo '-- error text ' . $i . ': ' . $resultError . "\n";
 432                     $bFailed = true;
 433                 }
 434             }
 435         }
 436         if ($bFailed) {
 437             fail('SQL errors loading placex and/or location_property_osmline tables');
 438         }
 439         echo "\n";
 440         info('Reanalysing database');
 441         $this->pgsqlRunScript('ANALYSE');
 442
 443         $sDatabaseDate = getDatabaseDate($this->oDB);
 444         pg_query($this->oDB->connection, 'TRUNCATE import_status');
 445         if ($sDatabaseDate === false) {
 446             warn('could not determine database date.');
 447         } else {
 448             $sSQL = "INSERT INTO import_status (lastimportdate) VALUES('".$sDatabaseDate."')";
 449             pg_query($this->oDB->connection, $sSQL);
 450             echo "Latest data imported from $sDatabaseDate.\n";
 451         }
 452     }
 453
 454     public function importTigerData()
 455     {
 456         info('Import Tiger data');
 457
 458         $sTemplate = file_get_contents(CONST_BasePath.'/sql/tiger_import_start.sql');
 459         $sTemplate = str_replace('{www-user}', CONST_Database_Web_User, $sTemplate);
 460         $sTemplate = $this->replaceTablespace(
 461             '{ts:aux-data}',
 462             CONST_Tablespace_Aux_Data,
 463             $sTemplate
 464         );
 465         $sTemplate = $this->replaceTablespace(
 466             '{ts:aux-index}',
 467             CONST_Tablespace_Aux_Index,
 468             $sTemplate
 469         );
 470         $this->pgsqlRunScript($sTemplate, false);
 471
 472         $aDBInstances = array();
 473         for ($i = 0; $i < $this->iInstances; $i++) {
 474             $aDBInstances[$i] =& getDB(true);
 475         }
 476
 477         foreach (glob(CONST_Tiger_Data_Path.'/*.sql') as $sFile) {
 478             echo $sFile.': ';
 479             $hFile = fopen($sFile, 'r');
 480             $sSQL = fgets($hFile, 100000);
 481             $iLines = 0;
 482             while (true) {
 483                 for ($i = 0; $i < $this->iInstances; $i++) {
 484                     if (!pg_connection_busy($aDBInstances[$i]->connection)) {
 485                         while (pg_get_result($aDBInstances[$i]->connection));
 486                         $sSQL = fgets($hFile, 100000);
 487                         if (!$sSQL) break 2;
 488                         if (!pg_send_query($aDBInstances[$i]->connection, $sSQL)) fail(pg_last_error($this->oDB->connection));
 489                         $iLines++;
 490                         if ($iLines == 1000) {
 491                             echo '.';
 492                             $iLines = 0;
 493                         }
 494                     }
 495                 }
 496                 usleep(10);
 497             }
 498             fclose($hFile);
 499
 500             $bAnyBusy = true;
 501             while ($bAnyBusy) {
 502                 $bAnyBusy = false;
 503                 for ($i = 0; $i < $this->iInstances; $i++) {
 504                     if (pg_connection_busy($aDBInstances[$i]->connection)) $bAnyBusy = true;
 505                 }
 506                 usleep(10);
 507             }
 508             echo "\n";
 509         }
 510
 511         info('Creating indexes on Tiger data');
 512         $sTemplate = file_get_contents(CONST_BasePath.'/sql/tiger_import_finish.sql');
 513         $sTemplate = str_replace('{www-user}', CONST_Database_Web_User, $sTemplate);
 514         $sTemplate = $this->replaceTablespace(
 515             '{ts:aux-data}',
 516             CONST_Tablespace_Aux_Data,
 517             $sTemplate
 518         );
 519         $sTemplate = $this->replaceTablespace(
 520             '{ts:aux-index}',
 521             CONST_Tablespace_Aux_Index,
 522             $sTemplate
 523         );
 524         $this->pgsqlRunScript($sTemplate, false);
 525     }
 526
 527     public function calculatePostcodes($bCMDResultAll)
 528     {
 529         info('Calculate Postcodes');
 530         if ($this->oDB == null) $this->oDB =& getDB();
 531         if (!pg_query($this->oDB->connection, 'TRUNCATE location_postcode')) {
 532             fail(pg_last_error($this->oDB->connection));
 533         }
 534
 535
 536         $sSQL  = 'INSERT INTO location_postcode';
 537         $sSQL .= ' (place_id, indexed_status, country_code, postcode, geometry) ';
 538         $sSQL .= "SELECT nextval('seq_place'), 1, country_code,";
 539         $sSQL .= "       upper(trim (both ' ' from address->'postcode')) as pc,";
 540         $sSQL .= '       ST_Centroid(ST_Collect(ST_Centroid(geometry)))';
 541         $sSQL .= '  FROM placex';
 542         $sSQL .= " WHERE address ? 'postcode' AND address->'postcode' NOT SIMILAR TO '%(,|;)%'";
 543         $sSQL .= '       AND geometry IS NOT null';
 544         $sSQL .= ' GROUP BY country_code, pc';
 545
 546         if (!pg_query($this->oDB->connection, $sSQL)) {
 547             fail(pg_last_error($this->oDB->connection));
 548         }
 549
 550         if (CONST_Use_Extra_US_Postcodes) {
 551             // only add postcodes that are not yet available in OSM
 552             $sSQL  = 'INSERT INTO location_postcode';
 553             $sSQL .= ' (place_id, indexed_status, country_code, postcode, geometry) ';
 554             $sSQL .= "SELECT nextval('seq_place'), 1, 'us', postcode,";
 555             $sSQL .= '       ST_SetSRID(ST_Point(x,y),4326)';
 556             $sSQL .= '  FROM us_postcode WHERE postcode NOT IN';
 557             $sSQL .= '        (SELECT postcode FROM location_postcode';
 558             $sSQL .= "          WHERE country_code = 'us')";
 559             if (!pg_query($this->oDB->connection, $sSQL)) fail(pg_last_error($this->oDB->connection));
 560         }
 561
 562         // add missing postcodes for GB (if available)
 563         $sSQL  = 'INSERT INTO location_postcode';
 564         $sSQL .= ' (place_id, indexed_status, country_code, postcode, geometry) ';
 565         $sSQL .= "SELECT nextval('seq_place'), 1, 'gb', postcode, geometry";
 566         $sSQL .= '  FROM gb_postcode WHERE postcode NOT IN';
 567         $sSQL .= '           (SELECT postcode FROM location_postcode';
 568         $sSQL .= "             WHERE country_code = 'gb')";
 569         if (!pg_query($this->oDB->connection, $sSQL)) fail(pg_last_error($this->oDB->connection));
 570
 571         if (!$bCMDResultAll) {
 572             $sSQL = "DELETE FROM word WHERE class='place' and type='postcode'";
 573             $sSQL .= 'and word NOT IN (SELECT postcode FROM location_postcode)';
 574             if (!pg_query($this->oDB->connection, $sSQL)) {
 575                 fail(pg_last_error($this->oDB->connection));
 576             }
 577         }
 578         $sSQL = 'SELECT count(getorcreate_postcode_id(v)) FROM ';
 579         $sSQL .= '(SELECT distinct(postcode) as v FROM location_postcode) p';
 580
 581         if (!pg_query($this->oDB->connection, $sSQL)) {
 582             fail(pg_last_error($this->oDB->connection));
 583         }
 584     }
 585
 586     public function index($bIndexNoanalyse)
 587     {
 588         $sOutputFile = '';
 589         $sBaseCmd = CONST_InstallPath.'/nominatim/nominatim -i -d '.$this->aDSNInfo['database'].' -P '
 590             .$this->aDSNInfo['port'].' -t '.$this->iInstances.$sOutputFile;
 591         if (isset($this->aDSNInfo['hostspec']) && $this->aDSNInfo['hostspec']) {
 592             $sBaseCmd .= ' -H '.$this->aDSNInfo['hostspec'];
 593         }
 594         if (isset($this->aDSNInfo['username']) && $this->aDSNInfo['username']) {
 595             $sBaseCmd .= ' -U '.$this->aDSNInfo['username'];
 596         }
 597         $aProcEnv = null;
 598         if (isset($this->aDSNInfo['password']) && $this->aDSNInfo['password']) {
 599             $aProcEnv = array_merge(array('PGPASSWORD' => $this->aDSNInfo['password']), $_ENV);
 600         }
 601
 602         info('Index ranks 0 - 4');
 603         $iStatus = runWithEnv($sBaseCmd.' -R 4', $aProcEnv);
 604         if ($iStatus != 0) {
 605             fail('error status ' . $iStatus . ' running nominatim!');
 606         }
 607         if (!$bIndexNoanalyse) $this->pgsqlRunScript('ANALYSE');
 608         info('Index ranks 5 - 25');
 609         $iStatus = runWithEnv($sBaseCmd.' -r 5 -R 25', $aProcEnv);
 610         if ($iStatus != 0) {
 611             fail('error status ' . $iStatus . ' running nominatim!');
 612         }
 613         if (!$bIndexNoanalyse) $this->pgsqlRunScript('ANALYSE');
 614         info('Index ranks 26 - 30');
 615         $iStatus = runWithEnv($sBaseCmd.' -r 26', $aProcEnv);
 616         if ($iStatus != 0) {
 617             fail('error status ' . $iStatus . ' running nominatim!');
 618         }
 619         info('Index postcodes');
 620         if ($this->oDB == null) $this->oDB =& getDB();
 621         $sSQL = 'UPDATE location_postcode SET indexed_status = 0';
 622         if (!pg_query($this->oDB->connection, $sSQL)) fail(pg_last_error($this->oDB->connection));
 623     }
 624
 625     public function createSearchIndices()
 626     {
 627         info('Create Search indices');
 628
 629         $sTemplate = file_get_contents(CONST_BasePath.'/sql/indices.src.sql');
 630         $sTemplate = str_replace('{www-user}', CONST_Database_Web_User, $sTemplate);
 631         $sTemplate = $this->replaceTablespace(
 632             '{ts:address-index}',
 633             CONST_Tablespace_Address_Index,
 634             $sTemplate
 635         );
 636         $sTemplate = $this->replaceTablespace(
 637             '{ts:search-index}',
 638             CONST_Tablespace_Search_Index,
 639             $sTemplate
 640         );
 641         $sTemplate = $this->replaceTablespace(
 642             '{ts:aux-index}',
 643             CONST_Tablespace_Aux_Index,
 644             $sTemplate
 645         );
 646         $this->pgsqlRunScript($sTemplate);
 647     }
 648
 649     public function createCountryNames()
 650     {
 651         info('Create search index for default country names');
 652
 653         $this->pgsqlRunScript("select getorcreate_country(make_standard_name('uk'), 'gb')");
 654         $this->pgsqlRunScript("select getorcreate_country(make_standard_name('united states'), 'us')");
 655         $this->pgsqlRunScript('select count(*) from (select getorcreate_country(make_standard_name(country_code), country_code) from country_name where country_code is not null) as x');
 656         $this->pgsqlRunScript("select count(*) from (select getorcreate_country(make_standard_name(name->'name'), country_code) from country_name where name ? 'name') as x");
 657         $sSQL = 'select count(*) from (select getorcreate_country(make_standard_name(v),'
 658             .'country_code) from (select country_code, skeys(name) as k, svals(name) as v from country_name) x where k ';
 659         if (CONST_Languages) {
 660             $sSQL .= 'in ';
 661             $sDelim = '(';
 662             foreach (explode(',', CONST_Languages) as $sLang) {
 663                 $sSQL .= $sDelim."'name:$sLang'";
 664                 $sDelim = ',';
 665             }
 666             $sSQL .= ')';
 667         } else {
 668             // all include all simple name tags
 669             $sSQL .= "like 'name:%'";
 670         }
 671         $sSQL .= ') v';
 672         $this->pgsqlRunScript($sSQL);
 673     }
 674
 675     public function drop()
 676     {
 677         info('Drop tables only required for updates');
 678
 679         // The implementation is potentially a bit dangerous because it uses
 680         // a positive selection of tables to keep, and deletes everything else.
 681         // Including any tables that the unsuspecting user might have manually
 682         // created. USE AT YOUR OWN PERIL.
 683         // tables we want to keep. everything else goes.
 684         $aKeepTables = array(
 685                         '*columns',
 686                         'import_polygon_*',
 687                         'import_status',
 688                         'place_addressline',
 689                         'location_postcode',
 690                         'location_property*',
 691                         'placex',
 692                         'search_name',
 693                         'seq_*',
 694                         'word',
 695                         'query_log',
 696                         'new_query_log',
 697                         'spatial_ref_sys',
 698                         'country_name',
 699                         'place_classtype_*'
 700                        );
 701
 702         if ($this->oDB = null) $this->oDB =& getDB();
 703         $aDropTables = array();
 704         $aHaveTables = chksql($this->oDB->getCol("SELECT tablename FROM pg_tables WHERE schemaname='public'"));
 705
 706         foreach ($aHaveTables as $sTable) {
 707             $bFound = false;
 708             foreach ($aKeepTables as $sKeep) {
 709                 if (fnmatch($sKeep, $sTable)) {
 710                     $bFound = true;
 711                     break;
 712                 }
 713             }
 714             if (!$bFound) array_push($aDropTables, $sTable);
 715         }
 716         foreach ($aDropTables as $sDrop) {
 717             if ($this->sVerbose) echo "dropping table $sDrop\n";
 718             @pg_query($this->oDB->connection, "DROP TABLE $sDrop CASCADE");
 719             // ignore warnings/errors as they might be caused by a table having
 720             // been deleted already by CASCADE
 721         }
 722
 723         if (!is_null(CONST_Osm2pgsql_Flatnode_File) && CONST_Osm2pgsql_Flatnode_File) {
 724             if ($sVerbose) echo 'deleting '.CONST_Osm2pgsql_Flatnode_File."\n";
 725             unlink(CONST_Osm2pgsql_Flatnode_File);
 726         }
 727     }
 728
 729     private function pgsqlRunDropAndRestore($sDumpFile)
 730     {
 731         if (!isset($this->aDSNInfo['port']) || !$this->aDSNInfo['port']) $this->aDSNInfo['port'] = 5432;
 732         $sCMD = 'pg_restore -p '.$this->aDSNInfo['port'].' -d '.$this->aDSNInfo['database'].' -Fc --clean '.$sDumpFile;
 733         if (isset($this->aDSNInfo['hostspec']) && $this->aDSNInfo['hostspec']) {
 734             $sCMD .= ' -h '.$this->aDSNInfo['hostspec'];
 735         }
 736         if (isset($this->aDSNInfo['username']) && $this->aDSNInfo['username']) {
 737             $sCMD .= ' -U '.$this->aDSNInfo['username'];
 738         }
 739         $aProcEnv = null;
 740         if (isset($this->aDSNInfo['password']) && $this->aDSNInfo['password']) {
 741             $aProcEnv = array_merge(array('PGPASSWORD' => $this->aDSNInfo['password']), $_ENV);
 742         }
 743         $iReturn = runWithEnv($sCMD, $aProcEnv);    // /lib/cmd.php "function runWithEnv($sCmd, $aEnv)"
 744     }
 745
 746     private function pgsqlRunScript($sScript, $bfatal = true)
 747     {
 748         runSQLScript(
 749             $sScript,
 750             $bfatal,
 751             $this->sVerbose,
 752             $this->sIgnoreErrors
 753         );
 754     }
 755
 756     private function createSqlFunctions()
 757     {
 758         $sTemplate = file_get_contents(CONST_BasePath.'/sql/functions.sql');
 759         $sTemplate = str_replace('{modulepath}', $this->sModulePath, $sTemplate);
 760         if ($this->bEnableDiffUpdates) {
 761             $sTemplate = str_replace('RETURN NEW; -- %DIFFUPDATES%', '--', $sTemplate);
 762         }
 763         if ($this->bEnableDebugStatements) {
 764             $sTemplate = str_replace('--DEBUG:', '', $sTemplate);
 765         }
 766         if (CONST_Limit_Reindexing) {
 767             $sTemplate = str_replace('--LIMIT INDEXING:', '', $sTemplate);
 768         }
 769         if (!CONST_Use_US_Tiger_Data) {
 770             $sTemplate = str_replace('-- %NOTIGERDATA% ', '', $sTemplate);
 771         }
 772         if (!CONST_Use_Aux_Location_data) {
 773             $sTemplate = str_replace('-- %NOAUXDATA% ', '', $sTemplate);
 774         }
 775         $this->pgsqlRunScript($sTemplate);
 776     }
 777
 778     private function pgsqlRunPartitionScript($sTemplate)
 779     {
 780         if ($this->oDB == null) $this->oDB =& getDB();
 781
 782         $sSQL = 'select distinct partition from country_name';
 783         $aPartitions = chksql($this->oDB->getCol($sSQL));
 784         if (!$this->bNoPartitions) $aPartitions[] = 0;
 785
 786         preg_match_all('#^-- start(.*?)^-- end#ms', $sTemplate, $aMatches, PREG_SET_ORDER);
 787         foreach ($aMatches as $aMatch) {
 788             $sResult = '';
 789             foreach ($aPartitions as $sPartitionName) {
 790                 $sResult .= str_replace('-partition-', $sPartitionName, $aMatch[1]);
 791             }
 792             $sTemplate = str_replace($aMatch[0], $sResult, $sTemplate);
 793         }
 794
 795         $this->pgsqlRunScript($sTemplate);
 796     }
 797
 798     private function pgsqlRunScriptFile($sFilename)
 799     {
 800         if (!file_exists($sFilename)) fail('unable to find '.$sFilename);
 801
 802         $sCMD = 'psql -p '.$this->aDSNInfo['port'].' -d '.$this->aDSNInfo['database'];
 803         if (!$this->sVerbose) {
 804             $sCMD .= ' -q';
 805         }
 806         if (isset($this->aDSNInfo['hostspec']) && $this->aDSNInfo['hostspec']) {
 807             $sCMD .= ' -h '.$this->aDSNInfo['hostspec'];
 808         }
 809         if (isset($this->aDSNInfo['username']) && $this->aDSNInfo['username']) {
 810             $sCMD .= ' -U '.$this->aDSNInfo['username'];
 811         }
 812         $aProcEnv = null;
 813         if (isset($this->aDSNInfo['password']) && $this->aDSNInfo['password']) {
 814             $aProcEnv = array_merge(array('PGPASSWORD' => $this->aDSNInfo['password']), $_ENV);
 815         }
 816         $ahGzipPipes = null;
 817         if (preg_match('/\\.gz$/', $sFilename)) {
 818             $aDescriptors = array(
 819                              0 => array('pipe', 'r'),
 820                              1 => array('pipe', 'w'),
 821                              2 => array('file', '/dev/null', 'a')
 822                             );
 823             $hGzipProcess = proc_open('zcat '.$sFilename, $aDescriptors, $ahGzipPipes);
 824             if (!is_resource($hGzipProcess)) fail('unable to start zcat');
 825             $aReadPipe = $ahGzipPipes[1];
 826             fclose($ahGzipPipes[0]);
 827         } else {
 828             $sCMD .= ' -f '.$sFilename;
 829             $aReadPipe = array('pipe', 'r');
 830         }
 831         $aDescriptors = array(
 832                          0 => $aReadPipe,
 833                          1 => array('pipe', 'w'),
 834                          2 => array('file', '/dev/null', 'a')
 835                         );
 836         $ahPipes = null;
 837         $hProcess = proc_open($sCMD, $aDescriptors, $ahPipes, null, $aProcEnv);
 838         if (!is_resource($hProcess)) fail('unable to start pgsql');
 839         // TODO: error checking
 840         while (!feof($ahPipes[1])) {
 841             echo fread($ahPipes[1], 4096);
 842         }
 843         fclose($ahPipes[1]);
 844         $iReturn = proc_close($hProcess);
 845         if ($iReturn > 0) {
 846             fail("pgsql returned with error code ($iReturn)");
 847         }
 848         if ($ahGzipPipes) {
 849             fclose($ahGzipPipes[1]);
 850             proc_close($hGzipProcess);
 851         }
 852     }
 853
 854     private function replaceTablespace($sTemplate, $sTablespace, $sSql)
 855     {
 856         if ($sTablespace) {
 857             $sSql = str_replace($sTemplate, 'TABLESPACE "'.$sTablespace.'"', $sSql);
 858         } else {
 859             $sSql = str_replace($sTemplate, '', $sSql);
 860         }
 861         return $sSql;
 862     }
 863 }