Merge pull request #210 from MDA2AV/reso808

udpate results

Author: MDA2AV

frameworks/drogon/Dockerfile

@@ -1,8 +1,8 @@
 FROM ubuntu:24.04 AS build
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    g++ cmake make git ca-certificates \
-    libjsoncpp-dev uuid-dev zlib1g-dev libssl-dev libsqlite3-dev \
+    g++ cmake make git ca-certificates pkg-config \
+    libjsoncpp-dev uuid-dev zlib1g-dev libssl-dev libsqlite3-dev libpq-dev \
     && rm -rf /var/lib/apt/lists/*
 
 # Build drogon from source
@@ -12,7 +12,7 @@ RUN git clone --depth 1 --branch v1.9.10 https://github.com/drogonframework/drog
     cmake -B build -DCMAKE_BUILD_TYPE=Release \
       -DCMAKE_CXX_FLAGS="-flto" \
       -DBUILD_EXAMPLES=OFF -DBUILD_CTL=OFF \
-      -DBUILD_ORM=OFF -DBUILD_BROTLI=OFF \
+      -DBUILD_ORM=ON -DBUILD_BROTLI=OFF \
       -S . && \
     cmake --build build -j$(nproc) && \
     cmake --install build
@@ -25,7 +25,7 @@ RUN cmake -B build -DCMAKE_BUILD_TYPE=Release -S . && \
 
 FROM ubuntu:24.04
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    libjsoncpp25 libssl3t64 libuuid1 libsqlite3-0 && \
+    libjsoncpp25 libssl3t64 libuuid1 libsqlite3-0 libpq5 && \
     rm -rf /var/lib/apt/lists/*
 COPY --from=build /usr/local/lib/libtrantor.so* /usr/local/lib/
 COPY --from=build /usr/local/lib/libdrogon.so* /usr/local/lib/

frameworks/drogon/main.cc

@@ -1,5 +1,6 @@
 #include <drogon/drogon.h>
 #include <sqlite3.h>
+#include <thread>
 #include <dirent.h>
 #include <fstream>
 #include <sstream>
@@ -60,6 +61,11 @@ static sqlite3 *getDb()
     return tl_db;
 }
 
+// ── PostgreSQL (async-db) ──
+
+static bool pg_available = false;
+static drogon::orm::DbClientPtr pgClient;
+
 static void loadDataset()
 {
     const char *path = getenv("DATASET_PATH");
@@ -171,6 +177,7 @@ class BenchmarkCtrl : public drogon::HttpController<BenchmarkCtrl>
     ADD_METHOD_TO(BenchmarkCtrl::upload,      "/upload",           Post);
     ADD_METHOD_TO(BenchmarkCtrl::baseline11,  "/baseline11",       Get, Post);
     ADD_METHOD_TO(BenchmarkCtrl::dbEndpoint,  "/db",               Get);
+    ADD_METHOD_TO(BenchmarkCtrl::asyncDb,    "/async-db",         Get);
     ADD_METHOD_TO(BenchmarkCtrl::staticFile,  "/static/{1}",       Get);
     METHOD_LIST_END
 
@@ -325,6 +332,66 @@ class BenchmarkCtrl : public drogon::HttpController<BenchmarkCtrl>
         callback(resp);
     }
 
+    void asyncDb(const HttpRequestPtr &req,
+                 std::function<void(const HttpResponsePtr &)> &&callback)
+    {
+        static const std::string empty_resp = "{\"items\":[],\"count\":0}";
+        if (!pg_available || !pgClient) {
+            auto resp = HttpResponse::newHttpResponse();
+            resp->setBody(empty_resp);
+            resp->setContentTypeCode(CT_APPLICATION_JSON);
+            callback(resp);
+            return;
+        }
+        double minPrice = 10.0, maxPrice = 50.0;
+        for (auto &[k, v] : req->parameters()) {
+            if (k == "min") { try { minPrice = std::stod(v); } catch (...) {} }
+            else if (k == "max") { try { maxPrice = std::stod(v); } catch (...) {} }
+        }
+        pgClient->execSqlAsync(
+            "SELECT id, name, category, price, quantity, active, tags, rating_score, rating_count FROM items WHERE price BETWEEN $1 AND $2 LIMIT 50",
+            [callback](const drogon::orm::Result &result) {
+                Json::Value respJson;
+                Json::Value items(Json::arrayValue);
+                for (const auto &row : result) {
+                    Json::Value item;
+                    item["id"] = static_cast<Json::Int64>(row["id"].as<int32_t>());
+                    item["name"] = row["name"].as<std::string>();
+                    item["category"] = row["category"].as<std::string>();
+                    item["price"] = row["price"].as<double>();
+                    item["quantity"] = static_cast<Json::Int64>(row["quantity"].as<int32_t>());
+                    item["active"] = row["active"].as<bool>();
+                    Json::CharReaderBuilder rb;
+                    Json::Value tags;
+                    std::string errs;
+                    std::string tagsStr = row["tags"].as<std::string>();
+                    std::istringstream tis(tagsStr);
+                    Json::parseFromStream(rb, tis, &tags, &errs);
+                    item["tags"] = tags;
+                    Json::Value rating;
+                    rating["score"] = row["rating_score"].as<double>();
+                    rating["count"] = static_cast<Json::Int64>(row["rating_count"].as<int32_t>());
+                    item["rating"] = rating;
+                    items.append(std::move(item));
+                }
+                respJson["items"] = std::move(items);
+                respJson["count"] = static_cast<int>(result.size());
+                Json::StreamWriterBuilder wb;
+                wb["indentation"] = "";
+                auto resp = HttpResponse::newHttpResponse();
+                resp->setBody(Json::writeString(wb, respJson));
+                resp->setContentTypeCode(CT_APPLICATION_JSON);
+                callback(resp);
+            },
+            [callback](const drogon::orm::DrogonDbException &e) {
+                auto resp = HttpResponse::newHttpResponse();
+                resp->setBody("{\"items\":[],\"count\":0}");
+                resp->setContentTypeCode(CT_APPLICATION_JSON);
+                callback(resp);
+            },
+            minPrice, maxPrice);
+    }
+
     void staticFile(const HttpRequestPtr &req,
                     std::function<void(const HttpResponsePtr &)> &&callback,
                     const std::string &filename)
@@ -354,6 +421,37 @@ int main()
         sqlite3 *test = openDb();
         if (test) { db_available = true; sqlite3_close(test); }
     }
+    {
+        const char *dbUrl = getenv("DATABASE_URL");
+        if (dbUrl) {
+            // Parse postgres://user:pass@host:port/dbname
+            std::string s(dbUrl);
+            auto se = s.find("://");
+            if (se != std::string::npos) {
+                s = s.substr(se + 3);
+                std::string user, pass, host = "localhost", port = "5432", dbname;
+                auto at = s.find('@');
+                if (at != std::string::npos) {
+                    auto up = s.substr(0, at);
+                    s = s.substr(at + 1);
+                    auto c = up.find(':');
+                    if (c != std::string::npos) { user = up.substr(0, c); pass = up.substr(c + 1); }
+                    else user = up;
+                }
+                auto sl = s.find('/');
+                if (sl != std::string::npos) { dbname = s.substr(sl + 1); s = s.substr(0, sl); }
+                auto c = s.find(':');
+                if (c != std::string::npos) { host = s.substr(0, c); port = s.substr(c + 1); }
+                else host = s;
+                int nconns = std::thread::hardware_concurrency();
+                if (nconns < 4) nconns = 4;
+                pgClient = drogon::orm::DbClient::newPgClient(
+                    "host=" + host + " port=" + port + " dbname=" + dbname +
+                    " user=" + user + " password=" + pass, nconns);
+                pg_available = true;
+            }
+        }
+    }
 
     app().setLogLevel(trantor::Logger::kWarn);
     app().setThreadNum(0);
@@ -372,6 +470,7 @@ int main()
         app().addListener("0.0.0.0", 8443, true, cert, key);
 
     app().enableGzip(true);
+
     app().run();
     return 0;
 }

frameworks/drogon/meta.json

@@ -16,6 +16,7 @@
     "compression",
     "mixed",
     "baseline-h2",
-    "static-h2"
+    "static-h2",
+    "async-db"
   ]
 }

frameworks/kemal/Dockerfile

@@ -4,7 +4,7 @@ FROM crystallang/crystal:1.14-alpine AS builder
 WORKDIR /app
 
 # Install SQLite dev headers, libpq, and gcc for reuseport shim
-RUN apk add --no-cache sqlite-dev sqlite-static gcc musl-dev
+RUN apk add --no-cache sqlite-dev sqlite-static gcc musl-dev libpq-dev git
 
 # Build SO_REUSEPORT shim
 COPY reuseport.c /tmp/reuseport.c
@@ -21,7 +21,7 @@ RUN crystal build src/server.cr -o server --release --no-debug
 # Runtime stage
 FROM alpine:3.20
 
-RUN apk add --no-cache ca-certificates libgcc gc libevent sqlite-libs pcre2
+RUN apk add --no-cache ca-certificates libgcc gc libevent sqlite-libs pcre2 libpq
 
 WORKDIR /app
 COPY --from=builder /app/server /app/server

frameworks/kemal/meta.json

@@ -14,6 +14,7 @@
     "upload",
     "compression",
     "noisy",
-    "mixed"
+    "mixed",
+    "async-db"
   ]
 }

frameworks/kemal/shard.yml

@@ -12,5 +12,8 @@ dependencies:
   sqlite3:
     github: crystal-lang/crystal-sqlite3
     version: ~> 0.21
+  pg:
+    github: will/crystal-pg
+    version: ~> 0.28
 
 crystal: ">= 1.10.0"

frameworks/kemal/src/server.cr

@@ -2,6 +2,8 @@ require "kemal"
 require "json"
 require "compress/gzip"
 require "sqlite3"
+require "db"
+require "pg"
 
 
 # ---------------------------------------------------------------------------
@@ -50,9 +52,26 @@ end
 
 DB_AVAILABLE = File.exists?(DB_PATH)
 
-
 PG_QUERY = "SELECT id, name, category, price, quantity, active, tags, rating_score, rating_count FROM items WHERE price BETWEEN $1 AND $2 LIMIT 50"
 
+PG_POOL_SIZE = {System.cpu_count.to_i * 4, 64}.max
+
+class PgPool
+  @@db : DB::Database? = nil
+
+  def self.get : DB::Database?
+    return @@db if @@db
+    if url = ENV["DATABASE_URL"]?
+      separator = url.includes?('?') ? '&' : '?'
+      pg_url = "#{url}#{separator}max_pool_size=#{PG_POOL_SIZE}&max_idle_pool_size=#{PG_POOL_SIZE}"
+      @@db = DB.open(pg_url)
+    end
+    @@db
+  rescue
+    nil
+  end
+end
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
@@ -180,6 +199,43 @@ get "/db" do |env|
   {items: items, count: items.size}.to_json
 end
 
+get "/async-db" do |env|
+  server_header(env)
+  env.response.content_type = "application/json"
+
+  unless pg = PgPool.get
+    next %({"items":[],"count":0})
+  end
+
+  min_val = (env.params.query["min"]?.try(&.to_f) || 10.0)
+  max_val = (env.params.query["max"]?.try(&.to_f) || 50.0)
+
+  begin
+    items = [] of Hash(String, JSON::Any)
+
+    pg.query(PG_QUERY, min_val, max_val) do |rs|
+      rs.each do
+        item = Hash(String, JSON::Any).new
+        item["id"] = JSON::Any.new(rs.read(Int32).to_i64)
+        item["name"] = JSON::Any.new(rs.read(String))
+        item["category"] = JSON::Any.new(rs.read(String))
+        item["price"] = JSON::Any.new(rs.read(Float64))
+        item["quantity"] = JSON::Any.new(rs.read(Int32).to_i64)
+        item["active"] = JSON::Any.new(rs.read(Bool))
+        item["tags"] = rs.read(JSON::Any)
+        rating_score = rs.read(Float64)
+        rating_count = rs.read(Int32).to_i64
+        item["rating"] = JSON::Any.new({"score" => JSON::Any.new(rating_score), "count" => JSON::Any.new(rating_count)})
+        items << item
+      end
+    end
+
+    {items: items, count: items.size}.to_json
+  rescue
+    %({"items":[],"count":0})
+  end
+end
+
 post "/upload" do |env|
   server_header(env)
   body = env.request.body.try(&.gets_to_end) || ""

frameworks/ntex/Cargo.toml frameworks/ntex-iouring/Cargo.tomlframeworks/ntex/Cargo.toml renamed to frameworks/ntex-iouring/Cargo.toml

@@ -12,6 +12,8 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 num_cpus = "1"
 rusqlite = { version = "0.31", features = ["bundled"] }
+tokio-postgres = { version = "0.7", features = ["with-serde_json-1"] }
+deadpool-postgres = { version = "0.14", features = ["rt_tokio_1"] }
 
 [profile.release]
 opt-level = 3