Rename pkg db tables, and fix logging typo

src/dds/pkg/db.cpp

 
 void migrate_repodb_3(nsql::database& db) {
     db.exec(R"(
-        CREATE TABLE dds_cat_remotes (
+        CREATE TABLE dds_pkg_remotes (
             remote_id INTEGER PRIMARY KEY AUTOINCREMENT,
             name TEXT NOT NULL UNIQUE,
             remote_url TEXT NOT NULL,
             db_mtime TEXT
         );
 
-        CREATE TABLE dds_cat_pkgs_new (
+        CREATE TABLE dds_pkgs (
             pkg_id INTEGER PRIMARY KEY AUTOINCREMENT,
             name TEXT NOT NULL,
             version TEXT NOT NULL,
             description TEXT NOT NULL,
             remote_url TEXT NOT NULL,
             remote_id INTEGER
-                REFERENCES dds_cat_remotes
+                REFERENCES dds_pkg_remotes
                 ON DELETE CASCADE,
             UNIQUE (name, version, remote_id)
         );
 
-        INSERT INTO dds_cat_pkgs_new(pkg_id,
-                                     name,
-                                     version,
-                                     description,
-                                     remote_url)
+        INSERT INTO dds_pkgs(pkg_id,
+                             name,
+                             version,
+                             description,
+                             remote_url)
             SELECT pkg_id,
                    name,
                    version,
                    ) || '#' || git_ref
             FROM dds_cat_pkgs;
 
-        CREATE TABLE dds_cat_pkg_deps_new (
+        CREATE TABLE dds_pkg_deps (
             dep_id INTEGER PRIMARY KEY AUTOINCREMENT,
             pkg_id INTEGER
                 NOT NULL
-                REFERENCES dds_cat_pkgs_new(pkg_id)
+                REFERENCES dds_pkgs(pkg_id)
                 ON DELETE CASCADE,
             dep_name TEXT NOT NULL,
             low TEXT NOT NULL,
             UNIQUE(pkg_id, dep_name)
         );
 
-        INSERT INTO dds_cat_pkg_deps_new SELECT * FROM dds_cat_pkg_deps;
+        INSERT INTO dds_pkg_deps SELECT * FROM dds_cat_pkg_deps;
 
         DROP TABLE dds_cat_pkg_deps;
         DROP TABLE dds_cat_pkgs;
-        ALTER TABLE dds_cat_pkgs_new RENAME TO dds_cat_pkgs;
-        ALTER TABLE dds_cat_pkg_deps_new RENAME TO dds_cat_pkg_deps;
     )");
 }
 
                        const http_remote_listing&     http) {
     nsql::exec(  //
         stmts(R"(
-            INSERT OR REPLACE INTO dds_cat_pkgs (
+            INSERT OR REPLACE INTO dds_pkgs (
                 name,
                 version,
                 remote_url,
 
     nsql::exec(  //
         stmts(R"(
-            INSERT OR REPLACE INTO dds_cat_pkgs (
+            INSERT OR REPLACE INTO dds_pkgs (
                 name,
                 version,
                 remote_url,
     std::visit([&](auto&& remote) { store_with_remote(st_cache, pkg, remote); }, pkg.remote);
     auto  db_pkg_id  = db.last_insert_rowid();
     auto& new_dep_st = st_cache(R"(
-        INSERT INTO dds_cat_pkg_deps (
+        INSERT INTO dds_pkg_deps (
             pkg_id,
             dep_name,
             low,
             version,
             remote_url,
             description
-        FROM dds_cat_pkgs
+        FROM dds_pkgs
         WHERE name = ?1 AND version = ?2
         ORDER BY pkg_id DESC
     )"_sql);
 
 std::vector<pkg_id> pkg_db::all() const noexcept {
     return nsql::exec_tuples<std::string, std::string>(
-               _stmt_cache("SELECT name, version FROM dds_cat_pkgs"_sql))
+               _stmt_cache("SELECT name, version FROM dds_pkgs"_sql))
         | neo::lref                                 //
         | ranges::views::transform(pair_to_pkg_id)  //
         | ranges::to_vector;
                _stmt_cache(
                    R"(
                 SELECT name, version
-                  FROM dds_cat_pkgs
+                  FROM dds_pkgs
                  WHERE name = ?
                  ORDER BY pkg_id DESC
                 )"_sql),
                    R"(
                 WITH this_pkg_id AS (
                     SELECT pkg_id
-                      FROM dds_cat_pkgs
+                      FROM dds_pkgs
                      WHERE name = ? AND version = ?
                 )
                 SELECT dep_name, low, high
-                  FROM dds_cat_pkg_deps
+                  FROM dds_pkg_deps
                  WHERE pkg_id IN this_pkg_id
               ORDER BY dep_name
                 )"_sql),

src/dds/pkg/remote.cpp

 
 void pkg_remote::store(nsql::database_ref db) {
     auto st = db.prepare(R"(
-        INSERT INTO dds_cat_remotes (name, remote_url)
+        INSERT INTO dds_pkg_remotes (name, remote_url)
             VALUES (?, ?)
         ON CONFLICT (name) DO
             UPDATE SET remote_url = ?2
 
     auto db_path = rdb._tempdir.path() / "repo.db";
 
-    auto rid_st          = db.prepare("SELECT remote_id FROM dds_cat_remotes WHERE name = ?");
+    auto rid_st          = db.prepare("SELECT remote_id FROM dds_pkg_remotes WHERE name = ?");
     rid_st.bindings()[1] = _name;
     auto [remote_id]     = nsql::unpack_single<std::int64_t>(rid_st);
     rid_st.reset();
     dds_log(trace, "Clearing prior contents");
     nsql::exec(  //
         db.prepare(R"(
-            DELETE FROM dds_cat_pkgs
+            DELETE FROM dds_pkgs
             WHERE remote_id = ?
         )"),
         remote_id);
     dds_log(trace, "Importing packages");
     nsql::exec(  //
         db.prepare(R"(
-            INSERT INTO dds_cat_pkgs
+            INSERT INTO dds_pkgs
                 (name, version, description, remote_url, remote_id)
             SELECT
                 name,
         base_url_str);
     dds_log(trace, "Importing dependencies");
     db.exec(R"(
-        INSERT OR REPLACE INTO dds_cat_pkg_deps (pkg_id, dep_name, low, high)
+        INSERT OR REPLACE INTO dds_pkg_deps (pkg_id, dep_name, low, high)
             SELECT
                 local_pkgs.pkg_id AS pkg_id,
                 dep_name,
                 high
             FROM remote.dds_repo_package_deps AS deps,
                  remote.dds_repo_packages AS pkgs USING(package_id),
-                 dds_cat_pkgs AS local_pkgs USING(name, version)
+                 dds_pkgs AS local_pkgs USING(name, version)
     )");
     // Validate our database
     dds_log(trace, "Running integrity check");
 
     // Save the cache info for the remote
     if (auto new_etag = resp.etag()) {
-        nsql::exec(db.prepare("UPDATE dds_cat_remotes SET db_etag = ? WHERE name = ?"),
+        nsql::exec(db.prepare("UPDATE dds_pkg_remotes SET db_etag = ? WHERE name = ?"),
                    *new_etag,
                    _name);
     }
     if (auto mtime = resp.last_modified()) {
-        nsql::exec(db.prepare("UPDATE dds_cat_remotes SET db_mtime = ? WHERE name = ?"),
+        nsql::exec(db.prepare("UPDATE dds_pkg_remotes SET db_mtime = ? WHERE name = ?"),
                    *mtime,
                    _name);
     }
 
 void dds::update_all_remotes(nsql::database_ref db) {
     dds_log(info, "Updating catalog from all remotes");
-    auto repos_st = db.prepare("SELECT name, remote_url, db_etag, db_mtime FROM dds_cat_remotes");
+    auto repos_st = db.prepare("SELECT name, remote_url, db_etag, db_mtime FROM dds_pkg_remotes");
     auto tups     = nsql::iter_tuples<std::string,
                                   std::string,
                                   std::optional<std::string>,

src/dds/util/http/pool.cpp

 
         dds_log(trace,
                 " --> HTTP {} {}://{}:{}{}",
-                origin.protocol,
                 params.method,
+                origin.protocol,
                 origin.hostname,
                 origin.port,
                 params.path);