diff --git a/src/command-line-app.cpp b/src/command-line-app.cpp
index e4247cc48..08d9161e0 100644
--- a/src/command-line-app.cpp
+++ b/src/command-line-app.cpp
@@ -32,29 +32,44 @@ bool command_line_app_t::want_version() const { return count("--version"); }
 
 void command_line_app_t::init_database_options()
 {
-    add_option("-d,--database", m_database_options.db)
+    add_option_function<std::string>("-d,--database",
+                                     [&](std::string const &value) {
+                                         m_connection_params.set("dbname",
+                                                                 value);
+                                     })
         ->description("Database name or PostgreSQL conninfo string.")
         ->type_name("DB")
         ->group("Database options");
 
-    add_option("-U,--user", m_database_options.username)
+    add_option_function<std::string>("-U,--user",
+                                     [&](std::string const &value) {
+                                         m_connection_params.set("user", value);
+                                     })
         ->description("Database user.")
         ->type_name("USERNAME")
         ->group("Database options");
 
-    add_flag_function(
-        "-W,--password",
-        [&](int64_t) { m_database_options.password = util::get_password(); })
+    add_flag_function("-W,--password",
+                      [&](int64_t) {
+                          m_connection_params.set("password",
+                                                  util::get_password());
+                      })
         ->description("Force password prompt.")
         ->group("Database options");
 
-    add_option("-H,--host", m_database_options.host)
+    add_option_function<std::string>("-H,--host",
+                                     [&](std::string const &value) {
+                                         m_connection_params.set("host", value);
+                                     })
         ->description(
             "Database server hostname or unix domain socket location.")
         ->type_name("HOST")
         ->group("Database options");
 
-    add_option("-P,--port", m_database_options.port)
+    add_option_function<std::string>("-P,--port",
+                                     [&](std::string const &value) {
+                                         m_connection_params.set("port", value);
+                                     })
         ->description("Database server port.")
         ->type_name("PORT")
         ->group("Database options");
diff --git a/src/command-line-app.hpp b/src/command-line-app.hpp
index 7dc5202ad..11a9eef08 100644
--- a/src/command-line-app.hpp
+++ b/src/command-line-app.hpp
@@ -26,13 +26,13 @@ class command_line_app_t : public CLI::App
 
     bool want_version() const;
 
-    database_options_t database_options() const noexcept
+    connection_params_t connection_params() const noexcept
     {
-        return m_database_options;
+        return m_connection_params;
     }
 
 private:
-    database_options_t m_database_options;
+    connection_params_t m_connection_params;
 
     void init_database_options();
     void init_logging_options();
diff --git a/src/command-line-parser.cpp b/src/command-line-parser.cpp
index f9759f0e0..61bbc5494 100644
--- a/src/command-line-parser.cpp
+++ b/src/command-line-parser.cpp
@@ -32,48 +32,6 @@
 #include <stdexcept>
 #include <thread> // for number of threads
 
-static bool compare_prefix(std::string const &str,
-                           std::string const &prefix) noexcept
-{
-    return std::strncmp(str.c_str(), prefix.c_str(), prefix.size()) == 0;
-}
-
-std::string build_conninfo(database_options_t const &opt)
-{
-    if (compare_prefix(opt.db, "postgresql://") ||
-        compare_prefix(opt.db, "postgres://")) {
-        return opt.db;
-    }
-
-    util::string_joiner_t joiner{' '};
-    joiner.add("fallback_application_name='osm2pgsql'");
-
-    if (std::strchr(opt.db.c_str(), '=') != nullptr) {
-        joiner.add(opt.db);
-        return joiner();
-    }
-
-    joiner.add("client_encoding='UTF8'");
-
-    if (!opt.db.empty()) {
-        joiner.add(fmt::format("dbname='{}'", opt.db));
-    }
-    if (!opt.username.empty()) {
-        joiner.add(fmt::format("user='{}'", opt.username));
-    }
-    if (!opt.password.empty()) {
-        joiner.add(fmt::format("password='{}'", opt.password));
-    }
-    if (!opt.host.empty()) {
-        joiner.add(fmt::format("host='{}'", opt.host));
-    }
-    if (!opt.port.empty()) {
-        joiner.add(fmt::format("port='{}'", opt.port));
-    }
-
-    return joiner();
-}
-
 static osmium::Box parse_bbox_param(std::string const &arg)
 {
     double minx = NAN;
@@ -730,7 +688,7 @@ options_t parse_command_line(int argc, char *argv[])
 
     check_options(&options);
 
-    options.conninfo = build_conninfo(app.database_options());
+    options.connection_params = app.connection_params();
 
     if (!options.slim) {
         options.middle_database_format = 0;
diff --git a/src/db-copy.cpp b/src/db-copy.cpp
index d61e386b8..3a63a8587 100644
--- a/src/db-copy.cpp
+++ b/src/db-copy.cpp
@@ -81,11 +81,12 @@ void db_deleter_by_type_and_id_t::delete_rows(std::string const &table,
     conn->exec(sql.data());
 }
 
-db_copy_thread_t::db_copy_thread_t(std::string const &conninfo)
+db_copy_thread_t::db_copy_thread_t(connection_params_t const &connection_params)
 {
-    // conninfo is captured by copy here, because we don't know wether the
-    // reference will still be valid once we get around to running the thread
-    m_worker = std::thread{thread_t{conninfo, &m_shared}};
+    // Connection params are captured by copy here, because we don't know
+    // whether the reference will still be valid once we get around to running
+    // the thread.
+    m_worker = std::thread{thread_t{connection_params, &m_shared}};
 }
 
 db_copy_thread_t::~db_copy_thread_t() { finish(); }
@@ -119,14 +120,15 @@ void db_copy_thread_t::finish()
     }
 }
 
-db_copy_thread_t::thread_t::thread_t(std::string conninfo, shared *shared)
-: m_conninfo(std::move(conninfo)), m_shared(shared)
+db_copy_thread_t::thread_t::thread_t(connection_params_t connection_params,
+                                     shared *shared)
+: m_connection_params(std::move(connection_params)), m_shared(shared)
 {}
 
 void db_copy_thread_t::thread_t::operator()()
 {
     try {
-        m_conn = std::make_unique<pg_conn_t>(m_conninfo);
+        m_conn = std::make_unique<pg_conn_t>(m_connection_params);
 
         // Let commits happen faster by delaying when they actually occur.
         m_conn->exec("SET synchronous_commit = off");
diff --git a/src/db-copy.hpp b/src/db-copy.hpp
index 563187547..5ab4b56fa 100644
--- a/src/db-copy.hpp
+++ b/src/db-copy.hpp
@@ -249,7 +249,7 @@ struct db_cmd_finish_t : public db_cmd_t
 class db_copy_thread_t
 {
 public:
-    explicit db_copy_thread_t(std::string const &conninfo);
+    explicit db_copy_thread_t(connection_params_t const &connection_params);
 
     db_copy_thread_t(db_copy_thread_t const &) = delete;
     db_copy_thread_t &operator=(db_copy_thread_t const &) = delete;
@@ -290,7 +290,7 @@ class db_copy_thread_t
     class thread_t
     {
     public:
-        thread_t(std::string conninfo, shared *shared);
+        thread_t(connection_params_t connection_params, shared *shared);
 
         void operator()();
 
@@ -300,7 +300,7 @@ class db_copy_thread_t
         void finish_copy();
         void delete_rows(db_cmd_copy_t *buffer);
 
-        std::string m_conninfo;
+        connection_params_t m_connection_params;
         std::unique_ptr<pg_conn_t> m_conn;
 
         // Target for copy operation currently ongoing.
diff --git a/src/expire-output.cpp b/src/expire-output.cpp
index 41b7a0c34..ddcc36931 100644
--- a/src/expire-output.cpp
+++ b/src/expire-output.cpp
@@ -16,15 +16,16 @@
 
 #include <system_error>
 
-std::size_t expire_output_t::output(quadkey_list_t const &tile_list,
-                                    std::string const &conninfo) const
+std::size_t
+expire_output_t::output(quadkey_list_t const &tile_list,
+                        connection_params_t const &connection_params) const
 {
     std::size_t num = 0;
     if (!m_filename.empty()) {
         num = output_tiles_to_file(tile_list);
     }
     if (!m_table.empty()) {
-        num = output_tiles_to_table(tile_list, conninfo);
+        num = output_tiles_to_table(tile_list, connection_params);
     }
     return num;
 }
@@ -51,13 +52,13 @@ std::size_t expire_output_t::output_tiles_to_file(
     return count;
 }
 
-std::size_t
-expire_output_t::output_tiles_to_table(quadkey_list_t const &tiles_at_maxzoom,
-                                       std::string const &conninfo) const
+std::size_t expire_output_t::output_tiles_to_table(
+    quadkey_list_t const &tiles_at_maxzoom,
+    connection_params_t const &connection_params) const
 {
     auto const qn = qualified_name(m_schema, m_table);
 
-    pg_conn_t connection{conninfo};
+    pg_conn_t connection{connection_params};
 
     auto const result = connection.exec("SELECT * FROM {} LIMIT 1", qn);
 
diff --git a/src/expire-output.hpp b/src/expire-output.hpp
index 8fa4d5e6a..fc4dba4ad 100644
--- a/src/expire-output.hpp
+++ b/src/expire-output.hpp
@@ -18,6 +18,7 @@
 #include <utility>
 
 class pg_conn_t;
+class connection_params_t;
 
 /**
  * Output for tile expiry.
@@ -52,7 +53,7 @@ class expire_output_t
     void set_maxzoom(uint32_t maxzoom) noexcept { m_maxzoom = maxzoom; }
 
     std::size_t output(quadkey_list_t const &tile_list,
-                       std::string const &conninfo) const;
+                       connection_params_t const &connection_params) const;
 
     /**
      * Write the list of tiles to a file.
@@ -66,10 +67,11 @@ class expire_output_t
      * Write the list of tiles to a database table.
      *
      * \param tiles_at_maxzoom The list of tiles at maximum zoom level
-     * \param conninfo database connection info
+     * \param connection_params Database connection parameters
      */
-    std::size_t output_tiles_to_table(quadkey_list_t const &tiles_at_maxzoom,
-                                      std::string const &conninfo) const;
+    std::size_t
+    output_tiles_to_table(quadkey_list_t const &tiles_at_maxzoom,
+                          connection_params_t const &connection_params) const;
 
     /**
      * Create table for tiles.
diff --git a/src/flex-table.cpp b/src/flex-table.cpp
index f154e02e5..d9d0111d5 100644
--- a/src/flex-table.cpp
+++ b/src/flex-table.cpp
@@ -241,11 +241,11 @@ bool flex_table_t::has_columns_with_expire() const noexcept
                        [](auto const &column) { return column.has_expire(); });
 }
 
-void table_connection_t::connect(std::string const &conninfo)
+void table_connection_t::connect(connection_params_t const &connection_params)
 {
     assert(!m_db_connection);
 
-    m_db_connection = std::make_unique<pg_conn_t>(conninfo);
+    m_db_connection = std::make_unique<pg_conn_t>(connection_params);
     m_db_connection->exec("SET synchronous_commit = off");
 }
 
diff --git a/src/flex-table.hpp b/src/flex-table.hpp
index 70481db5a..efbd71122 100644
--- a/src/flex-table.hpp
+++ b/src/flex-table.hpp
@@ -259,7 +259,7 @@ class table_connection_t
     {
     }
 
-    void connect(std::string const &conninfo);
+    void connect(connection_params_t const &connection_params);
 
     void start(bool append);
 
diff --git a/src/gen/osm2pgsql-gen.cpp b/src/gen/osm2pgsql-gen.cpp
index aff975cb4..c974c8ffd 100644
--- a/src/gen/osm2pgsql-gen.cpp
+++ b/src/gen/osm2pgsql-gen.cpp
@@ -195,8 +195,9 @@ class tile_processor_t
     std::size_t m_num_tiles;
 };
 
-void run_tile_gen(std::string const &conninfo, gen_base_t *master_generalizer,
-                  params_t params, uint32_t zoom,
+void run_tile_gen(connection_params_t const &connection_params,
+                  gen_base_t *master_generalizer, params_t params,
+                  uint32_t zoom,
                   std::vector<std::pair<uint32_t, uint32_t>> *queue,
                   std::mutex *mut, unsigned int n)
 {
@@ -204,7 +205,7 @@ void run_tile_gen(std::string const &conninfo, gen_base_t *master_generalizer,
 
     log_debug("Started generalizer thread for '{}'.",
               master_generalizer->strategy());
-    pg_conn_t db_connection{conninfo};
+    pg_conn_t db_connection{connection_params};
     std::string const strategy{master_generalizer->strategy()};
     auto generalizer = create_generalizer(strategy, &db_connection, &params);
 
@@ -231,9 +232,9 @@ void run_tile_gen(std::string const &conninfo, gen_base_t *master_generalizer,
 class genproc_t
 {
 public:
-    genproc_t(std::string const &filename, std::string conninfo,
-              std::string dbschema, bool append, bool updatable,
-              uint32_t jobs);
+    genproc_t(std::string const &filename,
+              connection_params_t connection_params, std::string dbschema,
+              bool append, bool updatable, uint32_t jobs);
 
     int app_define_table()
     {
@@ -285,7 +286,7 @@ class genproc_t
         write_to_debug_log(params, "Params (config):");
 
         log_debug("Connecting to database...");
-        pg_conn_t db_connection{m_conninfo};
+        pg_conn_t db_connection{m_connection_params};
 
         log_debug("Creating generalizer...");
         auto generalizer =
@@ -367,7 +368,7 @@ class genproc_t
             queries.emplace_back("COMMIT");
         }
 
-        pg_conn_t const db_connection{m_conninfo};
+        pg_conn_t const db_connection{m_connection_params};
 
         if (m_append && !if_has_rows.empty()) {
             auto const result = db_connection.exec(if_has_rows);
@@ -495,8 +496,9 @@ class genproc_t
             for (unsigned int n = 1;
                  n <= std::min(m_jobs, static_cast<uint32_t>(tile_list.size()));
                  ++n) {
-                threads.emplace_back(run_tile_gen, m_conninfo, generalizer,
-                                     params, zoom, &tile_list, &mut, n);
+                threads.emplace_back(run_tile_gen, m_connection_params,
+                                     generalizer, params, zoom, &tile_list,
+                                     &mut, n);
             }
             for (auto &t : threads) {
                 t.join();
@@ -512,7 +514,7 @@ class genproc_t
     std::vector<flex_table_t> m_tables;
     std::vector<expire_output_t> m_expire_outputs;
 
-    std::string m_conninfo;
+    connection_params_t m_connection_params;
     std::string m_dbschema;
     uint32_t m_jobs;
     bool m_append;
@@ -524,11 +526,13 @@ TRAMPOLINE(app_define_expire_output, define_expire_output)
 TRAMPOLINE(app_run_gen, run_gen)
 TRAMPOLINE(app_run_sql, run_sql)
 
-genproc_t::genproc_t(std::string const &filename, std::string conninfo,
+genproc_t::genproc_t(std::string const &filename,
+                     connection_params_t connection_params,
                      std::string dbschema, bool append, bool updatable,
                      uint32_t jobs)
-: m_conninfo(std::move(conninfo)), m_dbschema(std::move(dbschema)),
-  m_jobs(jobs), m_append(append), m_updatable(updatable)
+: m_connection_params(std::move(connection_params)),
+  m_dbschema(std::move(dbschema)), m_jobs(jobs), m_append(append),
+  m_updatable(updatable)
 {
     setup_lua_environment(lua_state(), filename, append);
 
@@ -588,7 +592,7 @@ void genproc_t::run()
     }
 
     if (!m_append) {
-        pg_conn_t const db_connection{m_conninfo};
+        pg_conn_t const db_connection{m_connection_params};
         for (auto const &table : m_tables) {
             if (table.id_type() == flex_table_index_type::tile &&
                 (table.always_build_id_index() || m_updatable)) {
@@ -694,15 +698,15 @@ int main(int argc, char *argv[])
                 jobs);
         }
 
-        auto const conninfo = build_conninfo(app.database_options());
+        auto const connection_params = app.connection_params();
 
         log_debug("Checking database capabilities...");
         {
-            pg_conn_t const db_connection{conninfo};
+            pg_conn_t const db_connection{connection_params};
             init_database_capabilities(db_connection);
         }
 
-        properties_t properties{conninfo, middle_dbschema};
+        properties_t properties{connection_params, middle_dbschema};
         properties.load();
 
         if (style.empty()) {
@@ -719,7 +723,8 @@ int main(int argc, char *argv[])
         }
 
         bool const updatable = properties.get_bool("updatable", false);
-        genproc_t gen{style, conninfo, dbschema, append, updatable, jobs};
+        genproc_t gen{style,  connection_params, dbschema,
+                      append, updatable,         jobs};
         gen.run();
 
         osmium::MemoryUsage const mem;
diff --git a/src/middle-pgsql.cpp b/src/middle-pgsql.cpp
index b6f367816..b7ba57b53 100644
--- a/src/middle-pgsql.cpp
+++ b/src/middle-pgsql.cpp
@@ -159,7 +159,8 @@ void middle_pgsql_t::table_desc::drop_table(
              util::human_readable_duration(timer.stop()));
 }
 
-void middle_pgsql_t::table_desc::build_index(std::string const &conninfo) const
+void middle_pgsql_t::table_desc::build_index(
+    connection_params_t const &connection_params) const
 {
     if (m_create_fw_dep_indexes.empty()) {
         return;
@@ -167,7 +168,7 @@ void middle_pgsql_t::table_desc::build_index(std::string const &conninfo) const
 
     // Use a temporary connection here because we might run in a separate
     // thread context.
-    pg_conn_t const db_connection{conninfo};
+    pg_conn_t const db_connection{connection_params};
 
     log_info("Building index on table '{}'", name());
     for (auto const &query : m_create_fw_dep_indexes) {
@@ -1295,10 +1296,11 @@ void middle_pgsql_t::after_relations()
 }
 
 middle_query_pgsql_t::middle_query_pgsql_t(
-    std::string const &conninfo, std::shared_ptr<node_locations_t> cache,
+    connection_params_t const &connection_params,
+    std::shared_ptr<node_locations_t> cache,
     std::shared_ptr<node_persistent_cache> persistent_cache,
     middle_pgsql_options const &options)
-: m_sql_conn(conninfo), m_cache(std::move(cache)),
+: m_sql_conn(connection_params), 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
@@ -1407,7 +1409,7 @@ void middle_pgsql_t::stop()
         // Building the indexes takes time, so do it asynchronously.
         for (auto &table : m_tables) {
             table.task_set(thread_pool().submit(
-                [&]() { table.build_index(m_options->conninfo); }));
+                [&]() { table.build_index(m_options->connection_params); }));
         }
     }
 }
@@ -1647,8 +1649,8 @@ middle_pgsql_t::middle_pgsql_t(std::shared_ptr<thread_pool_t> thread_pool,
 : middle_t(std::move(thread_pool)), m_options(options),
   m_cache(std::make_unique<node_locations_t>(
       static_cast<std::size_t>(options->cache) * 1024UL * 1024UL)),
-  m_db_connection(m_options->conninfo),
-  m_copy_thread(std::make_shared<db_copy_thread_t>(options->conninfo)),
+  m_db_connection(m_options->connection_params),
+  m_copy_thread(std::make_shared<db_copy_thread_t>(options->connection_params)),
   m_db_copy(m_copy_thread), m_append(options->append)
 {
     m_store_options.with_attributes = options->extra_attributes;
@@ -1723,7 +1725,8 @@ middle_pgsql_t::get_query_instance()
     // NOTE: this is thread safe for use in pending async processing only
     // because during that process they are only read from
     auto mid = std::make_unique<middle_query_pgsql_t>(
-        m_options->conninfo, m_cache, m_persistent_cache, m_store_options);
+        m_options->connection_params, m_cache, m_persistent_cache,
+        m_store_options);
 
     // We use a connection per table to enable the use of COPY
     for (auto &table : m_tables) {
diff --git a/src/middle-pgsql.hpp b/src/middle-pgsql.hpp
index 3f81dcd5a..34403272b 100644
--- a/src/middle-pgsql.hpp
+++ b/src/middle-pgsql.hpp
@@ -55,7 +55,8 @@ class middle_query_pgsql_t : public middle_query_t
 {
 public:
     middle_query_pgsql_t(
-        std::string const &conninfo, std::shared_ptr<node_locations_t> cache,
+        connection_params_t const &connection_params,
+        std::shared_ptr<node_locations_t> cache,
         std::shared_ptr<node_persistent_cache> persistent_cache,
         middle_pgsql_options const &options);
 
@@ -150,7 +151,7 @@ struct middle_pgsql_t : public middle_t
         void drop_table(pg_conn_t const &db_connection) const;
 
         ///< Open a new database connection and build index on this table.
-        void build_index(std::string const &conninfo) const;
+        void build_index(connection_params_t const &connection_params) const;
 
         std::string m_create_table;
         std::vector<std::string> m_prepare_queries;
diff --git a/src/options.hpp b/src/options.hpp
index 7b4c63b01..458927d95 100644
--- a/src/options.hpp
+++ b/src/options.hpp
@@ -10,6 +10,8 @@
  * For a full list of authors see the git log.
  */
 
+#include "pgsql-params.hpp"
+
 #include <osmium/osm/box.hpp>
 
 #include <cstdint>
@@ -37,18 +39,6 @@ enum class hstore_column : char
     all = 2
 };
 
-/// Database connection options.
-struct database_options_t
-{
-    std::string db;
-    std::string username;
-    std::string host;
-    std::string password;
-    std::string port;
-};
-
-std::string build_conninfo(database_options_t const &opt);
-
 /**
  * Structure for storing command-line and other options
  */
@@ -56,7 +46,8 @@ struct options_t
 {
     command_t command = command_t::process;
 
-    std::string conninfo; ///< connection info for database
+    /// Parameters for initializing database connections
+    connection_params_t connection_params;
 
     std::string prefix{"planet_osm"};         ///< prefix for table names
     bool prefix_is_set = false;
diff --git a/src/osm2pgsql.cpp b/src/osm2pgsql.cpp
index 46e0c57d8..209c98f52 100644
--- a/src/osm2pgsql.cpp
+++ b/src/osm2pgsql.cpp
@@ -86,7 +86,7 @@ static file_info run(options_t const &options)
 
 static void check_db(options_t const &options)
 {
-    pg_conn_t const db_connection{options.conninfo};
+    pg_conn_t const db_connection{options.connection_params};
 
     init_database_capabilities(db_connection);
 
@@ -372,7 +372,8 @@ int main(int argc, char *argv[])
 
         check_db(options);
 
-        properties_t properties{options.conninfo, options.middle_dbschema};
+        properties_t properties{options.connection_params,
+                                options.middle_dbschema};
         if (options.append) {
             if (properties.load()) {
                 check_and_update_properties(&properties, &options);
diff --git a/src/osmdata.cpp b/src/osmdata.cpp
index c7709e4b2..0779a6c8b 100644
--- a/src/osmdata.cpp
+++ b/src/osmdata.cpp
@@ -30,7 +30,7 @@ osmdata_t::osmdata_t(std::unique_ptr<dependency_manager_t> dependency_manager,
                      std::shared_ptr<middle_t> mid,
                      std::shared_ptr<output_t> output, options_t const &options)
 : m_dependency_manager(std::move(dependency_manager)), m_mid(std::move(mid)),
-  m_output(std::move(output)), m_conninfo(options.conninfo),
+  m_output(std::move(output)), m_connection_params(options.connection_params),
   m_bbox(options.bbox), m_num_procs(options.num_procs),
   m_append(options.append), m_droptemp(options.droptemp),
   m_with_extra_attrs(options.extra_attributes),
@@ -171,7 +171,7 @@ namespace {
 class multithreaded_processor
 {
 public:
-    multithreaded_processor(std::string const &conninfo,
+    multithreaded_processor(connection_params_t const &connection_params,
                             std::shared_ptr<middle_t> const &mid,
                             std::shared_ptr<output_t> output,
                             std::size_t thread_count)
@@ -183,7 +183,8 @@ class multithreaded_processor
         // For each thread we create a clone of the output.
         for (std::size_t i = 0; i < thread_count; ++i) {
             auto const midq = mid->get_query_instance();
-            auto copy_thread = std::make_shared<db_copy_thread_t>(conninfo);
+            auto copy_thread =
+                std::make_shared<db_copy_thread_t>(connection_params);
             m_clones.push_back(m_output->clone(midq, copy_thread));
         }
     }
@@ -350,7 +351,8 @@ class multithreaded_processor
 
 void osmdata_t::process_dependents() const
 {
-    multithreaded_processor proc{m_conninfo, m_mid, m_output, m_num_procs};
+    multithreaded_processor proc{m_connection_params, m_mid, m_output,
+                                 m_num_procs};
 
     // stage 1b processing: process parents of changed objects
     if (m_dependency_manager->has_pending()) {
diff --git a/src/osmdata.hpp b/src/osmdata.hpp
index 0da8d7f17..78b6ddee1 100644
--- a/src/osmdata.hpp
+++ b/src/osmdata.hpp
@@ -25,6 +25,7 @@
 
 #include "dependency-manager.hpp"
 #include "osmtypes.hpp"
+#include "pgsql-params.hpp"
 
 class middle_t;
 class output_t;
@@ -79,7 +80,7 @@ class osmdata_t : public osmium::handler::Handler
     std::shared_ptr<middle_t> m_mid;
     std::shared_ptr<output_t> m_output;
 
-    std::string m_conninfo;
+    connection_params_t m_connection_params;
 
     // Bounding box for node import (or invalid Box if everything should be
     // imported).
diff --git a/src/output-flex.cpp b/src/output-flex.cpp
index 2d2418a4f..7ead87e24 100644
--- a/src/output-flex.cpp
+++ b/src/output-flex.cpp
@@ -1086,8 +1086,9 @@ void output_flex_t::stop()
         if (!m_expire_tiles[i].empty()) {
             auto const &eo = (*m_expire_outputs)[i];
 
-            std::size_t const count = eo.output(m_expire_tiles[i].get_tiles(),
-                                                get_options()->conninfo);
+            std::size_t const count =
+                eo.output(m_expire_tiles[i].get_tiles(),
+                          get_options()->connection_params);
 
             log_info("Wrote {} entries to expire output [{}].", count, i);
         }
@@ -1224,14 +1225,14 @@ void output_flex_t::relation_modify(osmium::Relation const &rel)
 void output_flex_t::start()
 {
     for (auto &table : m_table_connections) {
-        table.connect(get_options()->conninfo);
+        table.connect(get_options()->connection_params);
         table.start(get_options()->append);
     }
 }
 
 static void
 create_expire_tables(std::vector<expire_output_t> const &expire_outputs,
-                     std::string const &conninfo)
+                     connection_params_t const &connection_params)
 {
     if (std::all_of(expire_outputs.begin(), expire_outputs.end(),
                     [](auto const &expire_output) {
@@ -1240,7 +1241,7 @@ create_expire_tables(std::vector<expire_output_t> const &expire_outputs,
         return;
     }
 
-    pg_conn_t const connection{conninfo};
+    pg_conn_t const connection{connection_params};
     for (auto const &expire_output : expire_outputs) {
         if (!expire_output.table().empty()) {
             expire_output.create_output_table(connection);
@@ -1261,7 +1262,7 @@ output_flex_t::output_flex_t(output_flex_t const *other,
 {
     for (auto &table : *m_tables) {
         auto &tc = m_table_connections.emplace_back(&table, m_copy_thread);
-        tc.connect(get_options()->conninfo);
+        tc.connect(get_options()->connection_params);
         tc.prepare();
     }
 
@@ -1282,7 +1283,7 @@ output_flex_t::output_flex_t(std::shared_ptr<middle_query_t> const &mid,
                              std::shared_ptr<thread_pool_t> thread_pool,
                              options_t const &options)
 : output_t(mid, std::move(thread_pool), options),
-  m_copy_thread(std::make_shared<db_copy_thread_t>(options.conninfo))
+  m_copy_thread(std::make_shared<db_copy_thread_t>(options.connection_params))
 {
     init_lua(options.style);
 
@@ -1331,7 +1332,7 @@ output_flex_t::output_flex_t(std::shared_ptr<middle_query_t> const &mid,
                                     reprojection::create_projection(3857));
     }
 
-    create_expire_tables(*m_expire_outputs, get_options()->conninfo);
+    create_expire_tables(*m_expire_outputs, get_options()->connection_params);
 }
 
 /**
diff --git a/src/output-gazetteer.cpp b/src/output-gazetteer.cpp
index 044bbbdbe..da41974f5 100644
--- a/src/output-gazetteer.cpp
+++ b/src/output-gazetteer.cpp
@@ -49,7 +49,7 @@ void output_gazetteer_t::start()
     if (!get_options()->append) {
         int const srid = get_options()->projection->target_srs();
 
-        pg_conn_t const conn{get_options()->conninfo};
+        pg_conn_t const conn{get_options()->connection_params};
 
         /* Drop any existing table */
         conn.exec("DROP TABLE IF EXISTS place CASCADE");
diff --git a/src/output-gazetteer.hpp b/src/output-gazetteer.hpp
index a068984a6..6f427d6be 100644
--- a/src/output-gazetteer.hpp
+++ b/src/output-gazetteer.hpp
@@ -16,6 +16,7 @@
 #include <osmium/memory/buffer.hpp>
 
 #include "gazetteer-style.hpp"
+#include "options.hpp"
 #include "osmtypes.hpp"
 #include "output.hpp"
 #include "reprojection.hpp"
@@ -34,7 +35,7 @@ class output_gazetteer_t : public output_t
                        std::shared_ptr<thread_pool_t> thread_pool,
                        options_t const &options)
     : output_t(mid, std::move(thread_pool), options),
-      m_copy(std::make_shared<db_copy_thread_t>(options.conninfo)),
+      m_copy(std::make_shared<db_copy_thread_t>(options.connection_params)),
       m_proj(options.projection)
     {
         m_style.load_style(options.style);
diff --git a/src/output-pgsql.cpp b/src/output-pgsql.cpp
index 40fa608db..9f2fc621d 100644
--- a/src/output-pgsql.cpp
+++ b/src/output-pgsql.cpp
@@ -418,7 +418,8 @@ void output_pgsql_t::start()
 {
     for (auto &t : m_tables) {
         //setup the table in postgres
-        t->start(get_options()->conninfo, get_options()->tblsmain_data);
+        t->start(get_options()->connection_params,
+                 get_options()->tblsmain_data);
     }
 }
 
@@ -451,7 +452,8 @@ output_pgsql_t::output_pgsql_t(std::shared_ptr<middle_query_t> const &mid,
 
     m_tagtransform = tagtransform_t::make_tagtransform(&options, exlist);
 
-    auto copy_thread = std::make_shared<db_copy_thread_t>(options.conninfo);
+    auto copy_thread =
+        std::make_shared<db_copy_thread_t>(options.connection_params);
 
     //for each table
     for (std::size_t i = 0; i < m_tables.size(); ++i) {
diff --git a/src/pgsql-params.hpp b/src/pgsql-params.hpp
new file mode 100644
index 000000000..fd0230d96
--- /dev/null
+++ b/src/pgsql-params.hpp
@@ -0,0 +1,42 @@
+#ifndef OSM2PGSQL_PGSQL_PARAMS_HPP
+#define OSM2PGSQL_PGSQL_PARAMS_HPP
+
+/**
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * This file is part of osm2pgsql (https://osm2pgsql.org/).
+ *
+ * Copyright (C) 2006-2024 by the osm2pgsql developer community.
+ * For a full list of authors see the git log.
+ */
+
+#include "format.hpp"
+
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+/**
+ * PostgreSQL connection parameters.
+ */
+class connection_params_t
+{
+public:
+    connection_params_t() { m_params["client_encoding"] = "UTF8"; }
+
+    void set(std::string const &param, std::string const &value)
+    {
+        m_params[param] = value;
+    }
+
+    auto begin() const noexcept { return m_params.begin(); }
+
+    auto end() const noexcept { return m_params.end(); }
+
+private:
+    std::map<std::string, std::string> m_params;
+
+}; // class connection_params_t
+
+#endif // OSM2PGSQL_PGSQL_PARAMS_HPP
diff --git a/src/pgsql.cpp b/src/pgsql.cpp
index 13866bf99..617470621 100644
--- a/src/pgsql.cpp
+++ b/src/pgsql.cpp
@@ -28,13 +28,36 @@ std::size_t pg_result_t::affected_rows() const noexcept
 
 std::atomic<std::uint32_t> pg_conn_t::connection_id{0};
 
-pg_conn_t::pg_conn_t(std::string const &conninfo)
-: m_conn(PQconnectdb(conninfo.c_str())),
-  m_connection_id(connection_id.fetch_add(1))
+static PGconn *open_connection(connection_params_t const &connection_params,
+                               std::uint32_t id)
 {
+    std::vector<char const *> keywords;
+    std::vector<char const *> values;
+
+    for (auto const &[k, v] : connection_params) {
+        keywords.push_back(k.c_str());
+        values.push_back(v.c_str());
+    }
+
+    std::string const app_name{fmt::format("osm2pgsql/C{}", id)};
+    keywords.push_back("fallback_application_name");
+    values.push_back(app_name.c_str());
+
+    keywords.push_back(nullptr);
+    values.push_back(nullptr);
+
+    return PQconnectdbParams(keywords.data(), values.data(), 1);
+}
+
+pg_conn_t::pg_conn_t(connection_params_t const &connection_params)
+: m_connection_id(connection_id.fetch_add(1))
+{
+    m_conn.reset(open_connection(connection_params, m_connection_id));
+
     if (!m_conn) {
         throw std::runtime_error{"Connecting to database failed."};
     }
+
     if (PQstatus(m_conn.get()) != CONNECTION_OK) {
         throw fmt_error("Connecting to database failed: {}.", error_msg());
     }
diff --git a/src/pgsql.hpp b/src/pgsql.hpp
index 9e653fc91..4774602a8 100644
--- a/src/pgsql.hpp
+++ b/src/pgsql.hpp
@@ -17,6 +17,7 @@
  */
 
 #include "format.hpp"
+#include "pgsql-params.hpp"
 
 #include <libpq-fe.h>
 
@@ -151,7 +152,7 @@ class binary_param : public std::string_view
 class pg_conn_t
 {
 public:
-    explicit pg_conn_t(std::string const &conninfo);
+    explicit pg_conn_t(connection_params_t const &connection_params);
 
     /**
      * Run the specified SQL command.
diff --git a/src/properties.cpp b/src/properties.cpp
index aa154d859..393b95db3 100644
--- a/src/properties.cpp
+++ b/src/properties.cpp
@@ -19,8 +19,10 @@
 
 static constexpr char const *const properties_table = "osm2pgsql_properties";
 
-properties_t::properties_t(std::string conninfo, std::string schema)
-: m_conninfo(std::move(conninfo)), m_schema(std::move(schema)),
+properties_t::properties_t(connection_params_t connection_params,
+                           std::string schema)
+: m_connection_params(std::move(connection_params)),
+  m_schema(std::move(schema)),
   m_has_properties_table(has_table(m_schema, properties_table))
 {
     assert(!m_schema.empty());
@@ -90,7 +92,7 @@ void properties_t::set_string(std::string property, std::string value,
     auto const &inserted = *(r.first);
     log_debug("  Storing {}='{}'", inserted.first, inserted.second);
 
-    pg_conn_t const db_connection{m_conninfo};
+    pg_conn_t const db_connection{m_connection_params};
     db_connection.exec(
         "PREPARE set_property(text, text) AS"
         " INSERT INTO {} (property, value) VALUES ($1, $2)"
@@ -117,7 +119,7 @@ void properties_t::store()
     auto const table = table_name();
 
     log_info("Storing properties to table '{}'.", table);
-    pg_conn_t const db_connection{m_conninfo};
+    pg_conn_t const db_connection{m_connection_params};
 
     if (m_has_properties_table) {
         db_connection.exec("TRUNCATE {}", table);
@@ -151,7 +153,7 @@ bool properties_t::load()
     auto const table = table_name();
     log_info("Loading properties from table '{}'.", table);
 
-    pg_conn_t const db_connection{m_conninfo};
+    pg_conn_t const db_connection{m_connection_params};
     auto const result = db_connection.exec("SELECT * FROM {}", table);
 
     for (int i = 0; i < result.num_tuples(); ++i) {
diff --git a/src/properties.hpp b/src/properties.hpp
index e8324c4c8..f8339da9f 100644
--- a/src/properties.hpp
+++ b/src/properties.hpp
@@ -18,6 +18,8 @@
  * configuration consistent between imports and updates.
  */
 
+#include "pgsql-params.hpp"
+
 #include <cstdint>
 #include <map>
 #include <string>
@@ -30,12 +32,12 @@ class properties_t
     /**
      * Create new properties store.
      *
-     * \param conninfo Connection info used to connect to the database.
+     * \param connection_params Parameters used to connect to the database.
      * \param schema The schema used for storing the data,
      *
      * \pre You must have called init_database_capabilities() before this.
      */
-    properties_t(std::string conninfo, std::string schema);
+    properties_t(connection_params_t connection_params, std::string schema);
 
     std::string get_string(std::string const &property,
                            std::string const &default_value) const;
@@ -95,7 +97,7 @@ class properties_t
     std::string table_name() const;
 
     std::map<std::string, std::string> m_properties;
-    std::string m_conninfo;
+    connection_params_t m_connection_params;
     std::string m_schema;
     bool m_has_properties_table;
 
diff --git a/src/table.cpp b/src/table.cpp
index d8f8b446c..f0d021180 100644
--- a/src/table.cpp
+++ b/src/table.cpp
@@ -45,8 +45,8 @@ table_t::table_t(std::string const &name, std::string type, columns_t columns,
 
 table_t::table_t(table_t const &other,
                  std::shared_ptr<db_copy_thread_t> const &copy_thread)
-: m_conninfo(other.m_conninfo), m_target(other.m_target), m_type(other.m_type),
-  m_srid(other.m_srid), m_append(other.m_append),
+: m_connection_params(other.m_connection_params), m_target(other.m_target),
+  m_type(other.m_type), m_srid(other.m_srid), m_append(other.m_append),
   m_hstore_mode(other.m_hstore_mode), m_columns(other.m_columns),
   m_hstore_columns(other.m_hstore_columns), m_table_space(other.m_table_space),
   m_copy(copy_thread)
@@ -66,19 +66,20 @@ void table_t::sync() { m_copy.sync(); }
 
 void table_t::connect()
 {
-    m_sql_conn = std::make_unique<pg_conn_t>(m_conninfo);
+    m_sql_conn = std::make_unique<pg_conn_t>(m_connection_params);
     //let commits happen faster by delaying when they actually occur
     m_sql_conn->exec("SET synchronous_commit = off");
 }
 
-void table_t::start(std::string const &conninfo, std::string const &table_space)
+void table_t::start(connection_params_t const &connection_params,
+                    std::string const &table_space)
 {
     if (m_sql_conn) {
         throw fmt_error("{} cannot start, its already started.",
                         m_target->name());
     }
 
-    m_conninfo = conninfo;
+    m_connection_params = connection_params;
     m_table_space = tablespace_clause(table_space);
 
     connect();
diff --git a/src/table.hpp b/src/table.hpp
index 1b42d7abb..3cfb8ab4a 100644
--- a/src/table.hpp
+++ b/src/table.hpp
@@ -37,7 +37,8 @@ class table_t
     table_t(table_t const &other,
             std::shared_ptr<db_copy_thread_t> const &copy_thread);
 
-    void start(std::string const &conninfo, std::string const &table_space);
+    void start(connection_params_t const &connection_params,
+               std::string const &table_space);
     void stop(bool updateable, bool enable_hstore_index,
               std::string const &table_space_index);
 
@@ -69,7 +70,7 @@ class table_t
 
     void generate_copy_column_list();
 
-    std::string m_conninfo;
+    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;
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 099c34a92..5288cce41 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -59,7 +59,6 @@ set_test(test-geom-transform LABELS NoDB)
 set_test(test-json-writer LABELS NoDB)
 set_test(test-middle)
 set_test(test-node-locations LABELS NoDB)
-set_test(test-options-database LABELS NoDB)
 set_test(test-options-parse LABELS NoDB)
 set_test(test-options-projection)
 set_test(test-ordered-index LABELS NoDB)
diff --git a/tests/common-import.hpp b/tests/common-import.hpp
index 35abc1651..9fc7bb325 100644
--- a/tests/common-import.hpp
+++ b/tests/common-import.hpp
@@ -134,7 +134,7 @@ class import_t
                     std::initializer_list<std::string> input_data,
                     std::string const &format = "opl")
     {
-        options.conninfo = m_db.conninfo();
+        options.connection_params = m_db.connection_params();
 
         auto thread_pool = std::make_shared<thread_pool_t>(1U);
         auto middle = create_middle(thread_pool, options);
@@ -173,7 +173,7 @@ class import_t
 
     void run_file(options_t options, char const *file = nullptr)
     {
-        options.conninfo = m_db.conninfo();
+        options.connection_params = m_db.connection_params();
 
         auto thread_pool = std::make_shared<thread_pool_t>(1U);
         auto middle = std::make_shared<middle_ram_t>(thread_pool, &options);
diff --git a/tests/common-options.hpp b/tests/common-options.hpp
index 5a4582eaa..446289a62 100644
--- a/tests/common-options.hpp
+++ b/tests/common-options.hpp
@@ -44,7 +44,7 @@ class opt_t
     opt_t &slim(testing::pg::tempdb_t const &db)
     {
         m_opt.slim = true;
-        m_opt.conninfo = db.conninfo();
+        m_opt.connection_params = db.connection_params();
         return *this;
     }
 
diff --git a/tests/common-pg.hpp b/tests/common-pg.hpp
index bed23944f..2113fd23f 100644
--- a/tests/common-pg.hpp
+++ b/tests/common-pg.hpp
@@ -37,7 +37,10 @@ namespace testing::pg {
 class conn_t : public pg_conn_t
 {
 public:
-    conn_t(std::string const &conninfo) : pg_conn_t(conninfo) {}
+    conn_t(connection_params_t const &connection_params)
+    : pg_conn_t(connection_params)
+    {
+    }
 
     std::string result_as_string(std::string const &cmd) const
     {
@@ -100,7 +103,9 @@ class tempdb_t
     tempdb_t() noexcept
     {
         try {
-            conn_t conn{"dbname=postgres"};
+            connection_params_t connection_params;
+            connection_params.set("dbname", "postgres");
+            conn_t conn{connection_params};
 
             m_db_name =
                 fmt::format("osm2pgsql-test-{}-{}", getpid(), time(nullptr));
@@ -138,7 +143,9 @@ class tempdb_t
                 return;
             }
             try {
-                conn_t conn{"dbname=postgres"};
+                connection_params_t connection_params;
+                connection_params.set("dbname", "postgres");
+                conn_t conn{connection_params};
                 conn.exec(R"(DROP DATABASE IF EXISTS "{}")", m_db_name);
             } catch (...) {
                 fprintf(stderr, "DROP DATABASE failed. Ignored.\n");
@@ -146,9 +153,13 @@ class tempdb_t
         }
     }
 
-    conn_t connect() const { return conn_t{conninfo()}; }
+    conn_t connect() const { return conn_t{connection_params()}; }
 
-    std::string conninfo() const { return "dbname=" + m_db_name; }
+    connection_params_t connection_params() const {
+        connection_params_t params;
+        params.set("dbname", m_db_name);
+        return params;
+    }
 
 private:
     std::string m_db_name;
diff --git a/tests/test-db-copy-mgr.cpp b/tests/test-db-copy-mgr.cpp
index 2aec343af..ef9df4bfc 100644
--- a/tests/test-db-copy-mgr.cpp
+++ b/tests/test-db-copy-mgr.cpp
@@ -89,7 +89,7 @@ static void check_row(std::vector<std::string> const &row)
 
 TEST_CASE("copy_mgr_t: Insert null")
 {
-    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.conninfo())};
+    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.connection_params())};
 
     auto const t = setup_table("big int8, t text");
 
@@ -109,7 +109,7 @@ TEST_CASE("copy_mgr_t: Insert null")
 
 TEST_CASE("copy_mgr_t: Insert numbers")
 {
-    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.conninfo())};
+    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.connection_params())};
 
     auto const t = setup_table("big int8, small smallint");
 
@@ -119,7 +119,7 @@ TEST_CASE("copy_mgr_t: Insert numbers")
 
 TEST_CASE("copy_mgr_t: Insert strings")
 {
-    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.conninfo())};
+    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.connection_params())};
 
     auto const t = setup_table("s0 text, s1 varchar");
 
@@ -150,7 +150,7 @@ TEST_CASE("copy_mgr_t: Insert strings")
 
 TEST_CASE("copy_mgr_t: Insert int arrays")
 {
-    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.conninfo())};
+    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.connection_params())};
 
     auto const t = setup_table("a int[]");
 
@@ -160,7 +160,7 @@ TEST_CASE("copy_mgr_t: Insert int arrays")
 
 TEST_CASE("copy_mgr_t: Insert string arrays")
 {
-    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.conninfo())};
+    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.connection_params())};
 
     auto const t = setup_table("a text[]");
 
@@ -183,7 +183,7 @@ TEST_CASE("copy_mgr_t: Insert string arrays")
 
 TEST_CASE("copy_mgr_t: Insert hashes")
 {
-    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.conninfo())};
+    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.connection_params())};
 
     auto const t = setup_table("h hstore");
 
@@ -206,7 +206,7 @@ TEST_CASE("copy_mgr_t: Insert hashes")
 
 TEST_CASE("copy_mgr_t: Insert something and roll back")
 {
-    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.conninfo())};
+    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.connection_params())};
 
     auto const t = setup_table("t text");
 
@@ -223,7 +223,7 @@ TEST_CASE("copy_mgr_t: Insert something and roll back")
 TEST_CASE("copy_mgr_t: Insert something, insert more, roll back, insert "
           "something else")
 {
-    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.conninfo())};
+    copy_mgr_t mgr{std::make_shared<db_copy_thread_t>(db.connection_params())};
 
     auto const t = setup_table("t text");
 
diff --git a/tests/test-db-copy-thread.cpp b/tests/test-db-copy-thread.cpp
index 2932817f2..9cfd30c61 100644
--- a/tests/test-db-copy-thread.cpp
+++ b/tests/test-db-copy-thread.cpp
@@ -30,7 +30,7 @@ TEST_CASE("db_copy_thread_t with db_deleter_by_id_t")
     auto const table =
         std::make_shared<db_target_descr_t>("public", "test_copy_thread", "id");
 
-    db_copy_thread_t t(db.conninfo());
+    db_copy_thread_t t{db.connection_params()};
     using cmd_copy_t = db_cmd_copy_delete_t<db_deleter_by_id_t>;
     auto cmd = std::make_unique<cmd_copy_t>(table);
 
@@ -159,7 +159,7 @@ TEST_CASE("db_copy_thread_t with db_deleter_place_t")
     auto table = std::make_shared<db_target_descr_t>(
         "public", "test_copy_thread", "place_id");
 
-    db_copy_thread_t t(db.conninfo());
+    db_copy_thread_t t{db.connection_params()};
     using cmd_copy_t = db_cmd_copy_delete_t<db_deleter_place_t>;
     auto cmd = std::make_unique<cmd_copy_t>(table);
 
diff --git a/tests/test-options-database.cpp b/tests/test-options-database.cpp
deleted file mode 100644
index 6fd652adb..000000000
--- a/tests/test-options-database.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/**
- * SPDX-License-Identifier: GPL-2.0-or-later
- *
- * This file is part of osm2pgsql (https://osm2pgsql.org/).
- *
- * Copyright (C) 2006-2024 by the osm2pgsql developer community.
- * For a full list of authors see the git log.
- */
-
-#include <catch.hpp>
-
-#include "options.hpp"
-
-/**
- * Tests that the conninfo strings are appropriately generated
- * This test is stricter than it needs to be, as it also cares about order,
- * but the current implementation always uses the same order, and attempting to
- * parse a conninfo string is complex.
- */
-TEST_CASE("Connection info parsing with dbname", "[NoDB]")
-{
-    database_options_t db;
-    CHECK(build_conninfo(db) ==
-          "fallback_application_name='osm2pgsql' client_encoding='UTF8'");
-    db.db = "foo";
-    CHECK(build_conninfo(db) == "fallback_application_name='osm2pgsql' "
-                                "client_encoding='UTF8' dbname='foo'");
-}
-
-TEST_CASE("Connection info parsing with user", "[NoDB]")
-{
-    database_options_t db;
-    db.username = "bar";
-    CHECK(build_conninfo(db) == "fallback_application_name='osm2pgsql' "
-                                "client_encoding='UTF8' user='bar'");
-}
-
-TEST_CASE("Connection info parsing with password", "[NoDB]")
-{
-    database_options_t db;
-    db.password = "bar";
-    CHECK(build_conninfo(db) == "fallback_application_name='osm2pgsql' "
-                                "client_encoding='UTF8' password='bar'");
-}
-
-TEST_CASE("Connection info parsing with host", "[NoDB]")
-{
-    database_options_t db;
-    db.host = "bar";
-    CHECK(build_conninfo(db) == "fallback_application_name='osm2pgsql' "
-                                "client_encoding='UTF8' host='bar'");
-}
-
-TEST_CASE("Connection info parsing with port", "[NoDB]")
-{
-    database_options_t db;
-    db.port = "bar";
-    CHECK(build_conninfo(db) == "fallback_application_name='osm2pgsql' "
-                                "client_encoding='UTF8' port='bar'");
-}
-
-TEST_CASE("Connection info parsing with complete info", "[NoDB]")
-{
-    database_options_t db;
-    db.db = "foo";
-    db.username = "bar";
-    db.password = "baz";
-    db.host = "bzz";
-    db.port = "123";
-    CHECK(build_conninfo(db) ==
-          "fallback_application_name='osm2pgsql' client_encoding='UTF8' "
-          "dbname='foo' "
-          "user='bar' password='baz' host='bzz' port='123'");
-}
diff --git a/tests/test-properties.cpp b/tests/test-properties.cpp
index b35ccb0fa..1e1aa5b91 100644
--- a/tests/test-properties.cpp
+++ b/tests/test-properties.cpp
@@ -15,7 +15,7 @@
 
 TEST_CASE("Store and retrieve properties (memory only)")
 {
-    properties_t properties{"", "public"};
+    properties_t properties{connection_params_t{}, "public"};
 
     properties.set_string("foo", "firstvalue");
     properties.set_string("foo", "bar"); // overwriting is okay
@@ -52,7 +52,7 @@ TEST_CASE("Store and retrieve properties (with database)")
         }
 
         {
-            properties_t properties{db.conninfo(), schema};
+            properties_t properties{db.connection_params(), schema};
 
             properties.set_string("foo", "bar");
             properties.set_string("empty", "");
@@ -77,7 +77,7 @@ TEST_CASE("Store and retrieve properties (with database)")
             REQUIRE(conn.get_count(full_table_name,
                                    "property='decide' AND value='true'") == 1);
 
-            properties_t properties{db.conninfo(), schema};
+            properties_t properties{db.connection_params(), schema};
             REQUIRE(properties.load());
 
             REQUIRE(properties.get_string("foo", "baz") == "bar");
@@ -106,7 +106,7 @@ TEST_CASE("Update existing properties in database")
     auto conn = db.connect();
 
     {
-        properties_t properties{db.conninfo(), "public"};
+        properties_t properties{db.connection_params(), "public"};
 
         properties.set_string("a", "xxx");
         properties.set_string("b", "yyy");
@@ -118,7 +118,7 @@ TEST_CASE("Update existing properties in database")
         init_database_capabilities(conn);
         REQUIRE(conn.get_count("osm2pgsql_properties") == 2);
 
-        properties_t properties{db.conninfo(), "public"};
+        properties_t properties{db.connection_params(), "public"};
         REQUIRE(properties.load());
 
         REQUIRE(properties.get_string("a", "def") == "xxx");
@@ -135,7 +135,7 @@ TEST_CASE("Update existing properties in database")
     {
         REQUIRE(conn.get_count("osm2pgsql_properties") == 2);
 
-        properties_t properties{db.conninfo(), "public"};
+        properties_t properties{db.connection_params(), "public"};
         REQUIRE(properties.load());
 
         // only "b" was updated in the database
@@ -150,6 +150,6 @@ TEST_CASE("Load returns false if there are no properties in database")
     auto conn = db.connect();
     init_database_capabilities(conn);
 
-    properties_t properties{db.conninfo(), "public"};
+    properties_t properties{db.connection_params(), "public"};
     REQUIRE_FALSE(properties.load());
 }