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

Consistently use m_db_connection for the database connection member var

Author: lonvia

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();
     }
 }

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;

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,

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;
 

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);
 }
 

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;