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