new tests

Author: vbilopav

.gitignore

@@ -433,3 +433,6 @@ build/
 
 *.sln
 pg_function_load_tests.sln
+
+.DS_Store
+Thumbs.db

src/.env

@@ -0,0 +1 @@
+BUILDX_NO_DEFAULT_ATTESTATIONS=1

src/_k6/scripts/run.sh

@@ -7,44 +7,32 @@ mkdir -p /results/$STAMP
 
 echo "*** Starting k6 tests, output will be saved in /results/$STAMP"
 
-for records in 1 10 100 500; do # records retrieved
-for target in 1 50 100; do # target number of virtual users VUs
-for duration in 60s; do # 10s 60s 120s; do # for duration in 5s 60s 120s; do # duration of the test
+# for records in 1 10 100 500; do # records retrieved
+# for target in 1 50 100; do # target number of virtual users VUs
+# for duration in 60s; do # duration of the test
+for records in 10; do # records retrieved
+for target in 1; do # target number of virtual users VUs
+for duration in 5s; do # duration of the test
 while read -r tag port; do
     echo "*** Running $tag:$port with $records records, $target VUs, and $duration duration"
     k6 run /scripts/script.js -e STAMP=$STAMP -e TAG=$tag -e PORT=$port -e RECORDS=$records -e DURATION=$duration -e TARGET=$target
     sleep 10 # sleep for 10 seconds between tests
 done << EOF
-django-app-v5.0.9 8000
-express-app-v4.18.2 3100
-postgrest-v12.2.3 3000
-fastapi-app-v0.103.2 8001
-fastify-app-v4.26.1 3101
-deno-app-v1.40.2 3102
-swoole-php-app-8.3.13 3103
-npgsqlrest-aot-v2.2.1 5000
-net8-npgsqlrest-jit-v2.12.1 5001
-net8-minapi-ef-jit-v8.0.10 5002
-net8-minapi-dapper-jit-v2.1.35 5003
-net8-minapi-norm-jit-v5.4.0 5004
-net8-minapi-ado-jit-v8.0.5 5005
-go-app-v1.22.9 5200
-rust-app-v1.75.0 5300
-java21-spring-boot-v3.2.2 5400
-perl-net-server-prefork-v5.34 8088
-npgsqlrest-aot-v2.4.0 5500
-npgsqlrest-aot-v2.5.0 5506
-npgsqlrest-aot-v2.6.0 5508
-npgsqlrest-aot-v2.7.0 5510
-net9-npgsqlrest-jit-v2.13.1 5501
-net9-npgsqlrest-jit-v2.14.0 5507
-net9-npgsqlrest-jit-v2.15.0 5509
-net9-npgsqlrest-jit-v2.16.0 5511
-net9-minapi-ef-jit-v9.0.1 5502
-net9-minapi-dapper-jit-v2.1.35 5503
-net9-minapi-norm-jit-v5.4.0 5504
-net9-minapi-ado-jit-v8.0.5 5505
-omnigres-master 8080
+django-app-v5.1.4 8000
+fastapi-app-v0.115.6 8001
+fastify-app-v5.2.1 3101
+bun-app-v1.1.42 3104
+go-app-v1.23.4 5200
+java24-spring-boot-v3.4.1 5400
+rust-app-v1.83.0 5300
+swoole-php-app-v8.4.0 3103
+postgrest-v12.2.8 3000
+net9-minapi-ef-jit 5002
+net10-minapi-ef-jit 5003
+net10-minapi-dapper-jit 5004
+npgsqlrest-aot-v2.36.2 5000
+npgsqlrest-aot-v3.2.2 5001
+npgsqlrest-jit-v3.2.2 5005
 EOF
 done # duration of the test
 done # target number of virtual users VUs

src/_k6/scripts/script.js

@@ -8,19 +8,60 @@ const records = Number(__ENV.RECORDS.trim() || "10")
 const duration = __ENV.DURATION.trim() || "60s";
 const target = Number(__ENV.TARGET.trim() || "100");
 const port = __ENV.PORT.trim();
