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                 has_run_migration = True
  48
  49         if has_run_migration:
  50             LOG.warning('Updating SQL functions.')
  51             refresh.create_functions(conn, config)
  52             tokenizer = tokenizer_factory.get_tokenizer_for_db(config)
  53             tokenizer.update_sql_functions(config)
  54
  55         properties.set_property(conn, 'database_version',
  56                                 '{0[0]}.{0[1]}.{0[2]}-{0[3]}'.format(NOMINATIM_VERSION))
  57
  58         conn.commit()
  59
  60     return 0
  61
  62
  63 def _guess_version(conn):
  64     """ Guess a database version when there is no property table yet.
  65         Only migrations for 3.6 and later are supported, so bail out
  66         when the version seems older.
  67     """
  68     with conn.cursor() as cur:
  69         # In version 3.6, the country_name table was updated. Check for that.
  70         cnt = cur.scalar("""SELECT count(*) FROM
  71                             (SELECT svals(name) FROM  country_name
  72                              WHERE country_code = 'gb')x;
  73                          """)
  74         if cnt < 100:
  75             LOG.fatal('It looks like your database was imported with a version '
  76                       'prior to 3.6.0. Automatic migration not possible.')
  77             raise UsageError('Migration not possible.')
  78
  79     return (3, 5, 0, 99)
  80
  81
  82
  83 def _migration(major, minor, patch=0, dbpatch=0):
  84     """ Decorator for a single migration step. The parameters describe the
  85         version after which the migration is applicable, i.e before changing
  86         from the given version to the next, the migration is required.
  87
  88         All migrations are run in the order in which they are defined in this
  89         file. Do not run global SQL scripts for migrations as you cannot be sure
  90         that these scripts do the same in later versions.
  91
  92         Functions will always be reimported in full at the end of the migration
  93         process, so the migration functions may leave a temporary state behind
  94         there.
  95     """
  96     def decorator(func):
  97         _MIGRATION_FUNCTIONS.append(((major, minor, patch, dbpatch), func))
  98
  99     return decorator
 100
 101
 102 @_migration(3, 5, 0, 99)
 103 def import_status_timestamp_change(conn, **_):
 104     """ Add timezone to timestamp in status table.
 105
 106         The import_status table has been changed to include timezone information
 107         with the time stamp.
 108     """
 109     with conn.cursor() as cur:
 110         cur.execute("""ALTER TABLE import_status ALTER COLUMN lastimportdate
 111                        TYPE timestamp with time zone;""")
 112
 113
 114 @_migration(3, 5, 0, 99)
 115 def add_nominatim_property_table(conn, config, **_):
 116     """ Add nominatim_property table.
 117     """
 118     if not conn.table_exists('nominatim_properties'):
 119         with conn.cursor() as cur:
 120             cur.execute("""CREATE TABLE nominatim_properties (
 121                                property TEXT,
 122                                value TEXT);
 123                            GRANT SELECT ON TABLE nominatim_properties TO "{}";
 124                         """.format(config.DATABASE_WEBUSER))
 125
 126 @_migration(3, 6, 0, 0)
 127 def change_housenumber_transliteration(conn, **_):
 128     """ Transliterate housenumbers.
 129
 130         The database schema switched from saving raw housenumbers in
 131         placex.housenumber to saving transliterated ones.
 132     """
 133     with conn.cursor() as cur:
 134         cur.execute("""CREATE OR REPLACE FUNCTION create_housenumber_id(housenumber TEXT)
 135                        RETURNS TEXT AS $$
 136                        DECLARE
 137                          normtext TEXT;
 138                        BEGIN
 139                          SELECT array_to_string(array_agg(trans), ';')
 140                            INTO normtext
 141                            FROM (SELECT lookup_word as trans, getorcreate_housenumber_id(lookup_word)
 142                                  FROM (SELECT make_standard_name(h) as lookup_word
 143                                        FROM regexp_split_to_table(housenumber, '[,;]') h) x) y;
 144                          return normtext;
 145                        END;
 146                        $$ LANGUAGE plpgsql STABLE STRICT;""")
 147         cur.execute("DELETE FROM word WHERE class = 'place' and type = 'house'")
 148         cur.execute("""UPDATE placex
 149                        SET housenumber = create_housenumber_id(housenumber)
 150                        WHERE housenumber is not null""")
 151
 152
 153 @_migration(3, 7, 0, 0)
 154 def switch_placenode_geometry_index(conn, **_):
 155     """ Replace idx_placex_geometry_reverse_placeNode index.
 156
 157         Make the index slightly more permissive, so that it can also be used
 158         when matching up boundaries and place nodes. It makes the index
 159         idx_placex_adminname index unnecessary.
 160     """
 161     with conn.cursor() as cur:
 162         cur.execute(""" CREATE INDEX IF NOT EXISTS idx_placex_geometry_placenode ON placex
 163                         USING GIST (geometry)
 164                         WHERE osm_type = 'N' and rank_search < 26
 165                               and class = 'place' and type != 'postcode'
 166                               and linked_place_id is null""")
 167         cur.execute(""" DROP INDEX IF EXISTS idx_placex_adminname """)
 168
 169
 170 @_migration(3, 7, 0, 1)
 171 def install_legacy_tokenizer(conn, config, **_):
 172     """ Setup legacy tokenizer.
 173
 174         If no other tokenizer has been configured yet, then create the
 175         configuration for the backwards-compatible legacy tokenizer
 176     """
 177     if properties.get_property(conn, 'tokenizer') is None:
 178         tokenizer = tokenizer_factory.create_tokenizer(config, init_db=False,
 179                                                        module_name='legacy')
 180
 181         tokenizer.migrate_database(config)