Consolidate database capability checks

There were several places (pgsql.hpp, pgsql-capabilities.hpp,
db-check.hpp) that had code to check various capabilities, version
numbers etc. of the database we are connected to. This is now
consolidated in pgsql-capabilities.hpp. It needs to be initialized once
at program start by calling init_database_capabilities() with a database
connection object. Checking version numbers or capabilities is then much
easier, because no active database connection is needed any more.

This also adds code to get the list of supported index methods from the
database which we will need shortly. (Only works with PostgreSQL >9.5.)

Author: joto

src/CMakeLists.txt

@@ -2,7 +2,6 @@
 add_library(osm2pgsql_lib STATIC)
 
 target_sources(osm2pgsql_lib PRIVATE
-  db-check.cpp
   db-copy.cpp
   dependency-manager.cpp
   expire-tiles.cpp

src/db-check.cpp

@@ -258,7 +258,7 @@ void table_connection_t::start(bool append)
 {
     assert(m_db_connection);
 
-    if (!has_schema(*m_db_connection, table().schema())) {
+    if (!has_schema(table().schema())) {
         throw std::runtime_error{
             "Schema '{0}' not available. "
             "Use 'CREATE SCHEMA \"{0}\";' to create it."_format(
@@ -267,7 +267,7 @@ void table_connection_t::start(bool append)
 
     for (auto const &ts :
          {table().data_tablespace(), table().index_tablespace()}) {
-        if (!has_tablespace(*m_db_connection, ts)) {
+        if (!has_tablespace(ts)) {
             throw std::runtime_error{
                 "Tablespace '{0}' not available. "
                 "Use 'CREATE TABLESPACE \"{0}\" ...;' to create it."_format(
@@ -276,7 +276,7 @@ void table_connection_t::start(bool append)
     }
 
     if (table().has_hstore_column()) {
-        if (!has_extension(*m_db_connection, "hstore")) {
+        if (!has_extension("hstore")) {
             throw std::runtime_error{"Extension 'hstore' not available. Use "
                                      "'CREATE EXTENSION hstore;' to load it."};
         }
@@ -336,7 +336,7 @@ void table_connection_t::stop(bool updateable, bool append)
         std::string sql = "INSERT INTO {} ({}) SELECT {} FROM {}"_format(
             table().full_tmp_name(), columns, columns, table().full_name());
 
-        auto const postgis_version = get_postgis_version(*m_db_connection);
+        auto const postgis_version = get_postgis_version();
 
         sql += " ORDER BY ";
         if (postgis_version.major == 2 && postgis_version.minor < 4) {

src/db-check.hpp

@@ -7,14 +7,16 @@
  * For a full list of authors see the git log.
  */
 
-#include "db-check.hpp"
 #include "dependency-manager.hpp"
 #include "input.hpp"
 #include "logging.hpp"
 #include "middle.hpp"
 #include "options.hpp"
 #include "osmdata.hpp"
 #include "output.hpp"
+#include "pgsql.hpp"
+#include "pgsql-capabilities.hpp"
+#include "pgsql-helper.hpp"
 #include "util.hpp"
 #include "version.hpp"
 
@@ -76,6 +78,26 @@ static void run(options_t const &options)
     osmdata.stop();
 }
 
+void check_db(options_t const &options)
+{
+    pg_conn_t db_connection{options.conninfo};
+
+    init_database_capabilities(db_connection);
+
+    // If we are in append mode and the middle nodes table isn't there,
+    // it probably means we used a flat node store when we created this
+    // database. Check for that and stop if it looks like we are missing
+    // the node location store option.
+    if (options.append && options.flat_node_file.empty()) {
+        if (!has_table(db_connection, options.middle_dbschema,
+                        options.prefix + "_nodes")) {
+            throw std::runtime_error{
+                "You seem to not have a nodes table. Did "
+                "you forget the --flat-nodes option?"};
+        }
+    }
+}
+
 int main(int argc, char *argv[])
 {
     try {

src/flex-table.cpp

@@ -8,59 +8,169 @@
  */
 
 #include "format.hpp"
+#include "logging.hpp"
+#include "pgsql-capabilities.hpp"
 #include "pgsql.hpp"
-#include "pgsql-helper.hpp"
+#include "version.hpp"
 
+#include <map>
 #include <set>
+#include <stdexcept>
 #include <string>
 
-static std::set<std::string> init_set_from_table(pg_conn_t const &db_connection,
-                                                 char const *table,
-                                                 char const *column,
-                                                 char const *condition)
+struct database_capabilities_t
 {
-    std::set<std::string> values;
+    std::map<std::string, std::string> settings;
 
+    std::set<std::string> extensions;
+    std::set<std::string> schemas;
+    std::set<std::string> tablespaces;
+    std::set<std::string> index_methods;
+
+    std::string database_name;
+
+    uint32_t database_version = 0;
+    postgis_version postgis{};
+};
+
+static database_capabilities_t &capabilities() noexcept
+{
+    static database_capabilities_t c;
+    return c;
+}
+
+static void init_set_from_query(std::set<std::string> *set,
+                                pg_conn_t const &db_connection,
+                                char const *table, char const *column,
+                                char const *condition = "true")
+{
     auto const res = db_connection.query(
         PGRES_TUPLES_OK,
         "SELECT {} FROM {} WHERE {}"_format(column, table, condition));
     for (int i = 0; i < res.num_tuples(); ++i) {
-        values.insert(res.get_value_as_string(i, 0));
+        set->insert(res.get_value_as_string(i, 0));
     }
+}
+
+/// Get all config settings from the database.
+static void init_settings(pg_conn_t const &db_connection)
+{
+    auto const res = db_connection.query(
+        PGRES_TUPLES_OK, "SELECT name, setting FROM pg_settings");
 
-    return values;
+    for (int i = 0; i < res.num_tuples(); ++i) {
+        capabilities().settings.emplace(res.get_value_as_string(i, 0),
+                                        res.get_value_as_string(i, 1));
+    }
 }
 
-bool has_extension(pg_conn_t const &db_connection, std::string const &value)
+static void init_database_name(pg_conn_t const &db_connection)
 {
-    static const std::set<std::string> values = init_set_from_table(
-        db_connection, "pg_catalog.pg_extension", "extname", "true");
+    auto const res =
+        db_connection.query(PGRES_TUPLES_OK, "SELECT current_catalog");
+
+    if (res.num_tuples() != 1) {
+        throw std::runtime_error{
+            "Database error: Can not access database name."};
+    }
 
-    return values.count(value);
+    capabilities().database_name = res.get_value_as_string(0, 0);
 }
 
-bool has_schema(pg_conn_t const &db_connection, std::string const &value)
+static void init_postgis_version(pg_conn_t const &db_connection)
 {
-    static const std::set<std::string> values = init_set_from_table(
-        db_connection, "pg_catalog.pg_namespace", "nspname",
-        "nspname !~ '^pg_' AND nspname <> 'information_schema'");
+    auto const res = db_connection.query(
+        PGRES_TUPLES_OK, "SELECT regexp_split_to_table(extversion, '\\.') FROM"
+                         " pg_extension WHERE extname='postgis'");
 
-    if (value.empty()) {
-        return true;
+    if (res.num_tuples() == 0) {
+        throw std::runtime_error{
+            "The postgis extension is not enabled on the database '{}'."
+            " Are you using the correct database?"
+            " Enable with 'CREATE EXTENSION postgis;'"_format(
+                capabilities().database_name)};
     }
 
-    return values.count(value);
+    capabilities().postgis = {std::stoi(res.get_value_as_string(0, 0)),
+                              std::stoi(res.get_value_as_string(1, 0))};
 }
 
-bool has_tablespace(pg_conn_t const &db_connection, std::string const &value)
+void init_database_capabilities(pg_conn_t const &db_connection)
 {
-    static const std::set<std::string> values =
-        init_set_from_table(db_connection, "pg_catalog.pg_tablespace",
-                            "spcname", "spcname != 'pg_global'");
+    init_settings(db_connection);
+    init_database_name(db_connection);
+    init_postgis_version(db_connection);
+
+    try {
+        log_info("Database version: {}",
+                 capabilities().settings.at("server_version"));
+        log_info("PostGIS version: {}.{}", capabilities().postgis.major,
+                 capabilities().postgis.minor);
+
+        auto const version_str =
+            capabilities().settings.at("server_version_num");
+        capabilities().database_version =
+            std::strtoul(version_str.c_str(), nullptr, 10);
+        if (capabilities().database_version <
+            get_minimum_postgresql_server_version_num()) {
+            throw std::runtime_error{
+                "Your database version is too old (need at least {})."_format(
+                    get_minimum_postgresql_server_version())};
+        }
 
+        if (capabilities().settings.at("server_encoding") != "UTF8") {
+            throw std::runtime_error{"Database is not using UTF8 encoding."};
+        }
+
+    } catch (std::out_of_range const &) {
+        // Thrown by the settings.at() if the named setting isn't found
+        throw std::runtime_error{"Can't access database setting."};
+    }
+
+    init_set_from_query(&capabilities().extensions, db_connection,
+                        "pg_catalog.pg_extension", "extname");
+    init_set_from_query(
+        &capabilities().schemas, db_connection, "pg_catalog.pg_namespace",
+        "nspname", "nspname !~ '^pg_' AND nspname <> 'information_schema'");
+    init_set_from_query(&capabilities().tablespaces, db_connection,
+                        "pg_catalog.pg_tablespace", "spcname",
+                        "spcname != 'pg_global'");
+    init_set_from_query(&capabilities().index_methods, db_connection,
+                        "pg_catalog.pg_am", "amname", "amtype = 'i'");
+}
+
+bool has_extension(std::string const &value)
+{
+    return capabilities().extensions.count(value);
+}
+
+bool has_schema(std::string const &value)
+{
     if (value.empty()) {
         return true;
     }
+    return capabilities().schemas.count(value);
+}
 
-    return values.count(value);
+bool has_tablespace(std::string const &value)
+{
+    if (value.empty()) {
+        return true;
+    }
+    return capabilities().tablespaces.count(value);
+}
+
+bool has_index_method(std::string const &value)
+{
+    return capabilities().index_methods.count(value);
+}
+
+uint32_t get_database_version() noexcept
+{
+    return capabilities().database_version;
+}
+
+postgis_version get_postgis_version() noexcept
+{
+    return capabilities().postgis;
 }