-const path = __ENV.REQ_PATH ? __ENV.REQ_PATH.trim() : (tag.indexOf('postgrest') != -1 ? '/rpc/test_func_v1' : '/api/test-data');
-
-const url = 'http://' +  tag + ':' + port + path + "?" + 
-    Object.entries({
-        _records: records,
-        _text_param: 'ABCDEFGHIJKLMNOPRSTUVWXYZ',
-        _int_param: 1234567890,
-        _ts_param: new Date('2014-12-31').toISOString(),
-        _bool_param: true
-    })
+
+// Determine the path based on the service type
+function getPath(tag) {
+    if (tag.indexOf('postgrest') !== -1) {
+        return '/rpc/perf_test';
+    }
+    return '/api/perf-test';
+}
+
+// Check if this service uses repeated query params for arrays (like ?a=1&a=2&a=3)
+// .NET minimal API and NpgsqlRest bind arrays this way
+function usesRepeatedQueryParams(tag) {
+    return tag.indexOf('npgsqlrest') !== -1 ||
+           tag.indexOf('net9-minapi') !== -1 ||
+           tag.indexOf('net10-minapi') !== -1;
+}
+
+const path = __ENV.REQ_PATH ? __ENV.REQ_PATH.trim() : getPath(tag);
+
+// Base parameters (non-array)
+const baseParams = {
+    _records: records,
+    _text: 'ABCDEFGHIJKLMNOPRSTUVWXYZ',
+    _int: 1234567890,
+    _bigint: '9223372036854770000',
+    _numeric: '12345.6789',
+    _real: '123.45',
+    _double: '123456.789012',
+    _bool: true,
+    _date: '2024-01-15',
+    _timestamp: '2024-01-15T10:30:00',
+    _timestamptz: '2024-01-15T10:30:00Z',
+    _uuid: 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11',
+    _json: '{"key":"value"}',
+    _jsonb: '{"key":"value"}'
+};
+
+// Build URL with all test parameters
+// NpgsqlRest uses repeated query params for arrays: _int_array=1&_int_array=2&_int_array=3
+// Other services use PostgreSQL array literal: _int_array={1,2,3}
+let baseUrl = 'http://' + tag + ':' + port + path + '?' +
+    Object.entries(baseParams)
     .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
     .join('&');
 
