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