Add mixed test

Author: MDA2AV

data/benchmark.db

@@ -3,6 +3,7 @@
 using System.Security.Cryptography.X509Certificates;
 using Microsoft.AspNetCore.ResponseCompression;
 using Microsoft.AspNetCore.Server.Kestrel.Core;
+using Microsoft.Data.Sqlite;
 
 var builder = WebApplication.CreateBuilder(args);
 builder.Logging.ClearProviders();
@@ -113,6 +114,50 @@
     }
 }
 
+// Open SQLite database
+SqliteConnection? dbConn = null;
+var dbPath = "/data/benchmark.db";
+if (File.Exists(dbPath))
+{
+    dbConn = new SqliteConnection($"Data Source={dbPath};Mode=ReadOnly");
+    dbConn.Open();
+    using var pragma = dbConn.CreateCommand();
+    pragma.CommandText = "PRAGMA mmap_size=268435456";
+    pragma.ExecuteNonQuery();
+}
+
+app.MapGet("/db", (HttpRequest req) =>
+{
+    if (dbConn == null)
+        return Results.Problem("DB not available");
+    double min = 10, max = 50;
+    if (req.Query.ContainsKey("min") && double.TryParse(req.Query["min"], out double pmin))
+        min = pmin;
+    if (req.Query.ContainsKey("max") && double.TryParse(req.Query["max"], out double pmax))
+        max = pmax;
+    using var cmd = dbConn.CreateCommand();
+    cmd.CommandText = "SELECT id, name, category, price, quantity, active, tags, rating_score, rating_count FROM items WHERE price BETWEEN @min AND @max LIMIT 50";
+    cmd.Parameters.AddWithValue("@min", min);
+    cmd.Parameters.AddWithValue("@max", max);
+    using var reader = cmd.ExecuteReader();
+    var items = new List<object>();
+    while (reader.Read())
+    {
+        items.Add(new
+        {
+            id = reader.GetInt32(0),
+            name = reader.GetString(1),
+            category = reader.GetString(2),
+            price = reader.GetDouble(3),
+            quantity = reader.GetInt32(4),
+            active = reader.GetInt32(5) == 1,
+            tags = JsonSerializer.Deserialize<List<string>>(reader.GetString(6)),
+            rating = new { score = reader.GetDouble(7), count = reader.GetInt32(8) },
+        });
+    }
+    return Results.Json(new { items, count = items.Count });
+});
+
 app.MapGet("/static/{filename}", (string filename) =>
 {
     if (staticFileMap.TryGetValue(filename, out var sf))

frameworks/aspnet-minimal/Program.cs

@@ -3,4 +3,7 @@
     <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Data.Sqlite" Version="9.0.3" />
+  </ItemGroup>
 </Project>

frameworks/aspnet-minimal/aspnet-minimal.csproj

@@ -14,6 +14,7 @@
     "upload",
     "compression",
     "noisy",
+    "mixed",
     "baseline-h2",
     "static-h2",
     "baseline-h3",

frameworks/aspnet-minimal/meta.json

@@ -2,7 +2,7 @@
   "display_name": "bun",
   "language": "TS",
   "type": "realistic",
-  "engine": "JavaScriptCore",
+  "engine": "JSC",
   "description": "Bun's built-in HTTP server using JavaScriptCore engine with multi-core clustering.",
   "repo": "https://github.com/oven-sh/bun",
   "enabled": true,
@@ -14,6 +14,7 @@
     "upload",
     "compression",
     "noisy",
+    "mixed",
     "baseline-h2",
     "static-h2"
   ]

frameworks/bun/meta.json

@@ -1,5 +1,6 @@
 const zlib = require("zlib");
 const fs = require("fs");
+const { Database } = require("bun:sqlite");
 
 const MIME_TYPES: Record<string, string> = {
   ".css": "text/css", ".js": "application/javascript", ".html": "text/html",
@@ -26,6 +27,19 @@ const largeItems = largeData.map((d: any) => ({
 }));
 const largeJsonBuf = Buffer.from(JSON.stringify({ items: largeItems, count: largeItems.length }));
 
+// Open SQLite database read-only (retry on transient failure)
+let dbStmt: any = null;
+for (let attempt = 0; attempt < 3 && !dbStmt; attempt++) {
+  try {
+    const db = new Database("/data/benchmark.db", { readonly: true });
+    db.exec("PRAGMA mmap_size=268435456");
+    dbStmt = db.prepare("SELECT id, name, category, price, quantity, active, tags, rating_score, rating_count FROM items WHERE price BETWEEN ? AND ? LIMIT 50");
+  } catch (e) {
+    console.error(`SQLite open attempt ${attempt + 1} failed:`, e);
+    if (attempt < 2) Bun.sleepSync(50);
+  }
+}
+
 // Pre-load static files
 const staticFiles: Record<string, { buf: Buffer; ct: string }> = {};
 try {
@@ -61,6 +75,36 @@ function handleRequest(req: Request): Response | Promise<Response> {
   const qIdx = url.indexOf("?", pathStart);
   const path = qIdx === -1 ? url.slice(pathStart) : url.slice(pathStart, qIdx);
 
+  if (path === "/db") {
+    if (!dbStmt) return new Response("DB not available", { status: 500 });
+    try {
+      let min = 10, max = 50;
+      if (qIdx !== -1) {
+        const qs = url.slice(qIdx + 1);
+        for (const pair of qs.split("&")) {
+          const eq = pair.indexOf("=");
+          if (eq === -1) continue;
+          const k = pair.slice(0, eq), v = pair.slice(eq + 1);
+          if (k === "min") min = parseFloat(v) || 10;
+          else if (k === "max") max = parseFloat(v) || 50;
+        }
+      }
+      const rows = dbStmt.all(min, max) as any[];
+      const items = rows.map((r: any) => ({
+        id: r.id, name: r.name, category: r.category,
+        price: r.price, quantity: r.quantity, active: r.active === 1,
+        tags: JSON.parse(r.tags),
+        rating: { score: r.rating_score, count: r.rating_count },
+      }));
+      const body = JSON.stringify({ items, count: items.length });
+      return new Response(body, {
+        headers: { "content-type": "application/json" },
+      });
+    } catch (e: any) {
+      return new Response(e.message || "db error", { status: 500 });
+    }
+  }
+
   if (path === "/pipeline") {
     return new Response("ok", { headers: { "content-type": "text/plain" } });
   }

frameworks/bun/server.ts

@@ -2,4 +2,7 @@ module httparena-handler
 
 go 1.24
 
-require github.com/caddyserver/caddy/v2 v2.9.1
+require (
+	github.com/caddyserver/caddy/v2 v2.9.1
+	modernc.org/sqlite v1.37.1
+)

frameworks/caddy/go.mod

@@ -1,6 +1,7 @@
 package httparenahandler
 
 import (
+	"database/sql"
 	"encoding/json"
 	"fmt"
 	"hash/crc32"
@@ -9,13 +10,15 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"runtime"
 	"strconv"
 	"strings"
 
 	"github.com/caddyserver/caddy/v2"
 	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
 	"github.com/caddyserver/caddy/v2/caddyconfig/httpcaddyfile"
 	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
+	_ "modernc.org/sqlite"
 )
 
 func init() {
@@ -54,6 +57,7 @@ type Handler struct {
 	jsonResponse      []byte
 	jsonLargeResponse []byte
 	staticFiles       map[string]staticFile
+	db                *sql.DB
 }
 
 func (Handler) CaddyModule() caddy.ModuleInfo {
@@ -149,6 +153,13 @@ func (h *Handler) Provision(ctx caddy.Context) error {
 		}
 	}
 
+	// Open SQLite database
+	db, err := sql.Open("sqlite", "file:/data/benchmark.db?mode=ro&immutable=1")
+	if err == nil {
+		db.SetMaxOpenConns(runtime.NumCPU())
+		h.db = db
+	}
+
 	return nil
 }
 
@@ -226,6 +237,57 @@ func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request, next caddyht
 			http.Error(w, "No dataset", 500)
 		}
 		return nil
+
+	case "/db":
+		if h.db == nil {
+			http.Error(w, "DB not available", 500)
+			return nil
+		}
+		minStr := r.URL.Query().Get("min")
+		maxStr := r.URL.Query().Get("max")
+		minPrice := 10.0
+		maxPrice := 50.0
+		if v, err := strconv.ParseFloat(minStr, 64); err == nil {
+			minPrice = v
+		}
+		if v, err := strconv.ParseFloat(maxStr, 64); err == nil {
+			maxPrice = v
+		}
+		rows, err := h.db.Query("SELECT id, name, category, price, quantity, active, tags, rating_score, rating_count FROM items WHERE price BETWEEN ? AND ? LIMIT 50", minPrice, maxPrice)
+		if err != nil {
+			http.Error(w, "Query failed", 500)
+			return nil
+		}
+		defer rows.Close()
+		var items []map[string]interface{}
+		for rows.Next() {
+			var dbId int
+			var name, category, tags string
+			var price float64
+			var quantity int
+			var active int
+			var ratingScore float64
+			var ratingCount int
+			if err := rows.Scan(&dbId, &name, &category, &price, &quantity, &active, &tags, &ratingScore, &ratingCount); err != nil {
+				continue
+			}
+			var tagsArr []string
+			json.Unmarshal([]byte(tags), &tagsArr)
+			items = append(items, map[string]interface{}{
+				"id": dbId, "name": name, "category": category,
+				"price": price, "quantity": quantity, "active": active == 1,
+				"tags": tagsArr,
+				"rating": map[string]interface{}{"score": ratingScore, "count": ratingCount},
+			})
+		}
+		resp := map[string]interface{}{
+			"items": items,
+			"count": len(items),
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.Header().Set("Server", "caddy")
+		json.NewEncoder(w).Encode(resp)
+		return nil
 	}
 
 	if strings.HasPrefix(path, "/static/") {

frameworks/caddy/handler.go

@@ -13,6 +13,7 @@
     "compression",
     "upload",
     "noisy",
+    "mixed",
     "baseline-h2",
     "static-h2",
     "baseline-h3",

frameworks/caddy/meta.json

@@ -6,8 +6,9 @@ add_compile_definitions(H2O_USE_LIBUV=0)
 set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3")
 find_library(H2O_LIB h2o-evloop REQUIRED)
 find_library(YAJL_LIB yajl REQUIRED)
+find_library(SQLITE3_LIB sqlite3 REQUIRED)
 add_executable(h2o-app src/main.c)
 find_library(BROTLI_ENC brotlienc)
 find_library(BROTLI_DEC brotlidec)
 find_library(BROTLI_COMMON brotlicommon)
-target_link_libraries(h2o-app ${H2O_LIB} ssl crypto ${YAJL_LIB} z ${BROTLI_ENC} ${BROTLI_DEC} ${BROTLI_COMMON} pthread m)
+target_link_libraries(h2o-app ${H2O_LIB} ssl crypto ${YAJL_LIB} ${SQLITE3_LIB} z ${BROTLI_ENC} ${BROTLI_DEC} ${BROTLI_COMMON} pthread m)