Merge pull request #2175 from joto/gen-append-flag

All generalizers can now differentiate between create and append mode, use this to not run ANALYZE in append mode

Author: lonvia

src/gen/gen-base.cpp

@@ -14,8 +14,8 @@
 
 #include <fmt/args.h>
 
-gen_base_t::gen_base_t(pg_conn_t *connection, params_t *params)
-: m_connection(connection), m_params(params)
+gen_base_t::gen_base_t(pg_conn_t *connection, bool append, params_t *params)
+: m_connection(connection), m_params(params), m_append(append)
 {
     assert(connection);
     assert(params);

src/gen/gen-base.hpp

@@ -67,8 +67,10 @@ class gen_base_t
         }
     }
 
+    bool append_mode() const noexcept { return m_append; }
+
 protected:
-    gen_base_t(pg_conn_t *connection, params_t *params);
+    gen_base_t(pg_conn_t *connection, bool append, params_t *params);
 
     /**
      * Check that the 'src_table' and 'dest_table' parameters exist and that
@@ -106,6 +108,7 @@ class gen_base_t
     std::vector<util::timer_t> m_timers;
     pg_conn_t *m_connection;
     params_t *m_params;
+    bool m_append;
     bool m_debug = false;
 }; // class gen_base_t
 

src/gen/gen-create.cpp

@@ -18,24 +18,25 @@
 
 std::unique_ptr<gen_base_t> create_generalizer(std::string const &strategy,
                                                pg_conn_t *connection,
-                                               params_t *params)
+                                               bool append, params_t *params)
 {
     auto generalizer = [&]() -> std::unique_ptr<gen_base_t> {
         if (strategy == "builtup") {
-            return std::make_unique<gen_tile_builtup_t>(connection, params);
+            return std::make_unique<gen_tile_builtup_t>(connection, append,
+                                                        params);
         }
         if (strategy == "discrete-isolation") {
-            return std::make_unique<gen_di_t>(connection, params);
+            return std::make_unique<gen_di_t>(connection, append, params);
         }
         if (strategy == "raster-union") {
-            return std::make_unique<gen_tile_raster_union_t>(connection,
+            return std::make_unique<gen_tile_raster_union_t>(connection, append,
                                                              params);
         }
         if (strategy == "rivers") {
-            return std::make_unique<gen_rivers_t>(connection, params);
+            return std::make_unique<gen_rivers_t>(connection, append, params);
         }
         if (strategy == "vector-union") {
-            return std::make_unique<gen_tile_vector_union_t>(connection,
+            return std::make_unique<gen_tile_vector_union_t>(connection, append,
                                                              params);
         }
         throw fmt_error("Unknown generalization strategy '{}'.", strategy);

src/gen/gen-create.hpp

@@ -21,6 +21,6 @@ class pg_conn_t;
 /// Instantiate a generalizer for the specified strategy.
 std::unique_ptr<gen_base_t> create_generalizer(std::string const &strategy,
                                                pg_conn_t *connection,
-                                               params_t *params);
+                                               bool append, params_t *params);
 
 #endif // OSM2PGSQL_GEN_CREATE_HPP

src/gen/gen-discrete-isolation.cpp

@@ -17,8 +17,8 @@
 #include <algorithm>
 #include <vector>
 
-gen_di_t::gen_di_t(pg_conn_t *connection, params_t *params)
-: gen_base_t(connection, params), m_timer_get(add_timer("get")),
+gen_di_t::gen_di_t(pg_conn_t *connection, bool append, params_t *params)
+: gen_base_t(connection, append, params), m_timer_get(add_timer("get")),
   m_timer_sort(add_timer("sort")), m_timer_di(add_timer("di")),
   m_timer_reorder(add_timer("reorder")), m_timer_write(add_timer("write"))
 {
@@ -143,7 +143,9 @@ FROM {src} WHERE {importance_column} > 0
     connection().exec("COMMIT");
     timer(m_timer_write).stop();
 
-    dbexec("ANALYZE {src}");
+    if (!append_mode()) {
+        dbexec("ANALYZE {src}");
+    }
 
     log_gen("Done.");
 }

src/gen/gen-discrete-isolation.hpp

@@ -17,7 +17,7 @@
 class gen_di_t : public gen_base_t
 {
 public:
-    gen_di_t(pg_conn_t *connection, params_t *params);
+    gen_di_t(pg_conn_t *connection, bool append, params_t *params);
 
     void process() override;
 

src/gen/gen-rivers.cpp

@@ -22,13 +22,12 @@
 #include <unordered_map>
 #include <vector>
 
-gen_rivers_t::gen_rivers_t(pg_conn_t *connection, params_t *params)
-: gen_base_t(connection, params), m_timer_area(add_timer("area")),
+gen_rivers_t::gen_rivers_t(pg_conn_t *connection, bool append, params_t *params)
+: gen_base_t(connection, append, params), m_timer_area(add_timer("area")),
   m_timer_prep(add_timer("prep")), m_timer_get(add_timer("get")),
   m_timer_sort(add_timer("sort")), m_timer_net(add_timer("net")),
   m_timer_remove(add_timer("remove")), m_timer_width(add_timer("width")),
-  m_timer_write(add_timer("write")),
-  m_delete_existing(params->has("delete_existing"))
+  m_timer_write(add_timer("write"))
 {
     check_src_dest_table_params_exist();
 
@@ -197,7 +196,11 @@ void gen_rivers_t::process()
     dbexec(R"(UPDATE {qualified_src_areas} SET width =)"
            R"( (ST_MaximumInscribedCircle("{geom_column}")).radius * 2)"
            R"( WHERE width IS NULL)");
-    dbexec("ANALYZE {qualified_src_areas}");
+
+    if (!append_mode()) {
+        dbexec("ANALYZE {qualified_src_areas}");
+    }
+
     timer(m_timer_area).stop();
 
     log_gen("Get 'width' from areas onto lines...");
@@ -323,7 +326,7 @@ SELECT "{id_column}", "{width_column}", "{name_column}", "{geom_column}"
     }
     timer(m_timer_width).stop();
 
-    if (m_delete_existing) {
+    if (append_mode()) {
         dbexec("TRUNCATE {dest}");
     }
 
@@ -343,7 +346,9 @@ SELECT "{id_column}", "{width_column}", "{name_column}", "{geom_column}"
     connection().exec("COMMIT");
     timer(m_timer_write).stop();
 
-    dbexec("ANALYZE {dest}");
+    if (!append_mode()) {
+        dbexec("ANALYZE {dest}");
+    }
 
     log_gen("Done.");
 }

src/gen/gen-rivers.hpp

@@ -17,7 +17,7 @@
 class gen_rivers_t : public gen_base_t
 {
 public:
-    gen_rivers_t(pg_conn_t *connection, params_t *params);
+    gen_rivers_t(pg_conn_t *connection, bool append, params_t *params);
 
     void process() override;
 
@@ -37,7 +37,6 @@ class gen_rivers_t : public gen_base_t
 
     std::size_t m_num_waterways = 0;
     std::size_t m_num_points = 0;
-    bool m_delete_existing;
 };
 
 #endif // OSM2PGSQL_GEN_RIVERS_HPP

src/gen/gen-tile-builtup.cpp

@@ -26,8 +26,9 @@ static std::size_t round_up(std::size_t value, std::size_t multiple) noexcept
     return ((value + multiple - 1U) / multiple) * multiple;
 }
 
-gen_tile_builtup_t::gen_tile_builtup_t(pg_conn_t *connection, params_t *params)
-: gen_tile_t(connection, params), m_timer_draw(add_timer("draw")),
+gen_tile_builtup_t::gen_tile_builtup_t(pg_conn_t *connection, bool append,
+                                       params_t *params)
+: gen_tile_t(connection, append, params), m_timer_draw(add_timer("draw")),
   m_timer_simplify(add_timer("simplify")),
   m_timer_vectorize(add_timer("vectorize")), m_timer_write(add_timer("write"))
 {
@@ -278,5 +279,8 @@ void gen_tile_builtup_t::post()
             }
         }
     }
-    dbexec("ANALYZE {dest}");
+
+    if (!append_mode()) {
+        dbexec("ANALYZE {dest}");
+    }
 }

src/gen/gen-tile-builtup.hpp

@@ -19,7 +19,7 @@
 class gen_tile_builtup_t final : public gen_tile_t
 {
 public:
-    gen_tile_builtup_t(pg_conn_t *connection, params_t *params);
+    gen_tile_builtup_t(pg_conn_t *connection, bool append, params_t *params);
 
     ~gen_tile_builtup_t() override = default;