nominatim/clicmd/setup.py

   1 # SPDX-License-Identifier: GPL-2.0-only
   2 #
   3 # This file is part of Nominatim. (https://nominatim.org)
   4 #
   5 # Copyright (C) 2022 by the Nominatim developer community.
   6 # For a full list of authors see the git log.
   7 """
   8 Implementation of the 'import' subcommand.
   9 """
  10 import logging
  11 from pathlib import Path
  12
  13 import psutil
  14
  15 from nominatim.db.connection import connect
  16 from nominatim.db import status, properties
  17 from nominatim.version import version_str
  18
  19 # Do not repeat documentation of subcommand classes.
  20 # pylint: disable=C0111
  21 # Using non-top-level imports to avoid eventually unused imports.
  22 # pylint: disable=C0415
  23
  24 LOG = logging.getLogger()
  25
  26 class SetupAll:
  27     """\
  28     Create a new Nominatim database from an OSM file.
  29
  30     This sub-command sets up a new Nominatim database from scratch starting
  31     with creating a new database in Postgresql. The user running this command
  32     needs superuser rights on the database.
  33     """
  34
  35     @staticmethod
  36     def add_args(parser):
  37         group_name = parser.add_argument_group('Required arguments')
  38         group = group_name.add_mutually_exclusive_group(required=True)
  39         group.add_argument('--osm-file', metavar='FILE', action='append',
  40                            help='OSM file to be imported'
  41                                 ' (repeat for importing multiple files)')
  42         group.add_argument('--continue', dest='continue_at',
  43                            choices=['load-data', 'indexing', 'db-postprocess'],
  44                            help='Continue an import that was interrupted')
  45         group = parser.add_argument_group('Optional arguments')
  46         group.add_argument('--osm2pgsql-cache', metavar='SIZE', type=int,
  47                            help='Size of cache to be used by osm2pgsql (in MB)')
  48         group.add_argument('--reverse-only', action='store_true',
  49                            help='Do not create tables and indexes for searching')
  50         group.add_argument('--no-partitions', action='store_true',
  51                            help=("Do not partition search indices "
  52                                  "(speeds up import of single country extracts)"))
  53         group.add_argument('--no-updates', action='store_true',
  54                            help="Do not keep tables that are only needed for "
  55                                 "updating the database later")
  56         group = parser.add_argument_group('Expert options')
  57         group.add_argument('--ignore-errors', action='store_true',
  58                            help='Continue import even when errors in SQL are present')
  59         group.add_argument('--index-noanalyse', action='store_true',
  60                            help='Do not perform analyse operations during index (expert only)')
  61
  62
  63     @staticmethod
  64     def run(args):
  65         from ..tools import database_import, refresh, postcodes, freeze, country_info
  66         from ..indexer.indexer import Indexer
  67
  68         country_info.setup_country_config(args.config)
  69
  70         if args.continue_at is None:
  71             files = args.get_osm_file_list()
  72
  73             LOG.warning('Creating database')
  74             database_import.setup_database_skeleton(args.config.get_libpq_dsn(),
  75                                                     rouser=args.config.DATABASE_WEBUSER)
  76
  77             LOG.warning('Setting up country tables')
  78             country_info.setup_country_tables(args.config.get_libpq_dsn(),
  79                                               args.data_dir,
  80                                               args.no_partitions)
  81
  82             LOG.warning('Importing OSM data file')
  83             database_import.import_osm_data(files,
  84                                             args.osm2pgsql_options(0, 1),
  85                                             drop=args.no_updates,
  86                                             ignore_errors=args.ignore_errors)
  87
  88             SetupAll._setup_tables(args.config, args.reverse_only)
  89
  90             LOG.warning('Importing wikipedia importance data')
  91             data_path = Path(args.config.WIKIPEDIA_DATA_PATH or args.project_dir)
  92             if refresh.import_wikipedia_articles(args.config.get_libpq_dsn(),
  93                                                  data_path) > 0:
  94                 LOG.error('Wikipedia importance dump file not found. '
  95                           'Will be using default importances.')
  96
  97         if args.continue_at is None or args.continue_at == 'load-data':
  98             LOG.warning('Initialise tables')
  99             with connect(args.config.get_libpq_dsn()) as conn:
 100                 database_import.truncate_data_tables(conn)
 101
 102             LOG.warning('Load data into placex table')
 103             database_import.load_data(args.config.get_libpq_dsn(),
 104                                       args.threads or psutil.cpu_count() or 1)
 105
 106         LOG.warning("Setting up tokenizer")
 107         tokenizer = SetupAll._get_tokenizer(args.continue_at, args.config)
 108
 109         if args.continue_at is None or args.continue_at == 'load-data':
 110             LOG.warning('Calculate postcodes')
 111             postcodes.update_postcodes(args.config.get_libpq_dsn(),
 112                                        args.project_dir, tokenizer)
 113
 114         if args.continue_at is None or args.continue_at in ('load-data', 'indexing'):
 115             if args.continue_at is not None and args.continue_at != 'load-data':
 116                 with connect(args.config.get_libpq_dsn()) as conn:
 117                     SetupAll._create_pending_index(conn, args.config.TABLESPACE_ADDRESS_INDEX)
 118             LOG.warning('Indexing places')
 119             indexer = Indexer(args.config.get_libpq_dsn(), tokenizer,
 120                               args.threads or psutil.cpu_count() or 1)
 121             indexer.index_full(analyse=not args.index_noanalyse)
 122
 123         LOG.warning('Post-process tables')
 124         with connect(args.config.get_libpq_dsn()) as conn:
 125             database_import.create_search_indices(conn, args.config,
 126                                                   drop=args.no_updates)
 127             LOG.warning('Create search index for default country names.')
 128             country_info.create_country_names(conn, tokenizer,
 129                                               args.config.LANGUAGES)
 130             if args.no_updates:
 131                 freeze.drop_update_tables(conn)
 132         tokenizer.finalize_import(args.config)
 133
 134         LOG.warning('Recompute word counts')
 135         tokenizer.update_statistics()
 136
 137         webdir = args.project_dir / 'website'
 138         LOG.warning('Setup website at %s', webdir)
 139         with connect(args.config.get_libpq_dsn()) as conn:
 140             refresh.setup_website(webdir, args.config, conn)
 141
 142         SetupAll._set_database_date(args.config.get_libpq_dsn())
 143
 144         return 0
 145
 146
 147     @staticmethod
 148     def _setup_tables(config, reverse_only):
 149         """ Set up the basic database layout: tables, indexes and functions.
 150         """
 151         from ..tools import database_import, refresh
 152
 153         with connect(config.get_libpq_dsn()) as conn:
 154             LOG.warning('Create functions (1st pass)')
 155             refresh.create_functions(conn, config, False, False)
 156             LOG.warning('Create tables')
 157             database_import.create_tables(conn, config, reverse_only=reverse_only)
 158             refresh.load_address_levels_from_config(conn, config)
 159             LOG.warning('Create functions (2nd pass)')
 160             refresh.create_functions(conn, config, False, False)
 161             LOG.warning('Create table triggers')
 162             database_import.create_table_triggers(conn, config)
 163             LOG.warning('Create partition tables')
 164             database_import.create_partition_tables(conn, config)
 165             LOG.warning('Create functions (3rd pass)')
 166             refresh.create_functions(conn, config, False, False)
 167
 168
 169     @staticmethod
 170     def _get_tokenizer(continue_at, config):
 171         """ Set up a new tokenizer or load an already initialised one.
 172         """
 173         from ..tokenizer import factory as tokenizer_factory
 174
 175         if continue_at is None or continue_at == 'load-data':
 176             # (re)initialise the tokenizer data
 177             return tokenizer_factory.create_tokenizer(config)
 178
 179         # just load the tokenizer
 180         return tokenizer_factory.get_tokenizer_for_db(config)
 181
 182     @staticmethod
 183     def _create_pending_index(conn, tablespace):
 184         """ Add a supporting index for finding places still to be indexed.
 185
 186             This index is normally created at the end of the import process
 187             for later updates. When indexing was partially done, then this
 188             index can greatly improve speed going through already indexed data.
 189         """
 190         if conn.index_exists('idx_placex_pendingsector'):
 191             return
 192
 193         with conn.cursor() as cur:
 194             LOG.warning('Creating support index')
 195             if tablespace:
 196                 tablespace = 'TABLESPACE ' + tablespace
 197             cur.execute(f"""CREATE INDEX idx_placex_pendingsector
 198                             ON placex USING BTREE (rank_address,geometry_sector)
 199                             {tablespace} WHERE indexed_status > 0
 200                          """)
 201         conn.commit()
 202
 203
 204     @staticmethod
 205     def _set_database_date(dsn):
 206         """ Determine the database date and set the status accordingly.
 207         """
 208         with connect(dsn) as conn:
 209             try:
 210                 dbdate = status.compute_database_date(conn)
 211                 status.set_status(conn, dbdate)
 212                 LOG.info('Database is at %s.', dbdate)
 213             except Exception as exc: # pylint: disable=broad-except
 214                 LOG.error('Cannot determine date of database: %s', exc)
 215
 216             properties.set_property(conn, 'database_version', version_str())