src/nominatim_db/clicmd/setup.py

   1 # SPDX-License-Identifier: GPL-3.0-or-later
   2 #
   3 # This file is part of Nominatim. (https://nominatim.org)
   4 #
   5 # Copyright (C) 2024 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 from typing import Optional
  11 import argparse
  12 import logging
  13 from pathlib import Path
  14 import asyncio
  15
  16 import psutil
  17
  18 from ..errors import UsageError
  19 from ..config import Configuration
  20 from ..db.connection import connect
  21 from ..db import status, properties
  22 from ..tokenizer.base import AbstractTokenizer
  23 from ..version import NOMINATIM_VERSION
  24 from .args import NominatimArgs
  25
  26 # Do not repeat documentation of subcommand classes.
  27 # pylint: disable=C0111
  28 # Using non-top-level imports to avoid eventually unused imports.
  29 # pylint: disable=C0415
  30
  31 LOG = logging.getLogger()
  32
  33 class SetupAll:
  34     """\
  35     Create a new Nominatim database from an OSM file.
  36
  37     This sub-command sets up a new Nominatim database from scratch starting
  38     with creating a new database in Postgresql. The user running this command
  39     needs superuser rights on the database.
  40     """
  41
  42     def add_args(self, parser: argparse.ArgumentParser) -> None:
  43         group1 = parser.add_argument_group('Required arguments')
  44         group1.add_argument('--osm-file', metavar='FILE', action='append',
  45                            help='OSM file to be imported'
  46                                 ' (repeat for importing multiple files)',
  47                                 default=None)
  48         group1.add_argument('--continue', dest='continue_at',
  49                            choices=['import-from-file', 'load-data', 'indexing', 'db-postprocess'],
  50                            help='Continue an import that was interrupted',
  51                            default=None)
  52         group2 = parser.add_argument_group('Optional arguments')
  53         group2.add_argument('--osm2pgsql-cache', metavar='SIZE', type=int,
  54                            help='Size of cache to be used by osm2pgsql (in MB)')
  55         group2.add_argument('--reverse-only', action='store_true',
  56                            help='Do not create tables and indexes for searching')
  57         group2.add_argument('--no-partitions', action='store_true',
  58                            help=("Do not partition search indices "
  59                                  "(speeds up import of single country extracts)"))
  60         group2.add_argument('--no-updates', action='store_true',
  61                            help="Do not keep tables that are only needed for "
  62                                 "updating the database later")
  63         group2.add_argument('--offline', action='store_true',
  64                             help="Do not attempt to load any additional data from the internet")
  65         group3 = parser.add_argument_group('Expert options')
  66         group3.add_argument('--ignore-errors', action='store_true',
  67                            help='Continue import even when errors in SQL are present')
  68         group3.add_argument('--index-noanalyse', action='store_true',
  69                            help='Do not perform analyse operations during index (expert only)')
  70         group3.add_argument('--prepare-database', action='store_true',
  71                             help='Create the database but do not import any data')
  72
  73
  74     def run(self, args: NominatimArgs) -> int: # pylint: disable=too-many-statements, too-many-branches
  75         if args.osm_file is None and args.continue_at is None and not args.prepare_database:
  76             raise UsageError("No input files (use --osm-file).")
  77
  78         if args.osm_file is not None and args.continue_at not in ('import-from-file', None):
  79             raise UsageError(f"Cannot use --continue {args.continue_at} and --osm-file together.")
  80
  81         if args.continue_at is not None and args.prepare_database:
  82             raise UsageError(
  83                 "Cannot use --continue and --prepare-database together."
  84             )
  85
  86         return asyncio.run(self.async_run(args))
  87
  88
  89     async def async_run(self, args: NominatimArgs) -> int:
  90         from ..data import country_info
  91         from ..tools import database_import, refresh, postcodes, freeze
  92         from ..indexer.indexer import Indexer
  93
  94         num_threads = args.threads or psutil.cpu_count() or 1
  95         country_info.setup_country_config(args.config)
  96
  97         if args.prepare_database or args.continue_at is None:
  98             LOG.warning('Creating database')
  99             database_import.setup_database_skeleton(args.config.get_libpq_dsn(),
 100                                                         rouser=args.config.DATABASE_WEBUSER)
 101             if args.prepare_database:
 102                 return 0
 103
 104         if args.continue_at in (None, 'import-from-file'):
 105             self._base_import(args)
 106
 107         if args.continue_at in ('import-from-file', 'load-data', None):
 108             LOG.warning('Initialise tables')
 109             with connect(args.config.get_libpq_dsn()) as conn:
 110                 database_import.truncate_data_tables(conn)
 111
 112             LOG.warning('Load data into placex table')
 113             await database_import.load_data(args.config.get_libpq_dsn(), num_threads)
 114
 115         LOG.warning("Setting up tokenizer")
 116         tokenizer = self._get_tokenizer(args.continue_at, args.config)
 117
 118         if args.continue_at in ('import-from-file', 'load-data', None):
 119             LOG.warning('Calculate postcodes')
 120             postcodes.update_postcodes(args.config.get_libpq_dsn(),
 121                                        args.project_dir, tokenizer)
 122
 123         if args.continue_at in \
 124             ('import-from-file', 'load-data', 'indexing', None):
 125             LOG.warning('Indexing places')
 126             indexer = Indexer(args.config.get_libpq_dsn(), tokenizer, num_threads)
 127             await indexer.index_full(analyse=not args.index_noanalyse)
 128
 129         LOG.warning('Post-process tables')
 130         with connect(args.config.get_libpq_dsn()) as conn:
 131             await database_import.create_search_indices(conn, args.config,
 132                                                         drop=args.no_updates,
 133                                                         threads=num_threads)
 134             LOG.warning('Create search index for default country names.')
 135             country_info.create_country_names(conn, tokenizer,
 136                                               args.config.get_str_list('LANGUAGES'))
 137             if args.no_updates:
 138                 freeze.drop_update_tables(conn)
 139         tokenizer.finalize_import(args.config)
 140
 141         LOG.warning('Recompute word counts')
 142         tokenizer.update_statistics(args.config, threads=num_threads)
 143
 144         webdir = args.project_dir / 'website'
 145         LOG.warning('Setup website at %s', webdir)
 146         with connect(args.config.get_libpq_dsn()) as conn:
 147             refresh.setup_website(webdir, args.config, conn)
 148
 149         self._finalize_database(args.config.get_libpq_dsn(), args.offline)
 150
 151         return 0
 152
 153
 154     def _base_import(self, args: NominatimArgs) -> None:
 155         from ..tools import database_import, refresh
 156         from ..data import country_info
 157
 158         files = args.get_osm_file_list()
 159         if not files:
 160             raise UsageError("No input files (use --osm-file).")
 161
 162         if args.continue_at in ('import-from-file', None):
 163             # Check if the correct plugins are installed
 164             database_import.check_existing_database_plugins(args.config.get_libpq_dsn())
 165             LOG.warning('Setting up country tables')
 166             country_info.setup_country_tables(args.config.get_libpq_dsn(),
 167                                             args.config.lib_dir.data,
 168                                             args.no_partitions)
 169
 170             LOG.warning('Importing OSM data file')
 171             database_import.import_osm_data(files,
 172                                             args.osm2pgsql_options(0, 1),
 173                                             drop=args.no_updates,
 174                                             ignore_errors=args.ignore_errors)
 175
 176             LOG.warning('Importing wikipedia importance data')
 177             data_path = Path(args.config.WIKIPEDIA_DATA_PATH or args.project_dir)
 178             if refresh.import_wikipedia_articles(args.config.get_libpq_dsn(),
 179                                                 data_path) > 0:
 180                 LOG.error('Wikipedia importance dump file not found. '
 181                         'Calculating importance values of locations will not '
 182                         'use Wikipedia importance data.')
 183
 184             LOG.warning('Importing secondary importance raster data')
 185             if refresh.import_secondary_importance(args.config.get_libpq_dsn(),
 186                                                 args.project_dir) != 0:
 187                 LOG.error('Secondary importance file not imported. '
 188                         'Falling back to default ranking.')
 189
 190             self._setup_tables(args.config, args.reverse_only)
 191
 192
 193     def _setup_tables(self, config: Configuration, reverse_only: bool) -> None:
 194         """ Set up the basic database layout: tables, indexes and functions.
 195         """
 196         from ..tools import database_import, refresh
 197
 198         with connect(config.get_libpq_dsn()) as conn:
 199             LOG.warning('Create functions (1st pass)')
 200             refresh.create_functions(conn, config, False, False)
 201             LOG.warning('Create tables')
 202             database_import.create_tables(conn, config, reverse_only=reverse_only)
 203             refresh.load_address_levels_from_config(conn, config)
 204             LOG.warning('Create functions (2nd pass)')
 205             refresh.create_functions(conn, config, False, False)
 206             LOG.warning('Create table triggers')
 207             database_import.create_table_triggers(conn, config)
 208             LOG.warning('Create partition tables')
 209             database_import.create_partition_tables(conn, config)
 210             LOG.warning('Create functions (3rd pass)')
 211             refresh.create_functions(conn, config, False, False)
 212
 213
 214     def _get_tokenizer(self, continue_at: Optional[str],
 215                        config: Configuration) -> AbstractTokenizer:
 216         """ Set up a new tokenizer or load an already initialised one.
 217         """
 218         from ..tokenizer import factory as tokenizer_factory
 219
 220         if continue_at in ('import-from-file', 'load-data', None):
 221             # (re)initialise the tokenizer data
 222             return tokenizer_factory.create_tokenizer(config)
 223
 224         # just load the tokenizer
 225         return tokenizer_factory.get_tokenizer_for_db(config)
 226
 227
 228     def _finalize_database(self, dsn: str, offline: bool) -> None:
 229         """ Determine the database date and set the status accordingly.
 230         """
 231         with connect(dsn) as conn:
 232             properties.set_property(conn, 'database_version', str(NOMINATIM_VERSION))
 233
 234             try:
 235                 dbdate = status.compute_database_date(conn, offline)
 236                 status.set_status(conn, dbdate)
 237                 LOG.info('Database is at %s.', dbdate)
 238             except Exception as exc: # pylint: disable=broad-except
 239                 LOG.error('Cannot determine date of database: %s', exc)