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         return func
 100
 101     return decorator
 102
 103
 104 @_migration(3, 5, 0, 99)
 105 def import_status_timestamp_change(conn, **_):
 106     """ Add timezone to timestamp in status table.
 107
 108         The import_status table has been changed to include timezone information
 109         with the time stamp.
 110     """
 111     with conn.cursor() as cur:
 112         cur.execute("""ALTER TABLE import_status ALTER COLUMN lastimportdate
 113                        TYPE timestamp with time zone;""")
 114
 115
 116 @_migration(3, 5, 0, 99)
 117 def add_nominatim_property_table(conn, config, **_):
 118     """ Add nominatim_property table.
 119     """
 120     if not conn.table_exists('nominatim_properties'):
 121         with conn.cursor() as cur:
 122             cur.execute("""CREATE TABLE nominatim_properties (
 123                                property TEXT,
 124                                value TEXT);
 125                            GRANT SELECT ON TABLE nominatim_properties TO "{}";
 126                         """.format(config.DATABASE_WEBUSER))
 127
 128 @_migration(3, 6, 0, 0)
 129 def change_housenumber_transliteration(conn, **_):
 130     """ Transliterate housenumbers.
 131
 132         The database schema switched from saving raw housenumbers in
 133         placex.housenumber to saving transliterated ones.
 134
 135         Note: the function create_housenumber_id() has been dropped in later
 136               versions.
 137     """
 138     with conn.cursor() as cur:
 139         cur.execute("""CREATE OR REPLACE FUNCTION create_housenumber_id(housenumber TEXT)
 140                        RETURNS TEXT AS $$
 141                        DECLARE
 142                          normtext TEXT;
 143                        BEGIN
 144                          SELECT array_to_string(array_agg(trans), ';')
 145                            INTO normtext
 146                            FROM (SELECT lookup_word as trans,
 147                                         getorcreate_housenumber_id(lookup_word)
 148                                  FROM (SELECT make_standard_name(h) as lookup_word
 149                                        FROM regexp_split_to_table(housenumber, '[,;]') h) x) y;
 150                          return normtext;
 151                        END;
 152                        $$ LANGUAGE plpgsql STABLE STRICT;""")
 153         cur.execute("DELETE FROM word WHERE class = 'place' and type = 'house'")
 154         cur.execute("""UPDATE placex
 155                        SET housenumber = create_housenumber_id(housenumber)
 156                        WHERE housenumber is not null""")
 157
 158
 159 @_migration(3, 7, 0, 0)
 160 def switch_placenode_geometry_index(conn, **_):
 161     """ Replace idx_placex_geometry_reverse_placeNode index.
 162
 163         Make the index slightly more permissive, so that it can also be used
 164         when matching up boundaries and place nodes. It makes the index
 165         idx_placex_adminname index unnecessary.
 166     """
 167     with conn.cursor() as cur:
 168         cur.execute(""" CREATE INDEX IF NOT EXISTS idx_placex_geometry_placenode ON placex
 169                         USING GIST (geometry)
 170                         WHERE osm_type = 'N' and rank_search < 26
 171                               and class = 'place' and type != 'postcode'
 172                               and linked_place_id is null""")
 173         cur.execute(""" DROP INDEX IF EXISTS idx_placex_adminname """)
 174
 175
 176 @_migration(3, 7, 0, 1)
 177 def install_legacy_tokenizer(conn, config, **_):
 178     """ Setup legacy tokenizer.
 179
 180         If no other tokenizer has been configured yet, then create the
 181         configuration for the backwards-compatible legacy tokenizer
 182     """
 183     if properties.get_property(conn, 'tokenizer') is None:
 184         with conn.cursor() as cur:
 185             for table in ('placex', 'location_property_osmline'):
 186                 has_column = cur.scalar("""SELECT count(*) FROM information_schema.columns
 187                                            WHERE table_name = %s
 188                                            and column_name = 'token_info'""",
 189                                         (table, ))
 190                 if has_column == 0:
 191                     cur.execute('ALTER TABLE {} ADD COLUMN token_info JSONB'.format(table))
 192         tokenizer = tokenizer_factory.create_tokenizer(config, init_db=False,
 193                                                        module_name='legacy')
 194
 195         tokenizer.migrate_database(config)
 196
 197
 198 @_migration(4, 0, 99, 0)
 199 def create_tiger_housenumber_index(conn, **_):
 200     """ Create idx_location_property_tiger_parent_place_id with included
 201         house number.
 202
 203         The inclusion is needed for efficient lookup of housenumbers in
 204         full address searches.
 205     """
 206     if conn.server_version_tuple() >= (11, 0, 0):
 207         with conn.cursor() as cur:
 208             cur.execute(""" CREATE INDEX IF NOT EXISTS
 209                                 idx_location_property_tiger_housenumber_migrated
 210                             ON location_property_tiger
 211                             USING btree(parent_place_id)
 212                             INCLUDE (startnumber, endnumber) """)