Merge pull request #1788 from joto/database-check-helper

Better error messages when extension/schema/tablespace is missing

Author: lonvia

src/CMakeLists.txt

@@ -26,6 +26,7 @@ target_sources(osm2pgsql_lib PRIVATE
   output-pgsql.cpp
   output.cpp
   pgsql.cpp
+  pgsql-capabilities.cpp
   pgsql-helper.cpp
   progress-display.cpp
   reprojection.cpp

src/flex-table.cpp

@@ -10,6 +10,7 @@
 #include "flex-table.hpp"
 #include "format.hpp"
 #include "logging.hpp"
+#include "pgsql-capabilities.hpp"
 #include "pgsql-helper.hpp"
 #include "util.hpp"
 
@@ -189,6 +190,30 @@ void table_connection_t::start(bool append)
 {
     assert(m_db_connection);
 
+    if (!has_schema(*m_db_connection, table().schema())) {
+        throw std::runtime_error{
+            "Schema '{0}' not available. "
+            "Use 'CREATE SCHEMA \"{0}\";' to create it."_format(
+                table().schema())};
+    }
+
+    for (auto const &ts :
+         {table().data_tablespace(), table().index_tablespace()}) {
+        if (!has_tablespace(*m_db_connection, ts)) {
+            throw std::runtime_error{
+                "Tablespace '{0}' not available. "
+                "Use 'CREATE TABLESPACE \"{0}\" ...;' to create it."_format(
+                    ts)};
+        }
+    }
+
+    if (table().has_hstore_column()) {
+        if (!has_extension(*m_db_connection, "hstore")) {
+            throw std::runtime_error{"Extension 'hstore' not available. Use "
+                                     "'CREATE EXTENSION hstore;' to load it."};
+        }
+    }
+
     m_db_connection->exec("SET client_min_messages = WARNING");
 
     if (!append) {

src/flex-table.hpp

@@ -110,6 +110,14 @@ class flex_table_t
         return m_geom_column != std::numeric_limits<std::size_t>::max();
     }
 
+    bool has_hstore_column() const noexcept
+    {
+        auto const it = std::find_if(begin(), end(), [&](auto const &column) {
+            return column.type() == table_column_type::hstore;
+        });
+        return it != end();
+    }
+
     /// Get the (first, if there are multiple) geometry column.
     flex_table_column_t const &geom_column() const noexcept
     {

src/pgsql-capabilities.cpp

@@ -0,0 +1,66 @@
+/**
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * This file is part of osm2pgsql (https://osm2pgsql.org/).
+ *
+ * Copyright (C) 2006-2022 by the osm2pgsql developer community.
+ * For a full list of authors see the git log.
+ */
+
+#include "format.hpp"
+#include "pgsql.hpp"
+#include "pgsql-helper.hpp"
+
+#include <set>
+#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)
+{
+    std::set<std::string> values;
+
+    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));
+    }
+
+    return values;
+}
+
+bool has_extension(pg_conn_t const &db_connection, std::string const &value)
+{
+    static const std::set<std::string> values = init_set_from_table(
+        db_connection, "pg_catalog.pg_extension", "extname", "true");
+
+    return values.count(value);
+}
+
+bool has_schema(pg_conn_t const &db_connection, std::string const &value)
+{
+    static const std::set<std::string> values = init_set_from_table(
+        db_connection, "pg_catalog.pg_namespace", "nspname",
+        "nspname !~ '^pg_' AND nspname <> 'information_schema'");
+
+    if (value.empty()) {
+        return true;
+    }
+
+    return values.count(value);
+}
+
+bool has_tablespace(pg_conn_t const &db_connection, std::string const &value)
+{
+    static const std::set<std::string> values =
+        init_set_from_table(db_connection, "pg_catalog.pg_tablespace",
+                            "spcname", "spcname != 'pg_global'");
+
+    if (value.empty()) {
+        return true;
+    }
+
+    return values.count(value);
+}

src/pgsql-capabilities.hpp

@@ -0,0 +1,21 @@
+#ifndef OSM2PGSQL_PGSQL_CAPABILITIES_HPP
+#define OSM2PGSQL_PGSQL_CAPABILITIES_HPP
+
+/**
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * This file is part of osm2pgsql (https://osm2pgsql.org/).
+ *
+ * Copyright (C) 2006-2022 by the osm2pgsql developer community.
+ * For a full list of authors see the git log.
+ */
+
+#include "pgsql.hpp"
+
+#include <string>
+
+bool has_extension(pg_conn_t const &db_connection, std::string const &value);
+bool has_schema(pg_conn_t const &db_connection, std::string const &value);
+bool has_tablespace(pg_conn_t const &db_connection, std::string const &value);
+
+#endif // OSM2PGSQL_PGSQL_CAPABILITIES_HPP

tests/CMakeLists.txt

@@ -72,6 +72,7 @@ set_test(test-output-pgsql-z_order)
 set_test(test-parse-osmium LABELS NoDB)
 set_test(test-persistent-cache LABELS NoDB)
 set_test(test-pgsql)
+set_test(test-pgsql-capabilities)
 set_test(test-reprojection LABELS NoDB)
 set_test(test-taginfo LABELS NoDB)
 set_test(test-tile LABELS NoDB)

tests/test-pgsql-capabilities.cpp

@@ -0,0 +1,39 @@
+/**
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * This file is part of osm2pgsql (https://osm2pgsql.org/).
+ *
+ * Copyright (C) 2006-2022 by the osm2pgsql developer community.
+ * For a full list of authors see the git log.
+ */
+
+#include <catch.hpp>
+
+#include "common-import.hpp"
+
+#include "pgsql-capabilities.hpp"
+
+static testing::db::import_t const db;
+
+TEST_CASE("has_extension() should work")
+{
+    auto const conn = db.db().connect();
+    REQUIRE(has_extension(conn, "postgis"));
+    REQUIRE_FALSE(has_schema(conn, "xzxzxzxz"));
+}
+
+TEST_CASE("has_schema() should work")
+{
+    auto const conn = db.db().connect();
+    REQUIRE(has_schema(conn, "public"));
+    REQUIRE_FALSE(has_schema(conn, "xzxzxzxz"));
+    REQUIRE_FALSE(has_schema(conn, "pg_toast"));
+}
+
+TEST_CASE("has_tablespace() should work")
+{
+    auto const conn = db.db().connect();
+    REQUIRE(has_tablespace(conn, "pg_default"));
+    REQUIRE_FALSE(has_tablespace(conn, "xzxzxzxz"));
+    REQUIRE_FALSE(has_tablespace(conn, "pg_global"));
+}