move table to db_copy classes

Author: lonvia

db-copy.hpp

@@ -281,6 +281,13 @@ class db_copy_mgr_t
         m_current->buffer += std::to_string(value);
     }
 
+    void add_value(double value)
+    {
+        char tmp[32];
+        snprintf(tmp, sizeof(tmp), "%g", value);
+        m_current->buffer += tmp;
+    }
+
     void add_value(std::string const &s) { add_value(s.c_str()); }
 
     void add_value(char const *s)

expire-tiles.cpp

@@ -14,6 +14,8 @@
 #include <cerrno>
 #include <string>
 
+#include <boost/format.hpp>
+
 #include "expire-tiles.hpp"
 #include "options.hpp"
 #include "reprojection.hpp"

osmdata.cpp

@@ -8,6 +8,7 @@
 
 #include <osmium/thread/pool.hpp>
 
+#include "db-copy.hpp"
 #include "middle.hpp"
 #include "node-ram-cache.hpp"
 #include "osmdata.hpp"
@@ -247,11 +248,13 @@ struct pending_threaded_processor : public middle_t::pending_processor {
         for (size_t i = 0; i < thread_count; ++i) {
             //clone the middle
             auto mid_clone = mid->get_query_instance(mid);
+            auto copy_thread = std::make_shared<db_copy_thread_t>(
+                outs[0]->get_options()->database_options.conninfo());
 
             //clone the outs
             output_vec_t out_clones;
             for (const auto& out: outs) {
-                out_clones.push_back(out->clone(mid_clone));
+                out_clones.push_back(out->clone(mid_clone, copy_thread));
             }
 
             //keep the clones for a specific thread to use

output-gazetteer.hpp

@@ -18,10 +18,9 @@
 class output_gazetteer_t : public output_t
 {
     output_gazetteer_t(output_gazetteer_t const *other,
-                       std::shared_ptr<middle_query_t> const &cloned_mid)
-    : output_t(cloned_mid, other->m_options),
-      m_copy(std::make_shared<db_copy_thread_t>(
-          other->m_options.database_options.conninfo())),
+                       std::shared_ptr<middle_query_t> const &cloned_mid,
+                       std::shared_ptr<db_copy_thread_t> const &copy_thread)
+    : output_t(cloned_mid, other->m_options), m_copy(copy_thread),
       m_conn(nullptr), m_builder(other->m_options.projection, true),
       osmium_buffer(PLACE_BUFFER_SIZE, osmium::memory::Buffer::auto_grow::yes)
     {
@@ -31,10 +30,10 @@ class output_gazetteer_t : public output_t
 
 public:
     output_gazetteer_t(std::shared_ptr<middle_query_t> const &mid,
-                       options_t const &options)
-    : output_t(mid, options), m_copy(std::make_shared<db_copy_thread_t>(
-                                  options.database_options.conninfo())),
-      m_conn(nullptr), m_builder(options.projection, true),
+                       options_t const &options,
+                       std::shared_ptr<db_copy_thread_t> const &copy_thread)
+    : output_t(mid, options), m_copy(copy_thread), m_conn(nullptr),
+      m_builder(options.projection, true),
       osmium_buffer(PLACE_BUFFER_SIZE, osmium::memory::Buffer::auto_grow::yes)
     {
         m_style.load_style(options.style);
@@ -43,9 +42,11 @@ class output_gazetteer_t : public output_t
     virtual ~output_gazetteer_t();
 
     std::shared_ptr<output_t>
-    clone(std::shared_ptr<middle_query_t> const &mid) const override
+    clone(std::shared_ptr<middle_query_t> const &mid,
+          std::shared_ptr<db_copy_thread_t> const &copy_thread) const override
     {
-        return std::shared_ptr<output_t>(new output_gazetteer_t(this, mid));
+        return std::shared_ptr<output_t>(
+            new output_gazetteer_t(this, mid, copy_thread));
     }
 
     int start() override;

output-multi.cpp

@@ -11,11 +11,11 @@
 #include <boost/algorithm/string/predicate.hpp>
 #include <vector>
 
-output_multi_t::output_multi_t(std::string const &name,
-                               std::shared_ptr<geometry_processor> processor_,
-                               export_list const &export_list,
-                               std::shared_ptr<middle_query_t> const &mid,
-                               options_t const &options)
+output_multi_t::output_multi_t(
+    std::string const &name, std::shared_ptr<geometry_processor> processor_,
+    export_list const &export_list, std::shared_ptr<middle_query_t> const &mid,
+    options_t const &options,
+    std::shared_ptr<db_copy_thread_t> const &copy_thread)
 : output_t(mid, options),
   m_tagtransform(tagtransform_t::make_tagtransform(&m_options, export_list)),
   m_processor(processor_), m_proj(m_options.projection),
@@ -27,7 +27,7 @@ output_multi_t::output_multi_t(std::string const &name,
   m_table(new table_t(name, m_processor->column_type(),
                       export_list.normal_columns(m_osm_type),
                       m_options.hstore_columns, m_processor->srid(),
-                      m_options.append, m_options.hstore_mode)),
+                      m_options.append, m_options.hstore_mode, copy_thread)),
   ways_done_tracker(new id_tracker()),
   m_expire(m_options.expire_tiles_zoom, m_options.expire_tiles_max_bbox,
            m_options.projection),
@@ -37,12 +37,14 @@ output_multi_t::output_multi_t(std::string const &name,
 {
 }
 
-output_multi_t::output_multi_t(output_multi_t const *other,
-                               std::shared_ptr<middle_query_t> const &mid)
+output_multi_t::output_multi_t(
+    output_multi_t const *other, std::shared_ptr<middle_query_t> const &mid,
+    std::shared_ptr<db_copy_thread_t> const &copy_thread)
 : output_t(mid, other->m_options),
   m_tagtransform(other->m_tagtransform->clone()),
   m_processor(other->m_processor), m_proj(other->m_proj),
-  m_osm_type(other->m_osm_type), m_table(new table_t(*other->m_table)),
+  m_osm_type(other->m_osm_type),
+  m_table(new table_t(*other->m_table, copy_thread)),
   // NOTE: we need to know which ways were used by relations so each thread
   // must have a copy of the original marked done ways, its read only so its
   // ok
@@ -57,10 +59,12 @@ output_multi_t::output_multi_t(output_multi_t const *other,
 
 output_multi_t::~output_multi_t() = default;
 
-std::shared_ptr<output_t>
-output_multi_t::clone(std::shared_ptr<middle_query_t> const &mid) const
+std::shared_ptr<output_t> output_multi_t::clone(
+    std::shared_ptr<middle_query_t> const &mid,
+    std::shared_ptr<db_copy_thread_t> const &copy_thread) const
 {
-    return std::shared_ptr<output_t>(new output_multi_t(this, mid));
+    return std::shared_ptr<output_t>(
+        new output_multi_t(this, mid, copy_thread));
 }
 
 int output_multi_t::start() {

output-multi.hpp

@@ -26,18 +26,21 @@ struct options_t;
 class output_multi_t : public output_t
 {
     output_multi_t(output_multi_t const *other,
-                   std::shared_ptr<middle_query_t> const &mid);
+                   std::shared_ptr<middle_query_t> const &mid,
+                   std::shared_ptr<db_copy_thread_t> const &copy_thread);
 
 public:
     output_multi_t(std::string const &name,
                    std::shared_ptr<geometry_processor> processor_,
                    export_list const &export_list,
                    std::shared_ptr<middle_query_t> const &mid,
-                   options_t const &options);
+                   options_t const &options,
+                   std::shared_ptr<db_copy_thread_t> const &copy_thread);
     virtual ~output_multi_t();
 
     std::shared_ptr<output_t>
-    clone(std::shared_ptr<middle_query_t> const &mid) const override;
+    clone(std::shared_ptr<middle_query_t> const &mid,
+          std::shared_ptr<db_copy_thread_t> const &copy_thread) const override;
 
     int start() override;
     void stop(osmium::thread::Pool *pool) override;

output-null.cpp

@@ -1,9 +1,6 @@
 #include "osmtypes.hpp"
 #include "output-null.hpp"
 
-struct middle_query_t;
-struct options_t;
-
 void output_null_t::cleanup() {
 }
 
@@ -63,9 +60,10 @@ int output_null_t::relation_modify(osmium::Relation const &) {
 }
 
 std::shared_ptr<output_t>
-output_null_t::clone(std::shared_ptr<middle_query_t> const &mid) const
+output_null_t::clone(std::shared_ptr<middle_query_t> const &mid,
+                     std::shared_ptr<db_copy_thread_t> const &) const
 {
-    return std::shared_ptr<output_t>(new output_null_t(this, mid));
+    return std::shared_ptr<output_t>(new output_null_t(mid, m_options));
 }
 
 output_null_t::output_null_t(std::shared_ptr<middle_query_t> const &mid,
@@ -74,10 +72,4 @@ output_null_t::output_null_t(std::shared_ptr<middle_query_t> const &mid,
 {
 }
 
-output_null_t::output_null_t(output_null_t const *other,
-                             std::shared_ptr<middle_query_t> const &mid)
-: output_t(mid, other->m_options)
-{
-}
-
 output_null_t::~output_null_t() = default;

output-null.hpp

@@ -7,16 +7,14 @@
 #include "output.hpp"
 
 class output_null_t : public output_t {
-    output_null_t(output_null_t const *other,
-                  std::shared_ptr<middle_query_t> const &mid);
-
 public:
     output_null_t(std::shared_ptr<middle_query_t> const &mid,
                   options_t const &options);
     virtual ~output_null_t();
 
     std::shared_ptr<output_t>
-    clone(std::shared_ptr<middle_query_t> const &mid) const override;
+    clone(std::shared_ptr<middle_query_t> const &mid,
+          std::shared_ptr<db_copy_thread_t> const &copy_thread) const override;
 
     int start() override;
     void stop(osmium::thread::Pool *pool) override;

output-pgsql.cpp

@@ -499,14 +499,17 @@ int output_pgsql_t::start()
     return 0;
 }
 
-std::shared_ptr<output_t>
-output_pgsql_t::clone(std::shared_ptr<middle_query_t> const &mid) const
+std::shared_ptr<output_t> output_pgsql_t::clone(
+    std::shared_ptr<middle_query_t> const &mid,
+    std::shared_ptr<db_copy_thread_t> const &copy_thread) const
 {
-    return std::shared_ptr<output_t>(new output_pgsql_t(this, mid));
+    return std::shared_ptr<output_t>(
+        new output_pgsql_t(this, mid, copy_thread));
 }
 
-output_pgsql_t::output_pgsql_t(std::shared_ptr<middle_query_t> const &mid,
-                               options_t const &o)
+output_pgsql_t::output_pgsql_t(
+    std::shared_ptr<middle_query_t> const &mid, options_t const &o,
+    std::shared_ptr<db_copy_thread_t> const &copy_thread)
 : output_t(mid, o), m_builder(o.projection, o.enable_multi),
   expire(o.expire_tiles_zoom, o.expire_tiles_max_bbox, o.projection),
   ways_done_tracker(new id_tracker()),
@@ -552,15 +555,16 @@ output_pgsql_t::output_pgsql_t(std::shared_ptr<middle_query_t> const &mid,
                 util::exit_nicely();
         }
 
-        m_tables[i].reset(new table_t(name, type, columns,
-                                      m_options.hstore_columns,
-                                      m_options.projection->target_srs(),
-                                      m_options.append, m_options.hstore_mode));
+        m_tables[i].reset(
+            new table_t(name, type, columns, m_options.hstore_columns,
+                        m_options.projection->target_srs(), m_options.append,
+                        m_options.hstore_mode, copy_thread));
     }
 }
 
-output_pgsql_t::output_pgsql_t(output_pgsql_t const *other,
-                               std::shared_ptr<middle_query_t> const &mid)
+output_pgsql_t::output_pgsql_t(
+    output_pgsql_t const *other, std::shared_ptr<middle_query_t> const &mid,
+    std::shared_ptr<db_copy_thread_t> const &copy_thread)
 : output_t(mid, other->m_options),
   m_tagtransform(other->m_tagtransform->clone()),
   m_enable_way_area(other->m_enable_way_area),
@@ -575,12 +579,12 @@ output_pgsql_t::output_pgsql_t(output_pgsql_t const *other,
 {
     for (size_t i = 0; i < t_MAX; ++i) {
         //copy constructor will just connect to the already there table
-        m_tables[i].reset(new table_t(*(other->m_tables[i].get())));
+        m_tables[i].reset(
+            new table_t(*(other->m_tables[i].get()), copy_thread));
     }
 }
 
-output_pgsql_t::~output_pgsql_t() {
-}
+output_pgsql_t::~output_pgsql_t() = default;
 
 size_t output_pgsql_t::pending_count() const {
     return ways_pending_tracker.size() + rels_pending_tracker.size();

output-pgsql.hpp

@@ -6,6 +6,7 @@
 #ifndef OUTPUT_PGSQL_H
 #define OUTPUT_PGSQL_H
 
+#include "db-copy.hpp"
 #include "expire-tiles.hpp"
 #include "id-tracker.hpp"
 #include "osmium-builder.hpp"
@@ -18,19 +19,22 @@
 
 class output_pgsql_t : public output_t {
     output_pgsql_t(output_pgsql_t const *other,
-                   std::shared_ptr<middle_query_t> const &mid);
+                   std::shared_ptr<middle_query_t> const &mid,
+                   std::shared_ptr<db_copy_thread_t> const &copy_thread);
 
 public:
     enum table_id {
         t_point = 0, t_line, t_poly, t_roads, t_MAX
     };
 
     output_pgsql_t(std::shared_ptr<middle_query_t> const &mid,
-                   options_t const &options);
+                   options_t const &options,
+                   std::shared_ptr<db_copy_thread_t> const &copy_thread);
     virtual ~output_pgsql_t();
 
     std::shared_ptr<output_t>
-    clone(std::shared_ptr<middle_query_t> const &mid) const override;
+    clone(std::shared_ptr<middle_query_t> const &mid,
+          std::shared_ptr<db_copy_thread_t> const &copy_thread) const override;
 
     int start() override;
     void stop(osmium::thread::Pool *pool) override;