Refactor db_target_descr_t: Always need schema on construction

We now always construct this fully with schema, name, and id column.
This way we make sure all data is there and the schema is not defaulted.

Author: joto

src/db-copy.hpp

@@ -10,6 +10,7 @@
  * For a full list of authors see the git log.
  */
 
+#include <cassert>
 #include <condition_variable>
 #include <deque>
 #include <future>
@@ -29,7 +30,7 @@
 struct db_target_descr_t
 {
     /// Schema of the target table.
-    std::string schema{"public"};
+    std::string schema;
     /// Name of the target table for the copy operation.
     std::string name;
     /// Name of id column used when deleting objects.
@@ -46,11 +47,15 @@ struct db_target_descr_t
                                     name == other.name && rows == other.rows);
     }
 
-    db_target_descr_t() = default;
+    db_target_descr_t() = delete;
 
-    db_target_descr_t(std::string n, std::string i, std::string r = {})
-    : name(std::move(n)), id(std::move(i)), rows(std::move(r))
-    {}
+    db_target_descr_t(std::string s, std::string n, std::string i,
+                      std::string r = {})
+    : schema(std::move(s)), name(std::move(n)), id(std::move(i)),
+      rows(std::move(r))
+    {
+        assert(!schema.empty());
+    }
 };
 
 /**

src/flex-table.hpp

@@ -250,11 +250,10 @@ class table_connection_t
                        std::shared_ptr<db_copy_thread_t> const &copy_thread)
     : m_proj(reprojection::create_projection(table->srid())), m_table(table),
       m_target(std::make_shared<db_target_descr_t>(
-          table->name(), table->id_column_names(),
+          table->schema(), table->name(), table->id_column_names(),
           table->build_sql_column_list())),
       m_copy_mgr(copy_thread), m_db_connection(nullptr)
     {
-        m_target->schema = table->schema();
     }
 
     void connect(std::string const &conninfo);

src/gazetteer-style.hpp

@@ -86,8 +86,10 @@ class gazetteer_copy_mgr_t : public db_copy_mgr_t<db_deleter_place_t>
     explicit gazetteer_copy_mgr_t(
         std::shared_ptr<db_copy_thread_t> const &processor)
     : db_copy_mgr_t<db_deleter_place_t>(processor),
-      m_table(std::make_shared<db_target_descr_t>("place", "place_id"))
-    {}
+      m_table(
+          std::make_shared<db_target_descr_t>("public", "place", "place_id"))
+    {
+    }
 
     void prepare() { new_line(m_table); }
 

src/middle-pgsql.cpp

@@ -132,12 +132,9 @@ middle_pgsql_t::table_desc::table_desc(options_t const &options,
                                        table_sql const &ts)
 : m_create_table(build_sql(options, ts.create_table)),
   m_prepare_queries(build_sql(options, ts.prepare_queries)),
-  m_copy_target(std::make_shared<db_target_descr_t>())
+  m_copy_target(std::make_shared<db_target_descr_t>(
+      options.middle_dbschema, build_sql(options, ts.name), "id"))
 {
-    m_copy_target->name = build_sql(options, ts.name);
-    m_copy_target->schema = options.middle_dbschema;
-    m_copy_target->id = "id";
-
     if (options.with_forward_dependencies) {
         m_create_fw_dep_indexes = build_sql(options, ts.create_fw_dep_indexes);
     }
@@ -1324,9 +1321,8 @@ void middle_pgsql_t::write_users_table()
 {
     log_info("Writing {} entries to table '{}'...", m_users.size(),
              m_users_table.name());
-    auto const users_table =
-        std::make_shared<db_target_descr_t>(m_users_table.name(), "id");
-    users_table->schema = m_users_table.schema();
+    auto const users_table = std::make_shared<db_target_descr_t>(
+        m_users_table.schema(), m_users_table.name(), "id");
 
     for (auto const &[id, name] : m_users) {
         m_db_copy.new_line(users_table);

src/table.cpp

@@ -30,14 +30,11 @@ table_t::table_t(std::string const &name, std::string type, columns_t columns,
                  hstore_column hstore_mode,
                  std::shared_ptr<db_copy_thread_t> const &copy_thread,
                  std::string const &schema)
-: m_target(std::make_shared<db_target_descr_t>(name.c_str(), "osm_id")),
+: m_target(std::make_shared<db_target_descr_t>(schema, name, "osm_id")),
   m_type(std::move(type)), m_srid(fmt::to_string(srid)), m_append(append),
   m_hstore_mode(hstore_mode), m_columns(std::move(columns)),
   m_hstore_columns(std::move(hstore_columns)), m_copy(copy_thread)
 {
-    assert(!schema.empty());
-    m_target->schema = schema;
-
     // if we dont have any columns
     if (m_columns.empty() && m_hstore_mode != hstore_column::all) {
         throw fmt_error("No columns provided for table {}.", name);

tests/test-db-copy-mgr.cpp

@@ -27,9 +27,8 @@ static std::shared_ptr<db_target_descr_t> setup_table(std::string const &cols)
     conn.exec("CREATE TABLE test_copy_mgr (id int8{}{})",
               cols.empty() ? "" : ",", cols);
 
-    auto table = std::make_shared<db_target_descr_t>();
-    table->name = "test_copy_mgr";
-    table->id = "id";
+    auto table =
+        std::make_shared<db_target_descr_t>("public", "test_copy_mgr", "id");
 
     return table;
 }

tests/test-db-copy-thread.cpp

@@ -27,9 +27,8 @@ TEST_CASE("db_copy_thread_t with db_deleter_by_id_t")
     conn.exec("DROP TABLE IF EXISTS test_copy_thread");
     conn.exec("CREATE TABLE test_copy_thread (id int8)");
 
-    auto const table = std::make_shared<db_target_descr_t>();
-    table->name = "test_copy_thread";
-    table->id = "id";
+    auto const table =
+        std::make_shared<db_target_descr_t>("public", "test_copy_thread", "id");
 
     db_copy_thread_t t(db.conninfo());
     using cmd_copy_t = db_cmd_copy_delete_t<db_deleter_by_id_t>;
@@ -157,9 +156,8 @@ TEST_CASE("db_copy_thread_t with db_deleter_place_t")
               "osm_id bigint,"
               "class text)");
 
-    auto table = std::make_shared<db_target_descr_t>();
-    table->name = "test_copy_thread";
-    table->id = "place_id";
+    auto table = std::make_shared<db_target_descr_t>(
+        "public", "test_copy_thread", "place_id");
 
     db_copy_thread_t t(db.conninfo());
     using cmd_copy_t = db_cmd_copy_delete_t<db_deleter_place_t>;