nominatim/db/connection.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 Specialised connection and cursor functions.
   9 """
  10 from typing import List, Optional, Any, Callable, ContextManager, Dict, cast, overload, Tuple
  11 import contextlib
  12 import logging
  13 import os
  14
  15 import psycopg2
  16 import psycopg2.extensions
  17 import psycopg2.extras
  18 from psycopg2 import sql as pysql
  19
  20 from nominatim.typing import SysEnv, Query, T_cursor
  21 from nominatim.errors import UsageError
  22
  23 LOG = logging.getLogger()
  24
  25 class Cursor(psycopg2.extras.DictCursor):
  26     """ A cursor returning dict-like objects and providing specialised
  27         execution functions.
  28     """
  29     # pylint: disable=arguments-renamed,arguments-differ
  30     def execute(self, query: Query, args: Any = None) -> None:
  31         """ Query execution that logs the SQL query when debugging is enabled.
  32         """
  33         if LOG.isEnabledFor(logging.DEBUG):
  34             LOG.debug(self.mogrify(query, args).decode('utf-8')) # type: ignore[no-untyped-call]
  35
  36         super().execute(query, args)
  37
  38
  39     def execute_values(self, sql: Query, argslist: List[Any],
  40                        template: Optional[str] = None) -> None:
  41         """ Wrapper for the psycopg2 convenience function to execute
  42             SQL for a list of values.
  43         """
  44         LOG.debug("SQL execute_values(%s, %s)", sql, argslist)
  45
  46         psycopg2.extras.execute_values(self, sql, argslist, template=template)
  47
  48
  49     def scalar(self, sql: Query, args: Any = None) -> Any:
  50         """ Execute query that returns a single value. The value is returned.
  51             If the query yields more than one row, a ValueError is raised.
  52         """
  53         self.execute(sql, args)
  54
  55         if self.rowcount != 1:
  56             raise RuntimeError("Query did not return a single row.")
  57
  58         result = self.fetchone() # type: ignore[no-untyped-call]
  59         assert result is not None
  60
  61         return result[0]
  62
  63
  64     def drop_table(self, name: str, if_exists: bool = True, cascade: bool = False) -> None:
  65         """ Drop the table with the given name.
  66             Set `if_exists` to False if a non-existant table should raise
  67             an exception instead of just being ignored. If 'cascade' is set
  68             to True then all dependent tables are deleted as well.
  69         """
  70         sql = 'DROP TABLE '
  71         if if_exists:
  72             sql += 'IF EXISTS '
  73         sql += '{}'
  74         if cascade:
  75             sql += ' CASCADE'
  76
  77         self.execute(pysql.SQL(sql).format(pysql.Identifier(name)))
  78
  79
  80 class Connection(psycopg2.extensions.connection):
  81     """ A connection that provides the specialised cursor by default and
  82         adds convenience functions for administrating the database.
  83     """
  84     @overload # type: ignore[override]
  85     def cursor(self) -> Cursor:
  86         ...
  87
  88     @overload
  89     def cursor(self, name: str) -> Cursor:
  90         ...
  91
  92     @overload
  93     def cursor(self, cursor_factory: Callable[..., T_cursor]) -> T_cursor:
  94         ...
  95
  96     def cursor(self, cursor_factory  = Cursor, **kwargs): # type: ignore
  97         """ Return a new cursor. By default the specialised cursor is returned.
  98         """
  99         return super().cursor(cursor_factory=cursor_factory, **kwargs)
 100
 101
 102     def table_exists(self, table: str) -> bool:
 103         """ Check that a table with the given name exists in the database.
 104         """
 105         with self.cursor() as cur:
 106             num = cur.scalar("""SELECT count(*) FROM pg_tables
 107                                 WHERE tablename = %s and schemaname = 'public'""", (table, ))
 108             return num == 1 if isinstance(num, int) else False
 109
 110
 111     def table_has_column(self, table: str, column: str) -> bool:
 112         """ Check if the table 'table' exists and has a column with name 'column'.
 113         """
 114         with self.cursor() as cur:
 115             has_column = cur.scalar("""SELECT count(*) FROM information_schema.columns
 116                                        WHERE table_name = %s
 117                                              and column_name = %s""",
 118                                     (table, column))
 119             return has_column > 0 if isinstance(has_column, int) else False
 120
 121
 122     def index_exists(self, index: str, table: Optional[str] = None) -> bool:
 123         """ Check that an index with the given name exists in the database.
 124             If table is not None then the index must relate to the given
 125             table.
 126         """
 127         with self.cursor() as cur:
 128             cur.execute("""SELECT tablename FROM pg_indexes
 129                            WHERE indexname = %s and schemaname = 'public'""", (index, ))
 130             if cur.rowcount == 0:
 131                 return False
 132
 133             if table is not None:
 134                 row = cur.fetchone() # type: ignore[no-untyped-call]
 135                 if row is None or not isinstance(row[0], str):
 136                     return False
 137                 return row[0] == table
 138
 139         return True
 140
 141
 142     def drop_table(self, name: str, if_exists: bool = True, cascade: bool = False) -> None:
 143         """ Drop the table with the given name.
 144             Set `if_exists` to False if a non-existant table should raise
 145             an exception instead of just being ignored.
 146         """
 147         with self.cursor() as cur:
 148             cur.drop_table(name, if_exists, cascade)
 149         self.commit()
 150
 151
 152     def server_version_tuple(self) -> Tuple[int, int]:
 153         """ Return the server version as a tuple of (major, minor).
 154             Converts correctly for pre-10 and post-10 PostgreSQL versions.
 155         """
 156         version = self.server_version
 157         if version < 100000:
 158             return (int(version / 10000), int((version % 10000) / 100))
 159
 160         return (int(version / 10000), version % 10000)
 161
 162
 163     def postgis_version_tuple(self) -> Tuple[int, int]:
 164         """ Return the postgis version installed in the database as a
 165             tuple of (major, minor). Assumes that the PostGIS extension
 166             has been installed already.
 167         """
 168         with self.cursor() as cur:
 169             version = cur.scalar('SELECT postgis_lib_version()')
 170
 171         version_parts = version.split('.')
 172         if len(version_parts) < 2:
 173             raise UsageError(f"Error fetching Postgis version. Bad format: {version}")
 174
 175         return (int(version_parts[0]), int(version_parts[1]))
 176
 177 class ConnectionContext(ContextManager[Connection]):
 178     """ Context manager of the connection that also provides direct access
 179         to the underlying connection.
 180     """
 181     connection: Connection
 182
 183 def connect(dsn: str) -> ConnectionContext:
 184     """ Open a connection to the database using the specialised connection
 185         factory. The returned object may be used in conjunction with 'with'.
 186         When used outside a context manager, use the `connection` attribute
 187         to get the connection.
 188     """
 189     try:
 190         conn = psycopg2.connect(dsn, connection_factory=Connection)
 191         ctxmgr = cast(ConnectionContext, contextlib.closing(conn))
 192         ctxmgr.connection = cast(Connection, conn)
 193         return ctxmgr
 194     except psycopg2.OperationalError as err:
 195         raise UsageError(f"Cannot connect to database: {err}") from err
 196
 197
 198 # Translation from PG connection string parameters to PG environment variables.
 199 # Derived from https://www.postgresql.org/docs/current/libpq-envars.html.
 200 _PG_CONNECTION_STRINGS = {
 201     'host': 'PGHOST',
 202     'hostaddr': 'PGHOSTADDR',
 203     'port': 'PGPORT',
 204     'dbname': 'PGDATABASE',
 205     'user': 'PGUSER',
 206     'password': 'PGPASSWORD',
 207     'passfile': 'PGPASSFILE',
 208     'channel_binding': 'PGCHANNELBINDING',
 209     'service': 'PGSERVICE',
 210     'options': 'PGOPTIONS',
 211     'application_name': 'PGAPPNAME',
 212     'sslmode': 'PGSSLMODE',
 213     'requiressl': 'PGREQUIRESSL',
 214     'sslcompression': 'PGSSLCOMPRESSION',
 215     'sslcert': 'PGSSLCERT',
 216     'sslkey': 'PGSSLKEY',
 217     'sslrootcert': 'PGSSLROOTCERT',
 218     'sslcrl': 'PGSSLCRL',
 219     'requirepeer': 'PGREQUIREPEER',
 220     'ssl_min_protocol_version': 'PGSSLMINPROTOCOLVERSION',
 221     'ssl_max_protocol_version': 'PGSSLMAXPROTOCOLVERSION',
 222     'gssencmode': 'PGGSSENCMODE',
 223     'krbsrvname': 'PGKRBSRVNAME',
 224     'gsslib': 'PGGSSLIB',
 225     'connect_timeout': 'PGCONNECT_TIMEOUT',
 226     'target_session_attrs': 'PGTARGETSESSIONATTRS',
 227 }
 228
 229
 230 def get_pg_env(dsn: str,
 231                base_env: Optional[SysEnv] = None) -> Dict[str, str]:
 232     """ Return a copy of `base_env` with the environment variables for
 233         PostgresSQL set up from the given database connection string.
 234         If `base_env` is None, then the OS environment is used as a base
 235         environment.
 236     """
 237     env = dict(base_env if base_env is not None else os.environ)
 238
 239     for param, value in psycopg2.extensions.parse_dsn(dsn).items(): # type: ignore
 240         if param in _PG_CONNECTION_STRINGS:
 241             env[_PG_CONNECTION_STRINGS[param]] = value
 242         else:
 243             LOG.error("Unknown connection parameter '%s' ignored.", param)
 244
 245     return env