]> git.openstreetmap.org Git - nominatim.git/blob - nominatim/tools/special_phrases/sp_importer.py
avoid repeated patterns for table name
[nominatim.git] / nominatim / tools / special_phrases / sp_importer.py
1 """
2     Module containing the class handling the import
3     of the special phrases.
4
5     Phrases are analyzed and imported into the database.
6
7     The phrases already present in the database which are not
8     valids anymore are removed.
9 """
10 import logging
11 import os
12 from os.path import isfile
13 from pathlib import Path
14 import re
15 import subprocess
16 import json
17
18 from psycopg2.sql import Identifier, Literal, SQL
19 from nominatim.errors import UsageError
20 from nominatim.tools.special_phrases.importer_statistics import SpecialPhrasesImporterStatistics
21
22 LOG = logging.getLogger()
23
24 def _classtype_table(phrase_class, phrase_type):
25     """ Return the name of the table for the given class and type.
26     """
27     return f'place_classtype_{phrase_class}_{phrase_type}'
28
29 class SPImporter():
30     # pylint: disable-msg=too-many-instance-attributes
31     """
32         Class handling the process of special phrases importation into the database.
33
34         Take a sp loader which load the phrases from an external source.
35     """
36     def __init__(self, config, phplib_dir, db_connection, sp_loader) -> None:
37         self.config = config
38         self.phplib_dir = phplib_dir
39         self.db_connection = db_connection
40         self.sp_loader = sp_loader
41         self.statistics_handler = SpecialPhrasesImporterStatistics()
42         self.black_list, self.white_list = self._load_white_and_black_lists()
43         self.sanity_check_pattern = re.compile(r'^\w+$')
44         # This set will contain all existing phrases to be added.
45         # It contains tuples with the following format: (lable, class, type, operator)
46         self.word_phrases = set()
47         #This set will contain all existing place_classtype tables which doesn't match any
48         #special phrases class/type on the wiki.
49         self.table_phrases_to_delete = set()
50
51     def import_phrases(self, tokenizer, should_replace):
52         """
53             Iterate through all SpecialPhrases extracted from the
54             loader and import them into the database.
55
56             If should_replace is set to True only the loaded phrases
57             will be kept into the database. All other phrases already
58             in the database will be removed.
59         """
60         LOG.warning('Special phrases importation starting')
61         self._fetch_existing_place_classtype_tables()
62
63         #Store pairs of class/type for further processing
64         class_type_pairs = set()
65
66         for loaded_phrases in self.sp_loader:
67             for phrase in loaded_phrases:
68                 result = self._process_phrase(phrase)
69                 if result:
70                     class_type_pairs.add(result)
71
72         self._create_place_classtype_table_and_indexes(class_type_pairs)
73         if should_replace:
74             self._remove_non_existent_tables_from_db()
75         self.db_connection.commit()
76
77         with tokenizer.name_analyzer() as analyzer:
78             analyzer.update_special_phrases(self.word_phrases, should_replace)
79
80         LOG.warning('Import done.')
81         self.statistics_handler.notify_import_done()
82
83
84     def _fetch_existing_place_classtype_tables(self):
85         """
86             Fetch existing place_classtype tables.
87             Fill the table_phrases_to_delete set of the class.
88         """
89         query = """
90             SELECT table_name
91             FROM information_schema.tables
92             WHERE table_schema='public'
93             AND table_name like 'place_classtype_%';
94         """
95         with self.db_connection.cursor() as db_cursor:
96             db_cursor.execute(SQL(query))
97             for row in db_cursor:
98                 self.table_phrases_to_delete.add(row[0])
99
100     def _load_white_and_black_lists(self):
101         """
102             Load white and black lists from phrases-settings.json.
103         """
104         settings_path = (self.config.config_dir / 'phrase-settings.json').resolve()
105
106         if self.config.PHRASE_CONFIG:
107             settings_path = self._convert_php_settings_if_needed(self.config.PHRASE_CONFIG)
108
109         with settings_path.open("r") as json_settings:
110             settings = json.load(json_settings)
111         return settings['blackList'], settings['whiteList']
112
113     def _check_sanity(self, phrase):
114         """
115             Check sanity of given inputs in case somebody added garbage in the wiki.
116             If a bad class/type is detected the system will exit with an error.
117         """
118         class_matchs = self.sanity_check_pattern.findall(phrase.p_class)
119         type_matchs = self.sanity_check_pattern.findall(phrase.p_type)
120
121         if not class_matchs or not type_matchs:
122             LOG.warning("Bad class/type: %s=%s. It will not be imported",
123                         phrase.p_class, phrase.p_type)
124             return False
125         return True
126
127     def _process_phrase(self, phrase):
128         """
129             Processes the given phrase by checking black and white list
130             and sanity.
131             Return the class/type pair corresponding to the phrase.
132         """
133
134         #blacklisting: disallow certain class/type combinations
135         if phrase.p_class in self.black_list.keys() \
136            and phrase.p_type in self.black_list[phrase.p_class]:
137             return None
138
139         #whitelisting: if class is in whitelist, allow only tags in the list
140         if phrase.p_class in self.white_list.keys() \
141            and phrase.p_type not in self.white_list[phrase.p_class]:
142             return None
143
144         #sanity check, in case somebody added garbage in the wiki
145         if not self._check_sanity(phrase):
146             self.statistics_handler.notify_one_phrase_invalid()
147             return None
148
149         self.word_phrases.add((phrase.p_label, phrase.p_class,
150                                phrase.p_type, phrase.p_operator))
151
152         return (phrase.p_class, phrase.p_type)
153
154
155     def _create_place_classtype_table_and_indexes(self, class_type_pairs):
156         """
157             Create table place_classtype for each given pair.
158             Also create indexes on place_id and centroid.
159         """
160         LOG.warning('Create tables and indexes...')
161
162         sql_tablespace = self.config.TABLESPACE_AUX_DATA
163         if sql_tablespace:
164             sql_tablespace = ' TABLESPACE '+sql_tablespace
165
166         with self.db_connection.cursor() as db_cursor:
167             db_cursor.execute("CREATE INDEX idx_placex_classtype ON placex (class, type)")
168
169         for pair in class_type_pairs:
170             phrase_class = pair[0]
171             phrase_type = pair[1]
172
173             table_name = _classtype_table(phrase_class, phrase_type)
174
175             if table_name in self.table_phrases_to_delete:
176                 self.statistics_handler.notify_one_table_ignored()
177                 #Remove this table from the ones to delete as it match a class/type
178                 #still existing on the special phrases of the wiki.
179                 self.table_phrases_to_delete.remove(table_name)
180                 #So dont need to create the table and indexes.
181                 continue
182
183             #Table creation
184             self._create_place_classtype_table(sql_tablespace, phrase_class, phrase_type)
185
186             #Indexes creation
187             self._create_place_classtype_indexes(sql_tablespace, phrase_class, phrase_type)
188
189             #Grant access on read to the web user.
190             self._grant_access_to_webuser(phrase_class, phrase_type)
191
192             self.statistics_handler.notify_one_table_created()
193
194         with self.db_connection.cursor() as db_cursor:
195             db_cursor.execute("DROP INDEX idx_placex_classtype")
196
197
198     def _create_place_classtype_table(self, sql_tablespace, phrase_class, phrase_type):
199         """
200             Create table place_classtype of the given phrase_class/phrase_type if doesn't exit.
201         """
202         table_name = _classtype_table(phrase_class, phrase_type)
203         with self.db_connection.cursor() as db_cursor:
204             db_cursor.execute(SQL("""
205                     CREATE TABLE IF NOT EXISTS {{}} {} 
206                     AS SELECT place_id AS place_id,st_centroid(geometry) AS centroid FROM placex 
207                     WHERE class = {{}} AND type = {{}}""".format(sql_tablespace))
208                               .format(Identifier(table_name), Literal(phrase_class),
209                                       Literal(phrase_type)))
210
211
212     def _create_place_classtype_indexes(self, sql_tablespace, phrase_class, phrase_type):
213         """
214             Create indexes on centroid and place_id for the place_classtype table.
215         """
216         index_prefix = 'idx_place_classtype_{}_{}_'.format(phrase_class, phrase_type)
217         base_table = _classtype_table(phrase_class, phrase_type)
218         #Index on centroid
219         if not self.db_connection.index_exists(index_prefix + 'centroid'):
220             with self.db_connection.cursor() as db_cursor:
221                 db_cursor.execute(SQL("""
222                     CREATE INDEX {{}} ON {{}} USING GIST (centroid) {}""".format(sql_tablespace))
223                                   .format(Identifier(index_prefix + 'centroid'),
224                                           Identifier(base_table)), sql_tablespace)
225
226         #Index on place_id
227         if not self.db_connection.index_exists(index_prefix + 'place_id'):
228             with self.db_connection.cursor() as db_cursor:
229                 db_cursor.execute(SQL(
230                     """CREATE INDEX {{}} ON {{}} USING btree(place_id) {}""".format(sql_tablespace))
231                                   .format(Identifier(index_prefix + 'place_id'),
232                                           Identifier(base_table)))
233
234
235     def _grant_access_to_webuser(self, phrase_class, phrase_type):
236         """
237             Grant access on read to the table place_classtype for the webuser.
238         """
239         table_name = _classtype_table(phrase_class, phrase_type)
240         with self.db_connection.cursor() as db_cursor:
241             db_cursor.execute(SQL("""GRANT SELECT ON {} TO {}""")
242                               .format(Identifier(table_name),
243                                       Identifier(self.config.DATABASE_WEBUSER)))
244
245     def _remove_non_existent_tables_from_db(self):
246         """
247             Remove special phrases which doesn't exist on the wiki anymore.
248             Delete the place_classtype tables.
249         """
250         LOG.warning('Cleaning database...')
251         #Array containing all queries to execute. Contain tuples of format (query, parameters)
252         queries_parameters = []
253
254         #Delete place_classtype tables corresponding to class/type which are not on the wiki anymore
255         for table in self.table_phrases_to_delete:
256             self.statistics_handler.notify_one_table_deleted()
257             query = SQL('DROP TABLE IF EXISTS {}').format(Identifier(table))
258             queries_parameters.append((query, ()))
259
260         with self.db_connection.cursor() as db_cursor:
261             for query, parameters in queries_parameters:
262                 db_cursor.execute(query, parameters)
263
264     def _convert_php_settings_if_needed(self, file_path):
265         """
266             Convert php settings file of special phrases to json file if it is still in php format.
267         """
268         if not isfile(file_path):
269             raise UsageError(str(file_path) + ' is not a valid file.')
270
271         file, extension = os.path.splitext(file_path)
272         json_file_path = Path(file + '.json').resolve()
273
274         if extension not in('.php', '.json'):
275             raise UsageError('The custom NOMINATIM_PHRASE_CONFIG file has not a valid extension.')
276
277         if extension == '.php' and not isfile(json_file_path):
278             try:
279                 subprocess.run(['/usr/bin/env', 'php', '-Cq',
280                                 (self.phplib_dir / 'migration/PhraseSettingsToJson.php').resolve(),
281                                 file_path], check=True)
282                 LOG.warning('special_phrase configuration file has been converted to json.')
283             except subprocess.CalledProcessError:
284                 LOG.error('Error while converting %s to json.', file_path)
285                 raise
286
287         return json_file_path