Merge pull request #2155 from joto/db-conn-name

lonvia · web-flow · commit bdd558341430 · 2024-04-03T21:15:36.000+02:00
Consistently use m_db_connection for the database connection member var
diff --git a/src/db-copy.cpp b/src/db-copy.cpp
@@ -128,15 +128,16 @@ db_copy_thread_t::thread_t::thread_t(connection_params_t connection_params,
 void db_copy_thread_t::thread_t::operator()()
 {
     try {
-        m_conn = std::make_unique<pg_conn_t>(m_connection_params, "copy");
+        m_db_connection =
+            std::make_unique<pg_conn_t>(m_connection_params, "copy");
 
         // Disable sequential scan on database tables in the copy threads.
         // The copy threads only do COPYs (which are unaffected by this
         // setting) and DELETEs which we know benefit from the index. For
         // some reason PostgreSQL chooses in some cases not to use that index,
         // possibly because the DELETEs get a large list of ids to delete of
         // which many are not in the table which confuses the query planner.
-        m_conn->exec("SET enable_seqscan = off");
+        m_db_connection->exec("SET enable_seqscan = off");
 
         bool done = false;
         while (!done) {
@@ -167,7 +168,7 @@ void db_copy_thread_t::thread_t::operator()()
 
         finish_copy();
 
-        m_conn.reset();
+        m_db_connection.reset();
     } catch (std::runtime_error const &e) {
         log_error("DB copy thread failed: {}", e.what());
         std::exit(2); // NOLINT(concurrency-mt-unsafe)
@@ -181,13 +182,13 @@ void db_copy_thread_t::thread_t::write_to_db(db_cmd_copy_t *buffer)
         finish_copy();
     }
 
-    buffer->delete_data(m_conn.get());
+    buffer->delete_data(m_db_connection.get());
 
     if (!m_inflight) {
         start_copy(buffer->target);
     }
 
-    m_conn->copy_send(buffer->buffer, buffer->target->name());
+    m_db_connection->copy_send(buffer->buffer, buffer->target->name());
 }
 
 void db_copy_thread_t::thread_t::start_copy(
@@ -208,15 +209,15 @@ void db_copy_thread_t::thread_t::start_copy(
     }
 
     sql.push_back('\0');
-    m_conn->copy_start(sql.data());
+    m_db_connection->copy_start(sql.data());
 
     m_inflight = target;
 }
 
 void db_copy_thread_t::thread_t::finish_copy()
 {
     if (m_inflight) {
-        m_conn->copy_end(m_inflight->name());
+        m_db_connection->copy_end(m_inflight->name());
         m_inflight.reset();
     }
 }
diff --git a/src/db-copy.hpp b/src/db-copy.hpp
@@ -301,7 +301,7 @@ class db_copy_thread_t
         void delete_rows(db_cmd_copy_t *buffer);
 
         connection_params_t m_connection_params;
-        std::unique_ptr<pg_conn_t> m_conn;
+        std::unique_ptr<pg_conn_t> m_db_connection;
 
         // Target for copy operation currently ongoing.
         std::shared_ptr<db_target_descr_t> m_inflight;
diff --git a/src/middle-pgsql.cpp b/src/middle-pgsql.cpp
@@ -141,7 +141,7 @@ middle_pgsql_t::table_desc::table_desc(options_t const &options,
 
 void middle_query_pgsql_t::exec_sql(std::string const &sql_cmd) const
 {
-    m_sql_conn.exec(sql_cmd);
+    m_db_connection.exec(sql_cmd);
 }
 
 void middle_pgsql_t::table_desc::drop_table(
@@ -665,7 +665,7 @@ std::size_t middle_query_pgsql_t::get_way_node_locations_db(
 
     // get any remaining nodes from the DB
     // Nodes must have been written back at this point.
-    auto const res = m_sql_conn.exec_prepared("get_node_list", id_list());
+    auto const res = m_db_connection.exec_prepared("get_node_list", id_list());
     std::unordered_map<osmid_t, osmium::Location> locs;
     for (int i = 0; i < res.num_tuples(); ++i) {
         locs.emplace(osmium::string_to_object_id(res.get_value(i, 0)),
@@ -776,7 +776,7 @@ std::size_t middle_query_pgsql_t::get_way_node_locations_flatnodes(
 
 osmium::Location middle_query_pgsql_t::get_node_location_db(osmid_t id) const
 {
-    auto const res = m_sql_conn.exec_prepared("get_node", id);
+    auto const res = m_db_connection.exec_prepared("get_node", id);
     if (res.num_tuples() == 0) {
         return osmium::Location{};
     }
@@ -1026,7 +1026,7 @@ bool middle_query_pgsql_t::way_get(osmid_t id,
 {
     assert(buffer);
 
-    auto const res = m_sql_conn.exec_prepared("get_way", id);
+    auto const res = m_db_connection.exec_prepared("get_way", id);
 
     if (res.num_tuples() != 1) {
         return false;
@@ -1061,7 +1061,7 @@ middle_query_pgsql_t::rel_members_get(osmium::Relation const &rel,
 
         // ...and get those ways from database
         if (!way_ids.empty()) {
-            res = m_sql_conn.exec_prepared("get_way_list", way_ids());
+            res = m_db_connection.exec_prepared("get_way_list", way_ids());
             wayidspg = get_ids_from_result(res);
         }
     }
@@ -1178,7 +1178,7 @@ bool middle_query_pgsql_t::relation_get_format1(
 {
     assert(buffer);
 
-    auto const res = m_sql_conn.exec_prepared("get_rel", id);
+    auto const res = m_db_connection.exec_prepared("get_rel", id);
     if (res.num_tuples() != 1) {
         return false;
     }
@@ -1205,7 +1205,7 @@ bool middle_query_pgsql_t::relation_get_format2(
 {
     assert(buffer);
 
-    auto const res = m_sql_conn.exec_prepared("get_rel", id);
+    auto const res = m_db_connection.exec_prepared("get_rel", id);
 
     if (res.num_tuples() == 0) {
         return false;
@@ -1305,13 +1305,13 @@ middle_query_pgsql_t::middle_query_pgsql_t(
     std::shared_ptr<node_locations_t> cache,
     std::shared_ptr<node_persistent_cache> persistent_cache,
     middle_pgsql_options const &options)
-: m_sql_conn(connection_params, "middle.query"), m_cache(std::move(cache)),
+: m_db_connection(connection_params, "middle.query"), m_cache(std::move(cache)),
   m_persistent_cache(std::move(persistent_cache)), m_store_options(options)
 {
     // Disable JIT and parallel workers as they are known to cause
     // problems when accessing the intarrays.
-    m_sql_conn.set_config("jit_above_cost", "-1");
-    m_sql_conn.set_config("max_parallel_workers_per_gather", "0");
+    m_db_connection.set_config("jit_above_cost", "-1");
+    m_db_connection.set_config("max_parallel_workers_per_gather", "0");
 }
 
 static void table_setup(pg_conn_t const &db_connection,
diff --git a/src/middle-pgsql.hpp b/src/middle-pgsql.hpp
@@ -85,7 +85,7 @@ class middle_query_pgsql_t : public middle_query_t
     std::size_t get_way_node_locations_flatnodes(osmium::WayNodeList *nodes) const;
     std::size_t get_way_node_locations_db(osmium::WayNodeList *nodes) const;
 
-    pg_conn_t m_sql_conn;
+    pg_conn_t m_db_connection;
     std::shared_ptr<node_locations_t> m_cache;
     std::shared_ptr<node_persistent_cache> m_persistent_cache;
 
diff --git a/src/table.cpp b/src/table.cpp
@@ -54,25 +54,26 @@ table_t::table_t(table_t const &other,
     // if the other table has already started, then we want to execute
     // the same stuff to get into the same state. but if it hasn't, then
     // this would be premature.
-    if (other.m_sql_conn) {
+    if (other.m_db_connection) {
         connect();
         prepare();
     }
 }
 
-void table_t::teardown() { m_sql_conn.reset(); }
+void table_t::teardown() { m_db_connection.reset(); }
 
 void table_t::sync() { m_copy.sync(); }
 
 void table_t::connect()
 {
-    m_sql_conn = std::make_unique<pg_conn_t>(m_connection_params, "out.pgsql");
+    m_db_connection =
+        std::make_unique<pg_conn_t>(m_connection_params, "out.pgsql");
 }
 
 void table_t::start(connection_params_t const &connection_params,
                     std::string const &table_space)
 {
-    if (m_sql_conn) {
+    if (m_db_connection) {
         throw fmt_error("{} cannot start, its already started.",
                         m_target->name());
     }
@@ -88,11 +89,11 @@ void table_t::start(connection_params_t const &connection_params,
 
     // we are making a new table
     if (!m_append) {
-        m_sql_conn->exec("DROP TABLE IF EXISTS {} CASCADE", qual_name);
+        m_db_connection->exec("DROP TABLE IF EXISTS {} CASCADE", qual_name);
     }
 
     // These _tmp tables can be left behind if we run out of disk space.
-    m_sql_conn->exec("DROP TABLE IF EXISTS {}", qual_tmp_name);
+    m_db_connection->exec("DROP TABLE IF EXISTS {}", qual_tmp_name);
 
     //making a new table
     if (!m_append) {
@@ -128,10 +129,10 @@ void table_t::start(connection_params_t const &connection_params,
         sql += m_table_space;
 
         //create the table
-        m_sql_conn->exec(sql);
+        m_db_connection->exec(sql);
 
         if (m_srid != "4326") {
-            create_geom_check_trigger(*m_sql_conn, m_target->schema(),
+            create_geom_check_trigger(*m_db_connection, m_target->schema(),
                                       m_target->name(), "ST_IsValid(NEW.way)");
         }
     }
@@ -143,9 +144,9 @@ void table_t::prepare()
 {
     //let postgres cache this query as it will presumably happen a lot
     auto const qual_name = qualified_name(m_target->schema(), m_target->name());
-    m_sql_conn->exec("PREPARE get_wkb(int8) AS"
-                     " SELECT way FROM {} WHERE osm_id = $1",
-                     qual_name);
+    m_db_connection->exec("PREPARE get_wkb(int8) AS"
+                          " SELECT way FROM {} WHERE osm_id = $1",
+                          qual_name);
 }
 
 void table_t::generate_copy_column_list()
@@ -187,7 +188,7 @@ void table_t::stop(bool updateable, bool enable_hstore_index,
 
     if (!m_append) {
         if (m_srid != "4326") {
-            drop_geom_check_trigger(*m_sql_conn, m_target->schema(),
+            drop_geom_check_trigger(*m_db_connection, m_target->schema(),
                                     m_target->name());
         }
 
@@ -216,27 +217,29 @@ void table_t::stop(bool updateable, bool enable_hstore_index,
             sql += "way";
         }
 
-        m_sql_conn->exec(sql);
+        m_db_connection->exec(sql);
 
-        m_sql_conn->exec("DROP TABLE {}", qual_name);
-        m_sql_conn->exec(R"(ALTER TABLE {} RENAME TO "{}")", qual_tmp_name,
-                         m_target->name());
+        m_db_connection->exec("DROP TABLE {}", qual_name);
+        m_db_connection->exec(R"(ALTER TABLE {} RENAME TO "{}")", qual_tmp_name,
+                              m_target->name());
 
         log_info("Creating geometry index on table '{}'...", m_target->name());
 
         // Use fillfactor 100 for un-updatable imports
-        m_sql_conn->exec("CREATE INDEX ON {} USING GIST (way) {} {}", qual_name,
-                         (updateable ? "" : "WITH (fillfactor = 100)"),
-                         tablespace_clause(table_space_index));
+        m_db_connection->exec("CREATE INDEX ON {} USING GIST (way) {} {}",
+                              qual_name,
+                              (updateable ? "" : "WITH (fillfactor = 100)"),
+                              tablespace_clause(table_space_index));
 
         /* slim mode needs this to be able to apply diffs */
         if (updateable) {
             log_info("Creating osm_id index on table '{}'...",
                      m_target->name());
-            m_sql_conn->exec("CREATE INDEX ON {} USING BTREE (osm_id) {}",
-                             qual_name, tablespace_clause(table_space_index));
+            m_db_connection->exec("CREATE INDEX ON {} USING BTREE (osm_id) {}",
+                                  qual_name,
+                                  tablespace_clause(table_space_index));
             if (m_srid != "4326") {
-                create_geom_check_trigger(*m_sql_conn, m_target->schema(),
+                create_geom_check_trigger(*m_db_connection, m_target->schema(),
                                           m_target->name(),
                                           "ST_IsValid(NEW.way)");
             }
@@ -247,18 +250,18 @@ void table_t::stop(bool updateable, bool enable_hstore_index,
             log_info("Creating hstore indexes on table '{}'...",
                      m_target->name());
             if (m_hstore_mode != hstore_column::none) {
-                m_sql_conn->exec("CREATE INDEX ON {} USING GIN (tags) {}",
-                                 qual_name,
-                                 tablespace_clause(table_space_index));
+                m_db_connection->exec("CREATE INDEX ON {} USING GIN (tags) {}",
+                                      qual_name,
+                                      tablespace_clause(table_space_index));
             }
             for (auto const &hcolumn : m_hstore_columns) {
-                m_sql_conn->exec(R"(CREATE INDEX ON {} USING GIN ("{}") {})",
-                                 qual_name, hcolumn,
-                                 tablespace_clause(table_space_index));
+                m_db_connection->exec(
+                    R"(CREATE INDEX ON {} USING GIN ("{}") {})", qual_name,
+                    hcolumn, tablespace_clause(table_space_index));
             }
         }
         log_info("Analyzing table '{}'...", m_target->name());
-        analyze_table(*m_sql_conn, m_target->schema(), m_target->name());
+        analyze_table(*m_db_connection, m_target->schema(), m_target->name());
     }
     teardown();
 }
@@ -444,6 +447,6 @@ void table_t::escape_type(std::string const &value, ColumnType flags)
 
 pg_result_t table_t::get_wkb(osmid_t id)
 {
-    return m_sql_conn->exec_prepared_as_binary("get_wkb", id);
+    return m_db_connection->exec_prepared_as_binary("get_wkb", id);
 }
 
diff --git a/src/table.hpp b/src/table.hpp
@@ -73,7 +73,7 @@ class table_t
     connection_params_t m_connection_params;
     std::shared_ptr<db_target_descr_t> m_target;
     std::string m_type;
-    std::unique_ptr<pg_conn_t> m_sql_conn;
+    std::unique_ptr<pg_conn_t> m_db_connection;
     std::string m_srid;
     bool m_append;
     hstore_column m_hstore_mode;

Original file line number	Diff line number	Diff line change
`@@ -128,15 +128,16 @@ db_copy_thread_t::thread_t::thread_t(connection_params_t connection_params,`
`128`	`128`	`void db_copy_thread_t::thread_t::operator()()`
`129`	`129`	`{`
`130`	`130`	`try {`
`131`		`- m_conn = std::make_unique<pg_conn_t>(m_connection_params, "copy");`
	`131`	`+ m_db_connection =`
	`132`	`+ std::make_unique<pg_conn_t>(m_connection_params, "copy");`
`132`	`133`
`133`	`134`	`// Disable sequential scan on database tables in the copy threads.`
`134`	`135`	`// The copy threads only do COPYs (which are unaffected by this`
`135`	`136`	`// setting) and DELETEs which we know benefit from the index. For`
`136`	`137`	`// some reason PostgreSQL chooses in some cases not to use that index,`
`137`	`138`	`// possibly because the DELETEs get a large list of ids to delete of`
`138`	`139`	`// which many are not in the table which confuses the query planner.`
`139`		`- m_conn->exec("SET enable_seqscan = off");`
	`140`	`+ m_db_connection->exec("SET enable_seqscan = off");`
`140`	`141`
`141`	`142`	`bool done = false;`
`142`	`143`	`while (!done) {`
`@@ -167,7 +168,7 @@ void db_copy_thread_t::thread_t::operator()()`
`167`	`168`
`168`	`169`	`finish_copy();`
`169`	`170`
`170`		`- m_conn.reset();`
	`171`	`+ m_db_connection.reset();`
`171`	`172`	`} catch (std::runtime_error const &e) {`
`172`	`173`	`log_error("DB copy thread failed: {}", e.what());`
`173`	`174`	`std::exit(2); // NOLINT(concurrency-mt-unsafe)`
`@@ -181,13 +182,13 @@ void db_copy_thread_t::thread_t::write_to_db(db_cmd_copy_t *buffer)`
`181`	`182`	`finish_copy();`
`182`	`183`	`}`
`183`	`184`
`184`		`- buffer->delete_data(m_conn.get());`
	`185`	`+ buffer->delete_data(m_db_connection.get());`
`185`	`186`
`186`	`187`	`if (!m_inflight) {`
`187`	`188`	`start_copy(buffer->target);`
`188`	`189`	`}`
`189`	`190`
`190`		`- m_conn->copy_send(buffer->buffer, buffer->target->name());`
	`191`	`+ m_db_connection->copy_send(buffer->buffer, buffer->target->name());`
`191`	`192`	`}`
`192`	`193`
`193`	`194`	`void db_copy_thread_t::thread_t::start_copy(`
`@@ -208,15 +209,15 @@ void db_copy_thread_t::thread_t::start_copy(`
`208`	`209`	`}`
`209`	`210`
`210`	`211`	`sql.push_back('\0');`
`211`		`- m_conn->copy_start(sql.data());`
	`212`	`+ m_db_connection->copy_start(sql.data());`
`212`	`213`
`213`	`214`	`m_inflight = target;`
`214`	`215`	`}`
`215`	`216`
`216`	`217`	`void db_copy_thread_t::thread_t::finish_copy()`
`217`	`218`	`{`
`218`	`219`	`if (m_inflight) {`
`219`		`- m_conn->copy_end(m_inflight->name());`
	`220`	`+ m_db_connection->copy_end(m_inflight->name());`
`220`	`221`	`m_inflight.reset();`
`221`	`222`	`}`
`222`	`223`	`}`
Original file line number	Diff line number	Diff line change
`@@ -141,7 +141,7 @@ middle_pgsql_t::table_desc::table_desc(options_t const &options,`
`141`	`141`
`142`	`142`	`void middle_query_pgsql_t::exec_sql(std::string const &sql_cmd) const`
`143`	`143`	`{`
`144`		`- m_sql_conn.exec(sql_cmd);`
	`144`	`+ m_db_connection.exec(sql_cmd);`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`void middle_pgsql_t::table_desc::drop_table(`
`@@ -665,7 +665,7 @@ std::size_t middle_query_pgsql_t::get_way_node_locations_db(`
`665`	`665`
`666`	`666`	`// get any remaining nodes from the DB`
`667`	`667`	`// Nodes must have been written back at this point.`
`668`		`- auto const res = m_sql_conn.exec_prepared("get_node_list", id_list());`
	`668`	`+ auto const res = m_db_connection.exec_prepared("get_node_list", id_list());`
`669`	`669`	`std::unordered_map<osmid_t, osmium::Location> locs;`
`670`	`670`	`for (int i = 0; i < res.num_tuples(); ++i) {`
`671`	`671`	`locs.emplace(osmium::string_to_object_id(res.get_value(i, 0)),`
`@@ -776,7 +776,7 @@ std::size_t middle_query_pgsql_t::get_way_node_locations_flatnodes(`
`776`	`776`
`777`	`777`	`osmium::Location middle_query_pgsql_t::get_node_location_db(osmid_t id) const`
`778`	`778`	`{`
`779`		`- auto const res = m_sql_conn.exec_prepared("get_node", id);`
	`779`	`+ auto const res = m_db_connection.exec_prepared("get_node", id);`
`780`	`780`	`if (res.num_tuples() == 0) {`
`781`	`781`	`return osmium::Location{};`
`782`	`782`	`}`
`@@ -1026,7 +1026,7 @@ bool middle_query_pgsql_t::way_get(osmid_t id,`
`1026`	`1026`	`{`
`1027`	`1027`	`assert(buffer);`
`1028`	`1028`
`1029`		`- auto const res = m_sql_conn.exec_prepared("get_way", id);`
	`1029`	`+ auto const res = m_db_connection.exec_prepared("get_way", id);`
`1030`	`1030`
`1031`	`1031`	`if (res.num_tuples() != 1) {`
`1032`	`1032`	`return false;`
`@@ -1061,7 +1061,7 @@ middle_query_pgsql_t::rel_members_get(osmium::Relation const &rel,`
`1061`	`1061`
`1062`	`1062`	`// ...and get those ways from database`
`1063`	`1063`	`if (!way_ids.empty()) {`
`1064`		`- res = m_sql_conn.exec_prepared("get_way_list", way_ids());`
	`1064`	`+ res = m_db_connection.exec_prepared("get_way_list", way_ids());`
`1065`	`1065`	`wayidspg = get_ids_from_result(res);`
`1066`	`1066`	`}`
`1067`	`1067`	`}`
`@@ -1178,7 +1178,7 @@ bool middle_query_pgsql_t::relation_get_format1(`
`1178`	`1178`	`{`
`1179`	`1179`	`assert(buffer);`
`1180`	`1180`
`1181`		`- auto const res = m_sql_conn.exec_prepared("get_rel", id);`
	`1181`	`+ auto const res = m_db_connection.exec_prepared("get_rel", id);`
`1182`	`1182`	`if (res.num_tuples() != 1) {`
`1183`	`1183`	`return false;`
`1184`	`1184`	`}`
`@@ -1205,7 +1205,7 @@ bool middle_query_pgsql_t::relation_get_format2(`
`1205`	`1205`	`{`
`1206`	`1206`	`assert(buffer);`
`1207`	`1207`
`1208`		`- auto const res = m_sql_conn.exec_prepared("get_rel", id);`
	`1208`	`+ auto const res = m_db_connection.exec_prepared("get_rel", id);`
`1209`	`1209`
`1210`	`1210`	`if (res.num_tuples() == 0) {`
`1211`	`1211`	`return false;`
`@@ -1305,13 +1305,13 @@ middle_query_pgsql_t::middle_query_pgsql_t(`
`1305`	`1305`	`std::shared_ptr<node_locations_t> cache,`
`1306`	`1306`	`std::shared_ptr<node_persistent_cache> persistent_cache,`
`1307`	`1307`	`middle_pgsql_options const &options)`
`1308`		`-: m_sql_conn(connection_params, "middle.query"), m_cache(std::move(cache)),`
	`1308`	`+: m_db_connection(connection_params, "middle.query"), m_cache(std::move(cache)),`
`1309`	`1309`	`m_persistent_cache(std::move(persistent_cache)), m_store_options(options)`
`1310`	`1310`	`{`
`1311`	`1311`	`// Disable JIT and parallel workers as they are known to cause`
`1312`	`1312`	`// problems when accessing the intarrays.`
`1313`		`- m_sql_conn.set_config("jit_above_cost", "-1");`
`1314`		`- m_sql_conn.set_config("max_parallel_workers_per_gather", "0");`
	`1313`	`+ m_db_connection.set_config("jit_above_cost", "-1");`
	`1314`	`+ m_db_connection.set_config("max_parallel_workers_per_gather", "0");`
`1315`	`1315`	`}`
`1316`	`1316`
`1317`	`1317`	`static void table_setup(pg_conn_t const &db_connection,`