]> git.openstreetmap.org Git - nominatim.git/blob - nominatim/tools/migration.py
Refactoring loading of external special phrases and importation process by introducin...
[nominatim.git] / nominatim / tools / migration.py
1 """
2 Functions for database migration to newer software versions.
3 """
4 import logging
5
6 from nominatim.db import properties
7 from nominatim.db.connection import connect
8 from nominatim.version import NOMINATIM_VERSION
9 from nominatim.tools import refresh
10 from nominatim.tokenizer import factory as tokenizer_factory
11 from nominatim.errors import UsageError
12
13 LOG = logging.getLogger()
14
15 _MIGRATION_FUNCTIONS = []
16
17 def migrate(config, paths):
18     """ Check for the current database version and execute migrations,
19         if necesssary.
20     """
21     with connect(config.get_libpq_dsn()) as conn:
22         if conn.table_exists('nominatim_properties'):
23             db_version_str = properties.get_property(conn, 'database_version')
24         else:
25             db_version_str = None
26
27         if db_version_str is not None:
28             parts = db_version_str.split('.')
29             db_version = tuple([int(x) for x in parts[:2] + parts[2].split('-')])
30
31             if db_version == NOMINATIM_VERSION:
32                 LOG.warning("Database already at latest version (%s)", db_version_str)
33                 return 0
34
35             LOG.info("Detected database version: %s", db_version_str)
36         else:
37             db_version = _guess_version(conn)
38
39
40         has_run_migration = False
41         for version, func in _MIGRATION_FUNCTIONS:
42             if db_version <= version:
43                 LOG.warning("Runnning: %s (%s)", func.__doc__.split('\n', 1)[0],
44                             '{0[0]}.{0[1]}.{0[2]}-{0[3]}'.format(version))
45                 kwargs = dict(conn=conn, config=config, paths=paths)
46                 func(**kwargs)
47                 conn.commit()
48                 has_run_migration = True
49
50         if has_run_migration:
51             LOG.warning('Updating SQL functions.')
52             refresh.create_functions(conn, config)
53             tokenizer = tokenizer_factory.get_tokenizer_for_db(config)
54             tokenizer.update_sql_functions(config)
55
56         properties.set_property(conn, 'database_version',
57                                 '{0[0]}.{0[1]}.{0[2]}-{0[3]}'.format(NOMINATIM_VERSION))
58
59         conn.commit()
60
61     return 0
62
63
64 def _guess_version(conn):
65     """ Guess a database version when there is no property table yet.
66         Only migrations for 3.6 and later are supported, so bail out
67         when the version seems older.
68     """
69     with conn.cursor() as cur:
70         # In version 3.6, the country_name table was updated. Check for that.
71         cnt = cur.scalar("""SELECT count(*) FROM
72                             (SELECT svals(name) FROM  country_name
73                              WHERE country_code = 'gb')x;
74                          """)
75         if cnt < 100:
76             LOG.fatal('It looks like your database was imported with a version '
77                       'prior to 3.6.0. Automatic migration not possible.')
78             raise UsageError('Migration not possible.')
79
80     return (3, 5, 0, 99)
81
82
83
84 def _migration(major, minor, patch=0, dbpatch=0):
85     """ Decorator for a single migration step. The parameters describe the
86         version after which the migration is applicable, i.e before changing
87         from the given version to the next, the migration is required.
88
89         All migrations are run in the order in which they are defined in this
90         file. Do not run global SQL scripts for migrations as you cannot be sure
91         that these scripts do the same in later versions.
92
93         Functions will always be reimported in full at the end of the migration
94         process, so the migration functions may leave a temporary state behind
95         there.
96     """
97     def decorator(func):
98         _MIGRATION_FUNCTIONS.append(((major, minor, patch, dbpatch), func))
99
100     return decorator
101
102
103 @_migration(3, 5, 0, 99)
104 def import_status_timestamp_change(conn, **_):
105     """ Add timezone to timestamp in status table.
106
107         The import_status table has been changed to include timezone information
108         with the time stamp.
109     """
110     with conn.cursor() as cur:
111         cur.execute("""ALTER TABLE import_status ALTER COLUMN lastimportdate
112                        TYPE timestamp with time zone;""")
113
114
115 @_migration(3, 5, 0, 99)
116 def add_nominatim_property_table(conn, config, **_):
117     """ Add nominatim_property table.
118     """
119     if not conn.table_exists('nominatim_properties'):
120         with conn.cursor() as cur:
121             cur.execute("""CREATE TABLE nominatim_properties (
122                                property TEXT,
123                                value TEXT);
124                            GRANT SELECT ON TABLE nominatim_properties TO "{}";
125                         """.format(config.DATABASE_WEBUSER))
126
127 @_migration(3, 6, 0, 0)
128 def change_housenumber_transliteration(conn, **_):
129     """ Transliterate housenumbers.
130
131         The database schema switched from saving raw housenumbers in
132         placex.housenumber to saving transliterated ones.
133
134         Note: the function create_housenumber_id() has been dropped in later
135               versions.
136     """
137     with conn.cursor() as cur:
138         cur.execute("""CREATE OR REPLACE FUNCTION create_housenumber_id(housenumber TEXT)
139                        RETURNS TEXT AS $$
140                        DECLARE
141                          normtext TEXT;
142                        BEGIN
143                          SELECT array_to_string(array_agg(trans), ';')
144                            INTO normtext
145                            FROM (SELECT lookup_word as trans, getorcreate_housenumber_id(lookup_word)
146                                  FROM (SELECT make_standard_name(h) as lookup_word
147                                        FROM regexp_split_to_table(housenumber, '[,;]') h) x) y;
148                          return normtext;
149                        END;
150                        $$ LANGUAGE plpgsql STABLE STRICT;""")
151         cur.execute("DELETE FROM word WHERE class = 'place' and type = 'house'")
152         cur.execute("""UPDATE placex
153                        SET housenumber = create_housenumber_id(housenumber)
154                        WHERE housenumber is not null""")
155
156
157 @_migration(3, 7, 0, 0)
158 def switch_placenode_geometry_index(conn, **_):
159     """ Replace idx_placex_geometry_reverse_placeNode index.
160
161         Make the index slightly more permissive, so that it can also be used
162         when matching up boundaries and place nodes. It makes the index
163         idx_placex_adminname index unnecessary.
164     """
165     with conn.cursor() as cur:
166         cur.execute(""" CREATE INDEX IF NOT EXISTS idx_placex_geometry_placenode ON placex
167                         USING GIST (geometry)
168                         WHERE osm_type = 'N' and rank_search < 26
169                               and class = 'place' and type != 'postcode'
170                               and linked_place_id is null""")
171         cur.execute(""" DROP INDEX IF EXISTS idx_placex_adminname """)
172
173
174 @_migration(3, 7, 0, 1)
175 def install_legacy_tokenizer(conn, config, **_):
176     """ Setup legacy tokenizer.
177
178         If no other tokenizer has been configured yet, then create the
179         configuration for the backwards-compatible legacy tokenizer
180     """
181     if properties.get_property(conn, 'tokenizer') is None:
182         with conn.cursor() as cur:
183             for table in ('placex', 'location_property_osmline'):
184                 has_column = cur.scalar("""SELECT count(*) FROM information_schema.columns
185                                            WHERE table_name = %s
186                                            and column_name = 'token_info'""",
187                                         (table, ))
188             if has_column == 0:
189                 cur.execute('ALTER TABLE {} ADD COLUMN token_info JSONB'.format(table))
190         tokenizer = tokenizer_factory.create_tokenizer(config, init_db=False,
191                                                        module_name='legacy')
192
193         tokenizer.migrate_database(config)