nominatim/clicmd/setup.py

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