utils/setup.php

   1 #!/usr/bin/php -Cq
   2 <?php
   3
   4 require_once(dirname(dirname(__FILE__)).'/settings/settings.php');
   5 require_once(CONST_BasePath.'/lib/init-cmd.php');
   6 ini_set('memory_limit', '800M');
   7
   8 $aCMDOptions
   9 = array(
  10    "Create and setup nominatim search system",
  11    array('help', 'h', 0, 1, 0, 0, false, 'Show Help'),
  12    array('quiet', 'q', 0, 1, 0, 0, 'bool', 'Quiet output'),
  13    array('verbose', 'v', 0, 1, 0, 0, 'bool', 'Verbose output'),
  14
  15    array('osm-file', '', 0, 1, 1, 1, 'realpath', 'File to import'),
  16    array('threads', '', 0, 1, 1, 1, 'int', 'Number of threads (where possible)'),
  17
  18    array('all', '', 0, 1, 0, 0, 'bool', 'Do the complete process'),
  19
  20    array('create-db', '', 0, 1, 0, 0, 'bool', 'Create nominatim db'),
  21    array('setup-db', '', 0, 1, 0, 0, 'bool', 'Build a blank nominatim db'),
  22    array('import-data', '', 0, 1, 0, 0, 'bool', 'Import a osm file'),
  23    array('osm2pgsql-cache', '', 0, 1, 1, 1, 'int', 'Cache size used by osm2pgsql'),
  24    array('create-functions', '', 0, 1, 0, 0, 'bool', 'Create functions'),
  25    array('enable-diff-updates', '', 0, 1, 0, 0, 'bool', 'Turn on the code required to make diff updates work'),
  26    array('enable-debug-statements', '', 0, 1, 0, 0, 'bool', 'Include debug warning statements in pgsql commands'),
  27    array('ignore-errors', '', 0, 1, 0, 0, 'bool', 'Continue import even when errors in SQL are present (EXPERT)'),
  28    array('create-tables', '', 0, 1, 0, 0, 'bool', 'Create main tables'),
  29    array('create-partition-tables', '', 0, 1, 0, 0, 'bool', 'Create required partition tables'),
  30    array('create-partition-functions', '', 0, 1, 0, 0, 'bool', 'Create required partition triggers'),
  31    array('no-partitions', '', 0, 1, 0, 0, 'bool', "Do not partition search indices (speeds up import of single country extracts)"),
  32    array('import-wikipedia-articles', '', 0, 1, 0, 0, 'bool', 'Import wikipedia article dump'),
  33    array('load-data', '', 0, 1, 0, 0, 'bool', 'Copy data to live tables from import table'),
  34    array('disable-token-precalc', '', 0, 1, 0, 0, 'bool', 'Disable name precalculation (EXPERT)'),
  35    array('import-tiger-data', '', 0, 1, 0, 0, 'bool', 'Import tiger data (not included in \'all\')'),
  36    array('calculate-postcodes', '', 0, 1, 0, 0, 'bool', 'Calculate postcode centroids'),
  37    array('osmosis-init', '', 0, 1, 0, 0, 'bool', 'Generate default osmosis configuration'),
  38    array('index', '', 0, 1, 0, 0, 'bool', 'Index the data'),
  39    array('index-noanalyse', '', 0, 1, 0, 0, 'bool', 'Do not perform analyse operations during index (EXPERT)'),
  40    array('create-search-indices', '', 0, 1, 0, 0, 'bool', 'Create additional indices required for search and update'),
  41    array('create-country-names', '', 0, 1, 0, 0, 'bool', 'Create default list of searchable country names'),
  42    array('drop', '', 0, 1, 0, 0, 'bool', 'Drop tables needed for updates, making the database readonly (EXPERIMENTAL)'),
  43   );
  44 getCmdOpt($_SERVER['argv'], $aCMDOptions, $aCMDResult, true, true);
  45
  46 $bDidSomething = false;
  47
  48 // Check if osm-file is set and points to a valid file if --all or --import-data is given
  49 if ($aCMDResult['import-data'] || $aCMDResult['all']) {
  50     if (!isset($aCMDResult['osm-file'])) {
  51         fail('missing --osm-file for data import');
  52     }
  53
  54     if (!file_exists($aCMDResult['osm-file'])) {
  55         fail('the path supplied to --osm-file does not exist');
  56     }
  57
  58     if (!is_readable($aCMDResult['osm-file'])) {
  59         fail('osm-file "'.$aCMDResult['osm-file'].'" not readable');
  60     }
  61 }
  62
  63
  64 // This is a pretty hard core default - the number of processors in the box - 1
  65 $iInstances = isset($aCMDResult['threads'])?$aCMDResult['threads']:(getProcessorCount()-1);
  66 if ($iInstances < 1) {
  67     $iInstances = 1;
  68     echo "WARNING: resetting threads to $iInstances\n";
  69 }
  70 if ($iInstances > getProcessorCount()) {
  71     $iInstances = getProcessorCount();
  72     echo "WARNING: resetting threads to $iInstances\n";
  73 }
  74
  75 // Assume we can steal all the cache memory in the box (unless told otherwise)
  76 if (isset($aCMDResult['osm2pgsql-cache'])) {
  77     $iCacheMemory = $aCMDResult['osm2pgsql-cache'];
  78 } else {
  79     $iCacheMemory = getCacheMemoryMB();
  80 }
  81
  82 $aDSNInfo = DB::parseDSN(CONST_Database_DSN);
  83 if (!isset($aDSNInfo['port']) || !$aDSNInfo['port']) $aDSNInfo['port'] = 5432;
  84
  85 if ($aCMDResult['create-db'] || $aCMDResult['all']) {
  86     echo "Create DB\n";
  87     $bDidSomething = true;
  88     $oDB = DB::connect(CONST_Database_DSN, false);
  89     if (!PEAR::isError($oDB)) {
  90         fail('database already exists ('.CONST_Database_DSN.')');
  91     }
  92     passthruCheckReturn('createdb -E UTF-8 -p '.$aDSNInfo['port'].' '.$aDSNInfo['database']);
  93 }
  94
  95 if ($aCMDResult['setup-db'] || $aCMDResult['all']) {
  96     echo "Setup DB\n";
  97     $bDidSomething = true;
  98
  99     // TODO: path detection, detection memory, etc.
 100     //
 101     $oDB =& getDB();
 102
 103     $fPostgresVersion = getPostgresVersion($oDB);
 104     echo 'Postgres version found: '.$fPostgresVersion."\n";
 105
 106     if ($fPostgresVersion < 9.1) {
 107         fail("Minimum supported version of Postgresql is 9.1.");
 108     }
 109
 110     pgsqlRunScript('CREATE EXTENSION IF NOT EXISTS hstore');
 111     pgsqlRunScript('CREATE EXTENSION IF NOT EXISTS postgis');
 112
 113     // For extratags and namedetails the hstore_to_json converter is
 114     // needed which is only available from Postgresql 9.3+. For older
 115     // versions add a dummy function that returns nothing.
 116     $iNumFunc = chksql($oDB->getOne("select count(*) from pg_proc where proname = 'hstore_to_json'"));
 117
 118     if ($iNumFunc == 0) {
 119         pgsqlRunScript("create function hstore_to_json(dummy hstore) returns text AS 'select null::text' language sql immutable");
 120         echo "WARNING: Postgresql is too old. extratags and namedetails API not available.";
 121     }
 122
 123     $fPostgisVersion = getPostgisVersion($oDB);
 124     echo 'Postgis version found: '.$fPostgisVersion."\n";
 125
 126     if ($fPostgisVersion < 2.1) {
 127         // Functions were renamed in 2.1 and throw an annoying deprecation warning
 128         pgsqlRunScript('ALTER FUNCTION st_line_interpolate_point(geometry, double precision) RENAME TO ST_LineInterpolatePoint');
 129         pgsqlRunScript('ALTER FUNCTION ST_Line_Locate_Point(geometry, geometry) RENAME TO ST_LineLocatePoint');
 130     }
 131     if ($fPostgisVersion < 2.2) {
 132         pgsqlRunScript('ALTER FUNCTION ST_Distance_Spheroid(geometry, geometry, spheroid) RENAME TO ST_DistanceSpheroid');
 133     }
 134
 135     pgsqlRunScriptFile(CONST_BasePath.'/data/country_name.sql');
 136     pgsqlRunScriptFile(CONST_BasePath.'/data/country_naturalearthdata.sql');
 137     pgsqlRunScriptFile(CONST_BasePath.'/data/country_osm_grid.sql');
 138     pgsqlRunScriptFile(CONST_BasePath.'/data/gb_postcode_table.sql');
 139     if (file_exists(CONST_BasePath.'/data/gb_postcode_data.sql.gz')) {
 140         pgsqlRunScriptFile(CONST_BasePath.'/data/gb_postcode_data.sql.gz');
 141     } else {
 142         echo "WARNING: external UK postcode table not found.\n";
 143     }
 144     if (CONST_Use_Extra_US_Postcodes) {
 145         pgsqlRunScriptFile(CONST_BasePath.'/data/us_postcode.sql');
 146     }
 147
 148     if ($aCMDResult['no-partitions']) {
 149         pgsqlRunScript('update country_name set partition = 0');
 150     }
 151
 152     // the following will be needed by create_functions later but
 153     // is only defined in the subsequently called create_tables.
 154     // Create dummies here that will be overwritten by the proper
 155     // versions in create-tables.
 156     pgsqlRunScript('CREATE TABLE place_boundingbox ()');
 157     pgsqlRunScript('create type wikipedia_article_match as ()');
 158 }
 159
 160 if ($aCMDResult['import-data'] || $aCMDResult['all']) {
 161     echo "Import\n";
 162     $bDidSomething = true;
 163
 164     $osm2pgsql = CONST_Osm2pgsql_Binary;
 165     if (!file_exists($osm2pgsql)) {
 166         echo "Check CONST_Osm2pgsql_Binary in your local settings file.\n";
 167         echo "Normally you should not need to set this manually.\n";
 168         fail("osm2pgsql not found in '$osm2pgsql'");
 169     }
 170
 171     if (!is_null(CONST_Osm2pgsql_Flatnode_File)) {
 172         $osm2pgsql .= ' --flat-nodes '.CONST_Osm2pgsql_Flatnode_File;
 173     }
 174     if (CONST_Tablespace_Osm2pgsql_Data)
 175         $osm2pgsql .= ' --tablespace-slim-data '.CONST_Tablespace_Osm2pgsql_Data;
 176     if (CONST_Tablespace_Osm2pgsql_Index)
 177         $osm2pgsql .= ' --tablespace-slim-index '.CONST_Tablespace_Osm2pgsql_Index;
 178     if (CONST_Tablespace_Place_Data)
 179         $osm2pgsql .= ' --tablespace-main-data '.CONST_Tablespace_Place_Data;
 180     if (CONST_Tablespace_Place_Index)
 181         $osm2pgsql .= ' --tablespace-main-index '.CONST_Tablespace_Place_Index;
 182     $osm2pgsql .= ' -lsc -O gazetteer --hstore --number-processes 1';
 183     $osm2pgsql .= ' -C '.$iCacheMemory;
 184     $osm2pgsql .= ' -P '.$aDSNInfo['port'];
 185     $osm2pgsql .= ' -d '.$aDSNInfo['database'].' '.$aCMDResult['osm-file'];
 186     passthruCheckReturn($osm2pgsql);
 187
 188     $oDB =& getDB();
 189     if (!$aCMDResult['ignore-errors'] && !chksql($oDB->getRow('select * from place limit 1'))) {
 190         fail('No Data');
 191     }
 192 }
 193
 194 if ($aCMDResult['create-functions'] || $aCMDResult['all']) {
 195     echo "Functions\n";
 196     $bDidSomething = true;
 197     if (!file_exists(CONST_InstallPath.'/module/nominatim.so')) fail("nominatim module not built");
 198     create_sql_functions($aCMDResult);
 199 }
 200
 201 if ($aCMDResult['create-tables'] || $aCMDResult['all']) {
 202     $bDidSomething = true;
 203
 204     echo "Tables\n";
 205     $sTemplate = file_get_contents(CONST_BasePath.'/sql/tables.sql');
 206     $sTemplate = str_replace('{www-user}', CONST_Database_Web_User, $sTemplate);
 207     $sTemplate = replace_tablespace(
 208         '{ts:address-data}',
 209         CONST_Tablespace_Address_Data,
 210         $sTemplate
 211     );
 212     $sTemplate = replace_tablespace(
 213         '{ts:address-index}',
 214         CONST_Tablespace_Address_Index,
 215         $sTemplate
 216     );
 217     $sTemplate = replace_tablespace(
 218         '{ts:search-data}',
 219         CONST_Tablespace_Search_Data,
 220         $sTemplate
 221     );
 222     $sTemplate = replace_tablespace(
 223         '{ts:search-index}',
 224         CONST_Tablespace_Search_Index,
 225         $sTemplate
 226     );
 227     $sTemplate = replace_tablespace(
 228         '{ts:aux-data}',
 229         CONST_Tablespace_Aux_Data,
 230         $sTemplate
 231     );
 232     $sTemplate = replace_tablespace(
 233         '{ts:aux-index}',
 234         CONST_Tablespace_Aux_Index,
 235         $sTemplate
 236     );
 237     pgsqlRunScript($sTemplate, false);
 238
 239     // re-run the functions
 240     echo "Functions\n";
 241     create_sql_functions($aCMDResult);
 242 }
 243
 244 if ($aCMDResult['create-partition-tables'] || $aCMDResult['all']) {
 245     echo "Partition Tables\n";
 246     $bDidSomething = true;
 247
 248     $sTemplate = file_get_contents(CONST_BasePath.'/sql/partition-tables.src.sql');
 249     $sTemplate = replace_tablespace(
 250         '{ts:address-data}',
 251         CONST_Tablespace_Address_Data,
 252         $sTemplate
 253     );
 254     $sTemplate = replace_tablespace(
 255         '{ts:address-index}',
 256         CONST_Tablespace_Address_Index,
 257         $sTemplate
 258     );
 259     $sTemplate = replace_tablespace(
 260         '{ts:search-data}',
 261         CONST_Tablespace_Search_Data,
 262         $sTemplate
 263     );
 264     $sTemplate = replace_tablespace(
 265         '{ts:search-index}',
 266         CONST_Tablespace_Search_Index,
 267         $sTemplate
 268     );
 269     $sTemplate = replace_tablespace(
 270         '{ts:aux-data}',
 271         CONST_Tablespace_Aux_Data,
 272         $sTemplate
 273     );
 274     $sTemplate = replace_tablespace(
 275         '{ts:aux-index}',
 276         CONST_Tablespace_Aux_Index,
 277         $sTemplate
 278     );
 279
 280     pgsqlRunPartitionScript($sTemplate);
 281 }
 282
 283
 284 if ($aCMDResult['create-partition-functions'] || $aCMDResult['all']) {
 285     echo "Partition Functions\n";
 286     $bDidSomething = true;
 287
 288     $sTemplate = file_get_contents(CONST_BasePath.'/sql/partition-functions.src.sql');
 289
 290     pgsqlRunPartitionScript($sTemplate);
 291 }
 292
 293 if ($aCMDResult['import-wikipedia-articles'] || $aCMDResult['all']) {
 294     $bDidSomething = true;
 295     $sWikiArticlesFile = CONST_Wikipedia_Data_Path.'/wikipedia_article.sql.bin';
 296     $sWikiRedirectsFile = CONST_Wikipedia_Data_Path.'/wikipedia_redirect.sql.bin';
 297     if (file_exists($sWikiArticlesFile)) {
 298         echo "Importing wikipedia articles...";
 299         pgsqlRunDropAndRestore($sWikiArticlesFile);
 300         echo "...done\n";
 301     } else {
 302         echo "WARNING: wikipedia article dump file not found - places will have default importance\n";
 303     }
 304     if (file_exists($sWikiRedirectsFile)) {
 305         echo "Importing wikipedia redirects...";
 306         pgsqlRunDropAndRestore($sWikiRedirectsFile);
 307         echo "...done\n";
 308     } else {
 309         echo "WARNING: wikipedia redirect dump file not found - some place importance values may be missing\n";
 310     }
 311 }
 312
 313
 314 if ($aCMDResult['load-data'] || $aCMDResult['all']) {
 315     echo "Drop old Data\n";
 316     $bDidSomething = true;
 317
 318     $oDB =& getDB();
 319     if (!pg_query($oDB->connection, 'TRUNCATE word')) fail(pg_last_error($oDB->connection));
 320     echo '.';
 321     if (!pg_query($oDB->connection, 'TRUNCATE placex')) fail(pg_last_error($oDB->connection));
 322     echo '.';
 323     if (!pg_query($oDB->connection, 'TRUNCATE location_property_osmline')) fail(pg_last_error($oDB->connection));
 324     echo '.';
 325     if (!pg_query($oDB->connection, 'TRUNCATE place_addressline')) fail(pg_last_error($oDB->connection));
 326     echo '.';
 327     if (!pg_query($oDB->connection, 'TRUNCATE place_boundingbox')) fail(pg_last_error($oDB->connection));
 328     echo '.';
 329     if (!pg_query($oDB->connection, 'TRUNCATE location_area')) fail(pg_last_error($oDB->connection));
 330     echo '.';
 331     if (!pg_query($oDB->connection, 'TRUNCATE search_name')) fail(pg_last_error($oDB->connection));
 332     echo '.';
 333     if (!pg_query($oDB->connection, 'TRUNCATE search_name_blank')) fail(pg_last_error($oDB->connection));
 334     echo '.';
 335     if (!pg_query($oDB->connection, 'DROP SEQUENCE seq_place')) fail(pg_last_error($oDB->connection));
 336     echo '.';
 337     if (!pg_query($oDB->connection, 'CREATE SEQUENCE seq_place start 100000')) fail(pg_last_error($oDB->connection));
 338     echo '.';
 339
 340     $sSQL = 'select distinct partition from country_name';
 341     $aPartitions = chksql($oDB->getCol($sSQL));
 342     if (!$aCMDResult['no-partitions']) $aPartitions[] = 0;
 343     foreach ($aPartitions as $sPartition) {
 344         if (!pg_query($oDB->connection, 'TRUNCATE location_road_'.$sPartition)) fail(pg_last_error($oDB->connection));
 345         echo '.';
 346     }
 347
 348     // used by getorcreate_word_id to ignore frequent partial words
 349     $sSQL = 'CREATE OR REPLACE FUNCTION get_maxwordfreq() RETURNS integer AS ';
 350     $sSQL .= '$$ SELECT '.CONST_Max_Word_Frequency.' as maxwordfreq; $$ LANGUAGE SQL IMMUTABLE';
 351     if (!pg_query($oDB->connection, $sSQL)) {
 352         fail(pg_last_error($oDB->connection));
 353     }
 354     echo ".\n";
 355
 356     // pre-create the word list
 357     if (!$aCMDResult['disable-token-precalc']) {
 358         echo "Loading word list\n";
 359         pgsqlRunScriptFile(CONST_BasePath.'/data/words.sql');
 360     }
 361
 362     echo "Load Data\n";
 363     $sColumns = 'osm_type, osm_id, class, type, name, admin_level, address, extratags, geometry';
 364
 365     $aDBInstances = array();
 366     $iLoadThreads = max(1, $iInstances - 1);
 367     for ($i = 0; $i < $iLoadThreads; $i++) {
 368         $aDBInstances[$i] =& getDB(true);
 369         $sSQL = "INSERT INTO placex ($sColumns) SELECT $sColumns FROM place WHERE osm_id % $iLoadThreads = $i";
 370         $sSQL .= " and not (class='place' and type='houses' and osm_type='W'";
 371         $sSQL .= "          and ST_GeometryType(geometry) = 'ST_LineString')";
 372         $sSQL .= " and ST_IsValid(geometry)";
 373         if ($aCMDResult['verbose']) echo "$sSQL\n";
 374         if (!pg_send_query($aDBInstances[$i]->connection, $sSQL)) {
 375             fail(pg_last_error($aDBInstances[$i]->connection));
 376         }
 377     }
 378     // last thread for interpolation lines
 379     $aDBInstances[$iLoadThreads] =& getDB(true);
 380     $sSQL = 'insert into location_property_osmline';
 381     $sSQL .= ' (osm_id, address, linegeo)';
 382     $sSQL .= ' SELECT osm_id, address, geometry from place where ';
 383     $sSQL .= "class='place' and type='houses' and osm_type='W' and ST_GeometryType(geometry) = 'ST_LineString'";
 384     if ($aCMDResult['verbose']) echo "$sSQL\n";
 385     if (!pg_send_query($aDBInstances[$iLoadThreads]->connection, $sSQL)) {
 386         fail(pg_last_error($aDBInstances[$iLoadThreads]->connection));
 387     }
 388
 389     $bAnyBusy = true;
 390     while ($bAnyBusy) {
 391         $bAnyBusy = false;
 392         for ($i = 0; $i <= $iLoadThreads; $i++) {
 393             if (pg_connection_busy($aDBInstances[$i]->connection)) $bAnyBusy = true;
 394         }
 395         sleep(1);
 396         echo '.';
 397     }
 398     echo "\n";
 399     echo "Reanalysing database...\n";
 400     pgsqlRunScript('ANALYSE');
 401 }
 402
 403 if ($aCMDResult['import-tiger-data']) {
 404     $bDidSomething = true;
 405
 406     $sTemplate = file_get_contents(CONST_BasePath.'/sql/tiger_import_start.sql');
 407     $sTemplate = str_replace('{www-user}', CONST_Database_Web_User, $sTemplate);
 408     $sTemplate = replace_tablespace(
 409         '{ts:aux-data}',
 410         CONST_Tablespace_Aux_Data,
 411         $sTemplate
 412     );
 413     $sTemplate = replace_tablespace(
 414         '{ts:aux-index}',
 415         CONST_Tablespace_Aux_Index,
 416         $sTemplate
 417     );
 418     pgsqlRunScript($sTemplate, false);
 419
 420     $aDBInstances = array();
 421     for ($i = 0; $i < $iInstances; $i++) {
 422         $aDBInstances[$i] =& getDB(true);
 423     }
 424
 425     foreach (glob(CONST_Tiger_Data_Path.'/*.sql') as $sFile) {
 426         echo $sFile.': ';
 427         $hFile = fopen($sFile, "r");
 428         $sSQL = fgets($hFile, 100000);
 429         $iLines = 0;
 430
 431         while (true) {
 432             for ($i = 0; $i < $iInstances; $i++) {
 433                 if (!pg_connection_busy($aDBInstances[$i]->connection)) {
 434                     while (pg_get_result($aDBInstances[$i]->connection));
 435                     $sSQL = fgets($hFile, 100000);
 436                     if (!$sSQL) break 2;
 437                     if (!pg_send_query($aDBInstances[$i]->connection, $sSQL)) fail(pg_last_error($oDB->connection));
 438                     $iLines++;
 439                     if ($iLines == 1000) {
 440                         echo ".";
 441                         $iLines = 0;
 442                     }
 443                 }
 444             }
 445             usleep(10);
 446         }
 447
 448         fclose($hFile);
 449
 450         $bAnyBusy = true;
 451         while ($bAnyBusy) {
 452             $bAnyBusy = false;
 453             for ($i = 0; $i < $iInstances; $i++) {
 454                 if (pg_connection_busy($aDBInstances[$i]->connection)) $bAnyBusy = true;
 455             }
 456             usleep(10);
 457         }
 458         echo "\n";
 459     }
 460
 461     echo "Creating indexes\n";
 462     $sTemplate = file_get_contents(CONST_BasePath.'/sql/tiger_import_finish.sql');
 463     $sTemplate = str_replace('{www-user}', CONST_Database_Web_User, $sTemplate);
 464     $sTemplate = replace_tablespace(
 465         '{ts:aux-data}',
 466         CONST_Tablespace_Aux_Data,
 467         $sTemplate
 468     );
 469     $sTemplate = replace_tablespace(
 470         '{ts:aux-index}',
 471         CONST_Tablespace_Aux_Index,
 472         $sTemplate
 473     );
 474     pgsqlRunScript($sTemplate, false);
 475 }
 476
 477 if ($aCMDResult['calculate-postcodes'] || $aCMDResult['all']) {
 478     $bDidSomething = true;
 479     $oDB =& getDB();
 480     if (!pg_query($oDB->connection, 'DELETE from placex where osm_type=\'P\'')) fail(pg_last_error($oDB->connection));
 481     $sSQL = "insert into placex (osm_type,osm_id,class,type,postcode,country_code,geometry) ";
 482     $sSQL .= "select 'P',nextval('seq_postcodes'),'place','postcode',postcode,country_code,";
 483     $sSQL .= "ST_SetSRID(ST_Point(x,y),4326) as geometry from (select country_code,postcode,";
 484     $sSQL .= "avg(st_x(st_centroid(geometry))) as x,avg(st_y(st_centroid(geometry))) as y ";
 485     $sSQL .= "from placex where postcode is not null group by country_code,postcode) as x ";
 486     $sSQL .= "where ST_Point(x,y) is not null";
 487     if (!pg_query($oDB->connection, $sSQL)) fail(pg_last_error($oDB->connection));
 488
 489     if (CONST_Use_Extra_US_Postcodes) {
 490         $sSQL = "insert into placex (osm_type,osm_id,class,type,postcode,country_code,geometry) ";
 491         $sSQL .= "select 'P',nextval('seq_postcodes'),'place','postcode',postcode,'us',";
 492         $sSQL .= "ST_SetSRID(ST_Point(x,y),4326) as geometry from us_postcode";
 493         if (!pg_query($oDB->connection, $sSQL)) fail(pg_last_error($oDB->connection));
 494     }
 495 }
 496
 497 if ($aCMDResult['osmosis-init'] || ($aCMDResult['all'] && !$aCMDResult['drop'])) { // no use doing osmosis-init when dropping update tables
 498     $bDidSomething = true;
 499     $oDB =& getDB();
 500
 501     if (!file_exists(CONST_Osmosis_Binary)) {
 502         echo "Please download osmosis.\nIf it is already installed, check the path in your local settings (settings/local.php) file.\n";
 503         if (!$aCMDResult['all']) {
 504             fail("osmosis not found in '".CONST_Osmosis_Binary."'");
 505         }
 506     } else {
 507         if (file_exists(CONST_InstallPath.'/settings/configuration.txt')) {
 508             echo "settings/configuration.txt already exists\n";
 509         } else {
 510             passthru(CONST_Osmosis_Binary.' --read-replication-interval-init '.CONST_InstallPath.'/settings');
 511             // update osmosis configuration.txt with our settings
 512             passthru("sed -i 's!baseUrl=.*!baseUrl=".CONST_Replication_Url."!' ".CONST_InstallPath.'/settings/configuration.txt');
 513             passthru("sed -i 's:maxInterval = .*:maxInterval = ".CONST_Replication_MaxInterval.":' ".CONST_InstallPath.'/settings/configuration.txt');
 514         }
 515
 516         // Find the last node in the DB
 517         $iLastOSMID = $oDB->getOne("select max(osm_id) from place where osm_type = 'N'");
 518
 519         // Lookup the timestamp that node was created (less 3 hours for margin for changsets to be closed)
 520         $sLastNodeURL = 'http://www.openstreetmap.org/api/0.6/node/'.$iLastOSMID."/1";
 521         $sLastNodeXML = file_get_contents($sLastNodeURL);
 522         preg_match('#timestamp="(([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})Z)"#', $sLastNodeXML, $aLastNodeDate);
 523         $iLastNodeTimestamp = strtotime($aLastNodeDate[1]) - (3*60*60);
 524
 525         // Search for the correct state file - uses file timestamps so need to sort by date descending
 526         $sRepURL = CONST_Replication_Url."/";
 527         $sRep = file_get_contents($sRepURL."?C=M;O=D;F=1");
 528         // download.geofabrik.de:    <a href="000/">000/</a></td><td align="right">26-Feb-2013 11:53  </td>
 529         // planet.openstreetmap.org: <a href="273/">273/</a>                    2013-03-11 07:41    -
 530         preg_match_all('#<a href="[0-9]{3}/">([0-9]{3}/)</a>\s*([-0-9a-zA-Z]+ [0-9]{2}:[0-9]{2})#', $sRep, $aRepMatches, PREG_SET_ORDER);
 531         if ($aRepMatches) {
 532             $aPrevRepMatch = false;
 533             foreach ($aRepMatches as $aRepMatch) {
 534                 if (strtotime($aRepMatch[2]) < $iLastNodeTimestamp) break;
 535                 $aPrevRepMatch = $aRepMatch;
 536             }
 537             if ($aPrevRepMatch) $aRepMatch = $aPrevRepMatch;
 538
 539             $sRepURL .= $aRepMatch[1];
 540             $sRep = file_get_contents($sRepURL."?C=M;O=D;F=1");
 541             preg_match_all('#<a href="[0-9]{3}/">([0-9]{3}/)</a>\s*([-0-9a-zA-Z]+ [0-9]{2}:[0-9]{2})#', $sRep, $aRepMatches, PREG_SET_ORDER);
 542             $aPrevRepMatch = false;
 543             foreach ($aRepMatches as $aRepMatch) {
 544                 if (strtotime($aRepMatch[2]) < $iLastNodeTimestamp) break;
 545                 $aPrevRepMatch = $aRepMatch;
 546             }
 547             if ($aPrevRepMatch) $aRepMatch = $aPrevRepMatch;
 548
 549             $sRepURL .= $aRepMatch[1];
 550             $sRep = file_get_contents($sRepURL."?C=M;O=D;F=1");
 551             preg_match_all('#<a href="[0-9]{3}.state.txt">([0-9]{3}).state.txt</a>\s*([-0-9a-zA-Z]+ [0-9]{2}:[0-9]{2})#', $sRep, $aRepMatches, PREG_SET_ORDER);
 552             $aPrevRepMatch = false;
 553             foreach ($aRepMatches as $aRepMatch) {
 554                 if (strtotime($aRepMatch[2]) < $iLastNodeTimestamp) break;
 555                 $aPrevRepMatch = $aRepMatch;
 556             }
 557             if ($aPrevRepMatch) $aRepMatch = $aPrevRepMatch;
 558
 559             $sRepURL .= $aRepMatch[1].'.state.txt';
 560             echo "Getting state file: $sRepURL\n";
 561             $sStateFile = file_get_contents($sRepURL);
 562             if (!$sStateFile || strlen($sStateFile) > 1000) fail("unable to obtain state file");
 563             file_put_contents(CONST_InstallPath.'/settings/state.txt', $sStateFile);
 564             echo "Updating DB status\n";
 565             pg_query($oDB->connection, 'TRUNCATE import_status');
 566             $sSQL = "INSERT INTO import_status VALUES('".$aRepMatch[2]."')";
 567             pg_query($oDB->connection, $sSQL);
 568         } else {
 569             if (!$aCMDResult['all']) {
 570                 fail("Cannot read state file directory.");
 571             }
 572         }
 573     }
 574 }
 575
 576 if ($aCMDResult['index'] || $aCMDResult['all']) {
 577     $bDidSomething = true;
 578     $sOutputFile = '';
 579     $sBaseCmd = CONST_InstallPath.'/nominatim/nominatim -i -d '.$aDSNInfo['database'].' -P '.$aDSNInfo['port'].' -t '.$iInstances.$sOutputFile;
 580     passthruCheckReturn($sBaseCmd.' -R 4');
 581     if (!$aCMDResult['index-noanalyse']) pgsqlRunScript('ANALYSE');
 582     passthruCheckReturn($sBaseCmd.' -r 5 -R 25');
 583     if (!$aCMDResult['index-noanalyse']) pgsqlRunScript('ANALYSE');
 584     passthruCheckReturn($sBaseCmd.' -r 26');
 585 }
 586
 587 if ($aCMDResult['create-search-indices'] || $aCMDResult['all']) {
 588     echo "Search indices\n";
 589     $bDidSomething = true;
 590
 591     $sTemplate = file_get_contents(CONST_BasePath.'/sql/indices.src.sql');
 592     $sTemplate = replace_tablespace(
 593         '{ts:address-index}',
 594         CONST_Tablespace_Address_Index,
 595         $sTemplate
 596     );
 597     $sTemplate = replace_tablespace(
 598         '{ts:search-index}',
 599         CONST_Tablespace_Search_Index,
 600         $sTemplate
 601     );
 602     $sTemplate = replace_tablespace(
 603         '{ts:aux-index}',
 604         CONST_Tablespace_Aux_Index,
 605         $sTemplate
 606     );
 607
 608     pgsqlRunScript($sTemplate);
 609 }
 610
 611 if ($aCMDResult['create-country-names'] || $aCMDResult['all']) {
 612     echo 'Creating search index for default country names';
 613     $bDidSomething = true;
 614
 615     pgsqlRunScript("select getorcreate_country(make_standard_name('uk'), 'gb')");
 616     pgsqlRunScript("select getorcreate_country(make_standard_name('united states'), 'us')");
 617     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");
 618     pgsqlRunScript("select count(*) from (select getorcreate_country(make_standard_name(name->'name'), country_code) from country_name where name ? 'name') as x");
 619
 620     $sSQL = 'select count(*) from (select getorcreate_country(make_standard_name(v), country_code) from (select country_code, skeys(name) as k, svals(name) as v from country_name) x where k ';
 621     if (CONST_Languages) {
 622         $sSQL .= 'in ';
 623         $sDelim = '(';
 624         foreach (explode(',', CONST_Languages) as $sLang) {
 625             $sSQL .= $sDelim."'name:$sLang'";
 626             $sDelim = ',';
 627         }
 628         $sSQL .= ')';
 629     } else {
 630         // all include all simple name tags
 631         $sSQL .= "like 'name:%'";
 632     }
 633     $sSQL .= ') v';
 634     pgsqlRunScript($sSQL);
 635 }
 636
 637 if ($aCMDResult['drop']) {
 638     // The implementation is potentially a bit dangerous because it uses
 639     // a positive selection of tables to keep, and deletes everything else.
 640     // Including any tables that the unsuspecting user might have manually
 641     // created. USE AT YOUR OWN PERIL.
 642     $bDidSomething = true;
 643
 644     // tables we want to keep. everything else goes.
 645     $aKeepTables = array(
 646                     "*columns",
 647                     "import_polygon_*",
 648                     "import_status",
 649                     "place_addressline",
 650                     "location_property*",
 651                     "placex",
 652                     "search_name",
 653                     "seq_*",
 654                     "word",
 655                     "query_log",
 656                     "new_query_log",
 657                     "gb_postcode",
 658                     "spatial_ref_sys",
 659                     "country_name",
 660                     "place_classtype_*"
 661                    );
 662
 663     $oDB =& getDB();
 664     $aDropTables = array();
 665     $aHaveTables = chksql($oDB->getCol("SELECT tablename FROM pg_tables WHERE schemaname='public'"));
 666
 667     foreach ($aHaveTables as $sTable) {
 668         $bFound = false;
 669         foreach ($aKeepTables as $sKeep) {
 670             if (fnmatch($sKeep, $sTable)) {
 671                 $bFound = true;
 672                 break;
 673             }
 674         }
 675         if (!$bFound) array_push($aDropTables, $sTable);
 676     }
 677
 678     foreach ($aDropTables as $sDrop) {
 679         if ($aCMDResult['verbose']) echo "dropping table $sDrop\n";
 680         @pg_query($oDB->connection, "DROP TABLE $sDrop CASCADE");
 681         // ignore warnings/errors as they might be caused by a table having
 682         // been deleted already by CASCADE
 683     }
 684
 685     if (!is_null(CONST_Osm2pgsql_Flatnode_File)) {
 686         if ($aCMDResult['verbose']) echo "deleting ".CONST_Osm2pgsql_Flatnode_File."\n";
 687         unlink(CONST_Osm2pgsql_Flatnode_File);
 688     }
 689 }
 690
 691 if (!$bDidSomething) {
 692     showUsage($aCMDOptions, true);
 693 } else {
 694     echo "Setup finished.\n";
 695 }
 696
 697
 698 function pgsqlRunScriptFile($sFilename)
 699 {
 700     if (!file_exists($sFilename)) fail('unable to find '.$sFilename);
 701
 702     // Convert database DSN to psql parameters
 703     $aDSNInfo = DB::parseDSN(CONST_Database_DSN);
 704     if (!isset($aDSNInfo['port']) || !$aDSNInfo['port']) $aDSNInfo['port'] = 5432;
 705     $sCMD = 'psql -p '.$aDSNInfo['port'].' -d '.$aDSNInfo['database'];
 706
 707     $ahGzipPipes = null;
 708     if (preg_match('/\\.gz$/', $sFilename)) {
 709         $aDescriptors = array(
 710                          0 => array('pipe', 'r'),
 711                          1 => array('pipe', 'w'),
 712                          2 => array('file', '/dev/null', 'a')
 713                         );
 714         $hGzipProcess = proc_open('zcat '.$sFilename, $aDescriptors, $ahGzipPipes);
 715         if (!is_resource($hGzipProcess)) fail('unable to start zcat');
 716         $aReadPipe = $ahGzipPipes[1];
 717         fclose($ahGzipPipes[0]);
 718     } else {
 719         $sCMD .= ' -f '.$sFilename;
 720         $aReadPipe = array('pipe', 'r');
 721     }
 722
 723     $aDescriptors = array(
 724                      0 => $aReadPipe,
 725                      1 => array('pipe', 'w'),
 726                      2 => array('file', '/dev/null', 'a')
 727                     );
 728     $ahPipes = null;
 729     $hProcess = proc_open($sCMD, $aDescriptors, $ahPipes);
 730     if (!is_resource($hProcess)) fail('unable to start pgsql');
 731
 732
 733     // TODO: error checking
 734     while (!feof($ahPipes[1])) {
 735         echo fread($ahPipes[1], 4096);
 736     }
 737     fclose($ahPipes[1]);
 738
 739     $iReturn = proc_close($hProcess);
 740     if ($iReturn > 0) {
 741         fail("pgsql returned with error code ($iReturn)");
 742     }
 743     if ($ahGzipPipes) {
 744         fclose($ahGzipPipes[1]);
 745         proc_close($hGzipProcess);
 746     }
 747 }
 748
 749 function pgsqlRunScript($sScript, $bfatal = true)
 750 {
 751     global $aCMDResult;
 752     // Convert database DSN to psql parameters
 753     $aDSNInfo = DB::parseDSN(CONST_Database_DSN);
 754     if (!isset($aDSNInfo['port']) || !$aDSNInfo['port']) $aDSNInfo['port'] = 5432;
 755     $sCMD = 'psql -p '.$aDSNInfo['port'].' -d '.$aDSNInfo['database'];
 756     if ($bfatal && !$aCMDResult['ignore-errors'])
 757         $sCMD .= ' -v ON_ERROR_STOP=1';
 758     $aDescriptors = array(
 759                      0 => array('pipe', 'r'),
 760                      1 => STDOUT,
 761                      2 => STDERR
 762                     );
 763     $ahPipes = null;
 764     $hProcess = @proc_open($sCMD, $aDescriptors, $ahPipes);
 765     if (!is_resource($hProcess)) fail('unable to start pgsql');
 766
 767     while (strlen($sScript)) {
 768         $written = fwrite($ahPipes[0], $sScript);
 769         if ($written <= 0) break;
 770         $sScript = substr($sScript, $written);
 771     }
 772     fclose($ahPipes[0]);
 773     $iReturn = proc_close($hProcess);
 774     if ($bfatal && $iReturn > 0) {
 775         fail("pgsql returned with error code ($iReturn)");
 776     }
 777 }
 778
 779 function pgsqlRunPartitionScript($sTemplate)
 780 {
 781     global $aCMDResult;
 782     $oDB =& getDB();
 783
 784     $sSQL = 'select distinct partition from country_name';
 785     $aPartitions = chksql($oDB->getCol($sSQL));
 786     if (!$aCMDResult['no-partitions']) $aPartitions[] = 0;
 787
 788     preg_match_all('#^-- start(.*?)^-- end#ms', $sTemplate, $aMatches, PREG_SET_ORDER);
 789     foreach ($aMatches as $aMatch) {
 790         $sResult = '';
 791         foreach ($aPartitions as $sPartitionName) {
 792             $sResult .= str_replace('-partition-', $sPartitionName, $aMatch[1]);
 793         }
 794         $sTemplate = str_replace($aMatch[0], $sResult, $sTemplate);
 795     }
 796
 797     pgsqlRunScript($sTemplate);
 798 }
 799
 800 function pgsqlRunRestoreData($sDumpFile)
 801 {
 802     // Convert database DSN to psql parameters
 803     $aDSNInfo = DB::parseDSN(CONST_Database_DSN);
 804     if (!isset($aDSNInfo['port']) || !$aDSNInfo['port']) $aDSNInfo['port'] = 5432;
 805     $sCMD = 'pg_restore -p '.$aDSNInfo['port'].' -d '.$aDSNInfo['database'].' -Fc -a '.$sDumpFile;
 806
 807     $aDescriptors = array(
 808                      0 => array('pipe', 'r'),
 809                      1 => array('pipe', 'w'),
 810                      2 => array('file', '/dev/null', 'a')
 811                     );
 812     $ahPipes = null;
 813     $hProcess = proc_open($sCMD, $aDescriptors, $ahPipes);
 814     if (!is_resource($hProcess)) fail('unable to start pg_restore');
 815
 816     fclose($ahPipes[0]);
 817
 818     // TODO: error checking
 819     while (!feof($ahPipes[1])) {
 820         echo fread($ahPipes[1], 4096);
 821     }
 822     fclose($ahPipes[1]);
 823
 824     $iReturn = proc_close($hProcess);
 825 }
 826
 827 function pgsqlRunDropAndRestore($sDumpFile)
 828 {
 829     // Convert database DSN to psql parameters
 830     $aDSNInfo = DB::parseDSN(CONST_Database_DSN);
 831     if (!isset($aDSNInfo['port']) || !$aDSNInfo['port']) $aDSNInfo['port'] = 5432;
 832     $sCMD = 'pg_restore -p '.$aDSNInfo['port'].' -d '.$aDSNInfo['database'].' -Fc --clean '.$sDumpFile;
 833
 834     $aDescriptors = array(
 835                      0 => array('pipe', 'r'),
 836                      1 => array('pipe', 'w'),
 837                      2 => array('file', '/dev/null', 'a')
 838                     );
 839     $ahPipes = null;
 840     $hProcess = proc_open($sCMD, $aDescriptors, $ahPipes);
 841     if (!is_resource($hProcess)) fail('unable to start pg_restore');
 842
 843     fclose($ahPipes[0]);
 844
 845     // TODO: error checking
 846     while (!feof($ahPipes[1])) {
 847         echo fread($ahPipes[1], 4096);
 848     }
 849     fclose($ahPipes[1]);
 850
 851     $iReturn = proc_close($hProcess);
 852 }
 853
 854 function passthruCheckReturn($cmd)
 855 {
 856     $result = -1;
 857     passthru($cmd, $result);
 858     if ($result != 0) fail('Error executing external command: '.$cmd);
 859 }
 860
 861 function replace_tablespace($sTemplate, $sTablespace, $sSql)
 862 {
 863     if ($sTablespace) {
 864         $sSql = str_replace($sTemplate, 'TABLESPACE "'.$sTablespace.'"', $sSql);
 865     } else {
 866         $sSql = str_replace($sTemplate, '', $sSql);
 867     }
 868
 869     return $sSql;
 870 }
 871
 872 function create_sql_functions($aCMDResult)
 873 {
 874     $sTemplate = file_get_contents(CONST_BasePath.'/sql/functions.sql');
 875     $sTemplate = str_replace('{modulepath}', CONST_InstallPath.'/module', $sTemplate);
 876     if ($aCMDResult['enable-diff-updates']) {
 877         $sTemplate = str_replace('RETURN NEW; -- %DIFFUPDATES%', '--', $sTemplate);
 878     }
 879     if ($aCMDResult['enable-debug-statements']) {
 880         $sTemplate = str_replace('--DEBUG:', '', $sTemplate);
 881     }
 882     if (CONST_Limit_Reindexing) {
 883         $sTemplate = str_replace('--LIMIT INDEXING:', '', $sTemplate);
 884     }
 885     if (!CONST_Use_US_Tiger_Data) {
 886         $sTemplate = str_replace('-- %NOTIGERDATA% ', '', $sTemplate);
 887     }
 888     if (!CONST_Use_Aux_Location_data) {
 889         $sTemplate = str_replace('-- %NOAUXDATA% ', '', $sTemplate);
 890     }
 891     pgsqlRunScript($sTemplate);
 892 }