+let url;
+if (usesRepeatedQueryParams(tag)) {
+    // .NET services and NpgsqlRest: use repeated query params for arrays
+    url = baseUrl + '&_int_array=1&_int_array=2&_int_array=3&_text_array=a&_text_array=b&_text_array=c';
+} else {
+    // Other services: use PostgreSQL array literal format
+    url = baseUrl + '&_int_array=' + encodeURIComponent('{1,2,3}') + '&_text_array=' + encodeURIComponent('{a,b,c}');
+}
+
 export const options = {
     thresholds: {
         http_req_failed: [{ threshold: "rate<0.01", abortOnFail: true }], // availability threshold for error rate
@@ -42,9 +83,16 @@ export default function () {
         [`${tag} status is 200`]: (r) => r.status === 200,
         [`${tag} response is JSON`]: (r) => r.headers['Content-Type'] && r.headers['Content-Type'].includes('application/json'),
         [`${tag} response has all data records`]: (r) => r.body && JSON.parse(r.body).length == records,
-        [`${tag} response first item has all fields`]: (r) => {
+        [`${tag} response first item has expected fields`]: (r) => {
             let d = JSON.parse(r.body)[0];
-            return d.id1 && d.foo1 && d.bar1 && d.datetime1 && d.id2 && d.foo2 && d.bar2 && d.datetime2 && d.long_foo_bar && d.is_foobar;
+            return d.row_num !== undefined &&
+                   d.text_val !== undefined &&
+                   d.varchar_val !== undefined &&
+                   d.int_val !== undefined &&
+                   d.bigint_val !== undefined &&
+                   d.bool_val !== undefined &&
+                   d.date_val !== undefined &&
+                   d.uuid_val !== undefined;
         }
     });
 }
@@ -57,7 +105,6 @@ export function handleSummary(data) {
     const failedReqs = data.metrics.http_req_failed.values.passes;
     return {
         [`/results/${stamp}/${fileTag}_summary.txt`]: textSummary(data, { indent: ' ', enableColors: false }),
-        //[`/results/${stamp}/${fileTag}_summary.json`]: JSON.stringify(data, null, 2),
         [`/results/${stamp}/${fileTag}.md`]: `|${tag}|${target}|${duration}|${records}|${reqs}|${reqsPerSec}|${reqsDuration}|${failedReqs}|[summary](/${stamp}/${fileTag}_summary.txt)|`,
     }
 }

src/_postgres/init.sql

@@ -1,41 +1,98 @@
-create function public.test_func_v1(
+create extension if not exists "uuid-ossp";
+
+-- Main performance test function with all parameter types
+create function public.perf_test(
     _records int,
-    _text_param text,
-    _int_param int,
-    _ts_param timestamp,
-    _bool_param bool
-) 
+    _text text,
+    _int int,
+    _bigint bigint,
+    _numeric numeric,
+    _real real,
+    _double double precision,
+    _bool bool,
+    _date date,
+    _timestamp timestamp,
+    _timestamptz timestamptz,
+    _uuid uuid,
+    _json json,
+    _jsonb jsonb,
+    _int_array int[],
+    _text_array text[]
+)
 returns table(
-    id1 int, 
-    foo1 text, 
-    bar1 text, 
-    datetime1 timestamp, 
-    id2 int, 
-    foo2 text, 
-    bar2 text, 
-    datetime2 timestamp,
-    long_foo_bar text, 
-    is_foobar bool
+    row_num int,
+    -- text types
+    text_val text,
+    varchar_val varchar(100),
+    char_val char(10),
+    -- integer types
+    smallint_val smallint,
+    int_val int,
+    bigint_val bigint,
+    -- floating point
+    numeric_val numeric(12,4),
+    real_val real,
+    double_val double precision,
+    -- boolean
+    bool_val bool,
+    -- date/time
+    date_val date,
+    time_val time,
+    timestamp_val timestamp,
+    timestamptz_val timestamptz,
+    interval_val interval,
+    -- special types
+    uuid_val uuid,
+    json_val json,
+    jsonb_val jsonb,
+    -- arrays
+    int_array_val int[],
+    text_array_val text[],
+    -- nullable
+    nullable_text text,
+    nullable_int int
 )
 stable
 language sql
 as
 $$
 select
-    i + _int_param as id1,
-    'foo' || '_' || _text_param || '_' || i::text as foo1,
-    'bar' || i::text as bar1,
-    (_ts_param::date) + (i::text || ' days')::interval as datetime1,
-    i+1 + _int_param as id2,
-    'foo' || '_' || _text_param || '_' || (i+1)::text as foo2,
-    'bar' || '_' || _text_param || '_' || (i+1)::text as bar2,
-    (_ts_param::date) + ((i+1)::text || ' days')::interval as datetime2,
-    'long_foo_bar_' || '_' || _text_param || '_' || (i+2)::text as long_foo_bar, 
-    (i % 2)::boolean and _bool_param as is_foobar
+    i as row_num,
+    -- text types
+    _text || '_' || i::text as text_val,
+    left(_text || '_' || i::text, 100)::varchar(100) as varchar_val,
+    lpad(i::text, 10, '0')::char(10) as char_val,
+    -- integer types
+    (i % 32767)::smallint as smallint_val,
+    _int + i as int_val,
+    _bigint + i as bigint_val,
+    -- floating point
+    (_numeric + i + 0.1234)::numeric(12,4) as numeric_val,
+    (_real + i * 0.1)::real as real_val,
+    (_double + i * 0.001)::double precision as double_val,
+    -- boolean
+    case when i % 2 = 0 then _bool else not _bool end as bool_val,
+    -- date/time
+    _date + i as date_val,
+    ('12:00:00'::time + (i || ' minutes')::interval)::time as time_val,
+    _timestamp + (i || ' hours')::interval as timestamp_val,
+    _timestamptz + (i || ' hours')::interval as timestamptz_val,
+    (i || ' days')::interval as interval_val,
+    -- special types
+    case when i = 1 then _uuid
+         else uuid_generate_v5(_uuid, i::text) end as uuid_val,
+    (_json::jsonb || jsonb_build_object('i', i))::json as json_val,
+    _jsonb || jsonb_build_object('row', i) as jsonb_val,
+    -- arrays
+    _int_array || array[i] as int_array_val,
+    _text_array || array[_text || i::text] as text_array_val,
+    -- nullable (nulls on even rows)
+    case when i % 2 = 1 then _text || '_' || i::text else null end as nullable_text,
+    case when i % 2 = 1 then i else null end as nullable_int
 from
     generate_series(1, _records) as i
 $$;
 
-comment on function public.test_func_v1(int, text, int, timestamp, bool) is 'HTTP GET /api/test-data';
+comment on function public.perf_test(int,text,int,bigint,numeric,real,double precision,bool,date,timestamp,timestamptz,uuid,json,jsonb,int[],text[]) is 'HTTP GET /api/perf-test';
 
-show max_connections;
+show max_connections;

src/bun-app-v1.1.42/Dockerfile

@@ -0,0 +1,10 @@
+FROM oven/bun:1.1.42
+
+WORKDIR /app
+COPY package.json ./
+RUN bun install --production
+COPY . .
+
+EXPOSE 3104
+
+CMD ["bun", "run", "app.ts"]

src/bun-app-v1.1.42/app.ts

@@ -0,0 +1,57 @@
+import postgres from 'postgres';
+
+const sql = postgres({
+    host: process.env.DB_HOST || 'postgres',
+    port: 5432,
+    database: process.env.DB_NAME || 'testdb',
+    username: process.env.DB_USER || 'testuser',
+    password: process.env.DB_PASSWORD || 'testpass',
+    max: 100
+});
+
+const server = Bun.serve({
+    port: 3104,
+    async fetch(request) {
+        // Extract path and query from request.url manually to avoid URL parsing issues with Docker hostnames
+        const rawUrl = request.url;
+        const pathStart = rawUrl.indexOf('/', rawUrl.indexOf('://') + 3);
+        const pathAndQuery = pathStart >= 0 ? rawUrl.substring(pathStart) : '/';
+        const [pathname, queryString] = pathAndQuery.split('?');
+        const params = new URLSearchParams(queryString || '');
+
+        if (pathname === '/api/perf-test' && request.method === 'GET') {
+            const records = parseInt(params.get('_records') || '0');
+            const text = params.get('_text') || '';
+            const intVal = parseInt(params.get('_int') || '0');
+            const bigint = params.get('_bigint') || '0';
+            const numeric = params.get('_numeric') || '0';
+            const real = params.get('_real') || '0';
+            const double = params.get('_double') || '0';
+            const bool = params.get('_bool') === 'true';
+            const date = params.get('_date') || '';
+            const timestamp = params.get('_timestamp') || '';
+            const timestamptz = params.get('_timestamptz') || '';
+            const uuid = params.get('_uuid') || '';
+            const json = params.get('_json') || '{}';
+            const jsonb = params.get('_jsonb') || '{}';
+            const intArray = params.get('_int_array') || '{}';
+            const textArray = params.get('_text_array') || '{}';
+
+            const rows = await sql`
+                SELECT row_num, text_val, varchar_val, char_val, smallint_val, int_val, bigint_val,
+                       numeric_val, real_val, double_val, bool_val, date_val, time_val,
+                       timestamp_val, timestamptz_val, interval_val, uuid_val, json_val, jsonb_val,
+                       int_array_val, text_array_val, nullable_text, nullable_int
+                FROM public.perf_test(${records}, ${text}, ${intVal}, ${bigint}::bigint, ${numeric}::numeric, ${real}::real, ${double}::double precision, ${bool}, ${date}::date, ${timestamp}::timestamp, ${timestamptz}::timestamptz, ${uuid}::uuid, ${json}::json, ${jsonb}::jsonb, ${intArray}::int[], ${textArray}::text[])
+            `;
+
+            return new Response(JSON.stringify(rows), {
+                headers: { 'Content-Type': 'application/json' }
+            });
+        }
+
+        return new Response('Not Found', { status: 404 });
+    }
+});
+
+console.log(`Bun server running on port ${server.port}`);

src/bun-app-v1.1.42/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "bun-test-app",
+  "type": "module",
+  "dependencies": {
+    "postgres": "3.4.5"
+  }
+}