[perf] Only copy tags to old tables for ids that are known to have tags

include/cgimap/backend/apidb/changeset_upload/node_updater.hpp

@@ -99,7 +99,7 @@ class ApiDB_Node_Updater : public api06::Node_Updater {
 
   void delete_current_nodes(const std::vector<node_t> &nodes);
 
-  void insert_new_current_node_tags(const std::vector<node_t> &nodes);
+  [[nodiscard]] std::vector<osm_nwr_id_t> insert_new_current_node_tags(const std::vector<node_t> &nodes);
 
   void save_current_nodes_to_history(const std::vector<osm_nwr_id_t> &ids);
 

include/cgimap/backend/apidb/changeset_upload/relation_updater.hpp

@@ -152,7 +152,7 @@ class ApiDB_Relation_Updater : public api06::Relation_Updater {
   void update_current_relations(const std::vector<relation_t> &relations,
                                 bool visible);
 
-  void
+  [[nodiscard]] std::vector<osm_nwr_id_t>
   insert_new_current_relation_tags(const std::vector<relation_t> &relations);
 
   void

include/cgimap/backend/apidb/changeset_upload/way_updater.hpp

@@ -115,7 +115,7 @@ class ApiDB_Way_Updater : public api06::Way_Updater {
 
   void update_current_ways(const std::vector<way_t> &ways, bool visible);
 
-  void insert_new_current_way_tags(const std::vector<way_t> &ways);
+  [[nodiscard]] std::vector<osm_nwr_id_t> insert_new_current_way_tags(const std::vector<way_t> &ways);
 
   void insert_new_current_way_nodes(const std::vector<way_t> &ways);
 

src/backend/apidb/changeset_upload/node_updater.cpp

@@ -124,9 +124,9 @@ void ApiDB_Node_Updater::process_new_nodes() {
 
   lock_current_nodes(ids);
 
-  insert_new_current_node_tags(create_nodes);
+  const auto ids_with_tags = insert_new_current_node_tags(create_nodes);
   save_current_nodes_to_history(ids);
-  save_current_node_tags_to_history(ids);
+  save_current_node_tags_to_history(ids_with_tags);
 
   m_bbox.expand(calc_node_bbox(ids));
 
@@ -171,9 +171,9 @@ void ApiDB_Node_Updater::process_modify_nodes() {
     delete_current_node_tags(ids_package);
     update_current_nodes(modify_nodes_package);
 
-    insert_new_current_node_tags(modify_nodes_package);
+    const auto ids_with_tags = insert_new_current_node_tags(modify_nodes_package);
     save_current_nodes_to_history(ids_package);
-    save_current_node_tags_to_history(ids_package);
+    save_current_node_tags_to_history(ids_with_tags);
 
     m_bbox.expand(calc_node_bbox(ids_package));
   }
@@ -669,11 +669,11 @@ void ApiDB_Node_Updater::delete_current_nodes(
     ct.deleted_node_ids.push_back({ id_to_old_id[row["id"].as<osm_nwr_id_t>()] });
 }
 
-void ApiDB_Node_Updater::insert_new_current_node_tags(
+std::vector<osm_nwr_id_t> ApiDB_Node_Updater::insert_new_current_node_tags(
     const std::vector<node_t> &nodes) {
 
   if (nodes.empty())
-    return;
+    return {};
 
   m.prepare("insert_new_current_node_tags",
 
@@ -695,22 +695,27 @@ void ApiDB_Node_Updater::insert_new_current_node_tags(
 
   unsigned total_tags = 0;
 
-  for (const auto &node : nodes)
+  for (const auto &node : nodes) {
     for (const auto &tag : node.tags) {
       ids.emplace_back(node.id);
       ks.emplace_back(escape(tag.first));
       vs.emplace_back(escape(tag.second));
       ++total_tags;
     }
+  }
 
   if (total_tags == 0)
-    return;
+    return {};
 
-  pqxx::result r =
-      m.exec_prepared("insert_new_current_node_tags", ids, ks, vs);
+  auto r = m.exec_prepared("insert_new_current_node_tags", ids, ks, vs);
 
   if (r.affected_rows() != total_tags)
     throw http::server_error("Could not create new current node tags");
+
+  // prepare list of node ids with tags
+  std::sort(ids.begin(), ids.end());
+  ids.erase(std::unique(ids.begin(), ids.end()), ids.end());
+  return ids;
 }
 
 void ApiDB_Node_Updater::save_current_nodes_to_history(

src/backend/apidb/changeset_upload/relation_updater.cpp

@@ -146,11 +146,11 @@ void ApiDB_Relation_Updater::process_new_relations() {
   lock_current_relations(ids);
   lock_future_members(create_relations, ids);
 
-  insert_new_current_relation_tags(create_relations);
+  const auto ids_with_tags = insert_new_current_relation_tags(create_relations);
   insert_new_current_relation_members(create_relations);
 
   save_current_relations_to_history(ids);
-  save_current_relation_tags_to_history(ids);
+  save_current_relation_tags_to_history(ids_with_tags);
   save_current_relation_members_to_history(ids);
 
   m_bbox.expand(calc_relation_bbox(ids));
@@ -242,11 +242,11 @@ void ApiDB_Relation_Updater::process_modify_relations() {
     delete_current_relation_members(ids_package);
 
     update_current_relations(modify_relations_package, true);
-    insert_new_current_relation_tags(modify_relations_package);
+    const auto ids_with_tags = insert_new_current_relation_tags(modify_relations_package);
     insert_new_current_relation_members(modify_relations_package);
 
     save_current_relations_to_history(ids_package);
-    save_current_relation_tags_to_history(ids_package);
+    save_current_relation_tags_to_history(ids_with_tags);
     save_current_relation_members_to_history(ids_package);
 
     /* After the database changes are done, check the updated
@@ -1290,11 +1290,11 @@ void ApiDB_Relation_Updater::update_current_relations(
   }
 }
 
-void ApiDB_Relation_Updater::insert_new_current_relation_tags(
+std::vector<osm_nwr_id_t>  ApiDB_Relation_Updater::insert_new_current_relation_tags(
     const std::vector<relation_t> &relations) {
 
   if (relations.empty())
-    return;
+    return {};
 
   m.prepare("insert_new_current_relation_tags",
 
@@ -1314,15 +1314,29 @@ void ApiDB_Relation_Updater::insert_new_current_relation_tags(
   std::vector<std::string> ks;
   std::vector<std::string> vs;
 
-  for (const auto &relation : relations)
+  unsigned total_tags = 0;
+
+  for (const auto &relation : relations) {
     for (const auto &tag : relation.tags) {
       ids.emplace_back(relation.id);
       ks.emplace_back(escape(tag.first));
       vs.emplace_back(escape(tag.second));
+      ++total_tags;
     }
+  }
 
-  pqxx::result r =
-      m.exec_prepared("insert_new_current_relation_tags", ids, ks, vs);
+  if (total_tags == 0)
+    return {};
+
+  auto r = m.exec_prepared("insert_new_current_relation_tags", ids, ks, vs);
+
+  if (r.affected_rows() != total_tags)
+    throw http::server_error("Could not create new current relation tags");
+
+  // prepare list of relation ids with tags
+  std::sort(ids.begin(), ids.end());
+  ids.erase(std::unique(ids.begin(), ids.end()), ids.end());
+  return ids;
 }
 
 void ApiDB_Relation_Updater::insert_new_current_relation_members(

src/backend/apidb/changeset_upload/way_updater.cpp

@@ -142,11 +142,11 @@ void ApiDB_Way_Updater::process_new_ways() {
   lock_current_ways(ids);
   lock_future_nodes(create_ways);
 
-  insert_new_current_way_tags(create_ways);
+  const auto ids_with_tags = insert_new_current_way_tags(create_ways);
   insert_new_current_way_nodes(create_ways);
 
   save_current_ways_to_history(ids);
-  save_current_way_tags_to_history(ids);
+  save_current_way_tags_to_history(ids_with_tags);
   save_current_way_nodes_to_history(ids);
 
   m_bbox.expand(calc_way_bbox(ids));
@@ -196,11 +196,11 @@ void ApiDB_Way_Updater::process_modify_ways() {
     delete_current_way_nodes(ids_package);
 
     update_current_ways(modify_ways_package, true);
-    insert_new_current_way_tags(modify_ways_package);
+    const auto ids_with_tags = insert_new_current_way_tags(modify_ways_package);
     insert_new_current_way_nodes(modify_ways_package);
 
     save_current_ways_to_history(ids_package);
-    save_current_way_tags_to_history(ids_package);
+    save_current_way_tags_to_history(ids_with_tags);
     save_current_way_nodes_to_history(ids_package);
 
     m_bbox.expand(calc_way_bbox(ids));
@@ -690,11 +690,11 @@ void ApiDB_Way_Updater::update_current_ways(const std::vector<way_t> &ways,
   }
 }
 
-void ApiDB_Way_Updater::insert_new_current_way_tags(
+std::vector<osm_nwr_id_t> ApiDB_Way_Updater::insert_new_current_way_tags(
     const std::vector<way_t> &ways) {
 
   if (ways.empty())
-    return;
+    return {};
 
   m.prepare("insert_new_current_way_tags",
 
@@ -714,15 +714,29 @@ void ApiDB_Way_Updater::insert_new_current_way_tags(
   std::vector<std::string> ks;
   std::vector<std::string> vs;
 
-  for (const auto &way : ways)
+  unsigned total_tags = 0;
+
+  for (const auto &way : ways) {
     for (const auto &tag : way.tags) {
       ids.emplace_back(way.id);
       ks.emplace_back(escape(tag.first));
       vs.emplace_back(escape(tag.second));
+      ++total_tags;
     }
+  }
 
-  pqxx::result r =
-      m.exec_prepared("insert_new_current_way_tags", ids, ks, vs);
+  if (total_tags == 0)
+    return {};
+
+  auto r = m.exec_prepared("insert_new_current_way_tags", ids, ks, vs);
+
+  if (r.affected_rows() != total_tags)
+    throw http::server_error("Could not create new current way tags");
+
+  // prepare list of way ids with tags
+  std::sort(ids.begin(), ids.end());
+  ids.erase(std::unique(ids.begin(), ids.end()), ids.end());
+  return ids;
 }
 
 void ApiDB_Way_Updater::insert_new_current_way_nodes(