GizmoSQL: split benchmark.sh + use gizmosql_client (depends on #860)

Adopts the per-system 7-script interface from #860 for gizmosql/, and
replaces the Java sqlline-based gizmosqlline client with the C++
gizmosql_client shell that ships with gizmosql_server.

Scripts (matching the contract from lib/benchmark-common.sh):
  benchmark.sh - 4-line shim that exec's ../lib/benchmark-common.sh
  install      - apt + curl gizmosql_cli_linux_$ARCH.zip; no openjdk, no
                 separate gizmosqlline download
  start        - idempotent server bring-up (skips if port 31337 is open)
  check        - cheap TCP probe (auth-gated SQL would need credentials)
  stop         - kills tracked PID; pkill belt-and-braces fallback
  load         - rm -f clickbench.db, then create.sql + load.sql via
                 gizmosql_client; deletes hits.parquet and sync's
  query        - reads one query from stdin, runs via gizmosql_client with
                 .timer on + .mode trash; emits fractional seconds as the
                 last stderr line (parsed from "Run Time: X.XXs")
  data-size    - wc -c clickbench.db

Notes:
- BENCH_DOWNLOAD_SCRIPT=download-hits-parquet-single, BENCH_RESTARTABLE=yes
  (gizmosql is a server, so per-query restart neutralizes warm-process
  effects, matching the clickhouse/postgres pattern in #860).
- util.sh now exports GIZMOSQL_HOST/PORT/USER/PASSWORD - the env vars
  gizmosql_client reads natively, so query/load can call gizmosql_client
  with no flags. The server still receives the username via --username.
- PID_FILE moved to a stable /tmp path (was /tmp/gizmosql_server_$$.pid,
  which broke across the start/stop process boundary in the new layout).

This PR depends on #860 (which introduces lib/benchmark-common.sh and the
contract). Once #860 lands, this PR's diff against main will be only
the gizmosql/ files. Validated locally on macOS with gizmosql v1.22.4:
the query script produces the expected fractional-seconds last line on
stdout/stderr separation, and exits non-zero on error paths.

See https://docs.gizmosql.com/#/client for gizmosql_client docs.

Author: prmoore77

gizmosql/benchmark.sh

@@ -1,73 +1,5 @@
 #!/bin/bash
-
-# needed by DuckDB
-export HOME=/home/ubuntu
-
-# Install requirements
-apt-get update -y
-apt install openjdk-17-jre-headless unzip netcat-openbsd -y
-
-# Detect architecture (maps x86_64->amd64, aarch64->arm64)
-ARCH=$(uname -m)
-if [ "$ARCH" = "x86_64" ]; then
-    ARCH="amd64"
-elif [ "$ARCH" = "aarch64" ]; then
-    ARCH="arm64"
-fi
-
-# Server setup Install
-curl -L -o gizmosql.zip "https://github.com/gizmodata/gizmosql/releases/latest/download/gizmosql_cli_linux_${ARCH}.zip"
-unzip gizmosql.zip
-mv gizmosql_server gizmosql_client /usr/local/bin/
-
-# Install Java and the GizmoSQLLine CLI client
-pushd /tmp
-curl -L -o gizmosqlline https://github.com/gizmodata/gizmosqlline/releases/latest/download/gizmosqlline
-chmod +x gizmosqlline
-mv gizmosqlline /usr/local/bin/
-popd
-
-# Source our env vars and utility functions for starting/stopping gizmosql server
-. util.sh
-
-# Start the GizmoSQL server in the background
-start_gizmosql
-
-# Create the table
-gizmosqlline \
-  -u ${GIZMOSQL_SERVER_URI} \
-  -n ${GIZMOSQL_USERNAME} \
-  -p ${GIZMOSQL_PASSWORD} \
-  -f create.sql
-
-# Load the data
-../download-hits-parquet-single
-
-echo -n "Load time: "
-time gizmosqlline \
-  -u ${GIZMOSQL_SERVER_URI} \
-  -n ${GIZMOSQL_USERNAME} \
-  -p ${GIZMOSQL_PASSWORD} \
-  -f load.sql
-
-stop_gizmosql
-
-# Run the queries
-./run.sh 2>&1 | tee log.txt
-
-# Remove carriage returns from the log
-sed -i 's/\r$//' log.txt
-
-echo -n "Data size: "
-wc -c clickbench.db
-
-cat log.txt | \
-  grep -E 'rows? selected \([0-9.]+ seconds\)|Killed|Segmentation' | \
-  sed -E 's/.*rows? selected \(([0-9.]+) seconds\).*/\1/; s/.*(Killed|Segmentation).*/null/' | \
-  awk '{
-    if (NR % 3 == 1) printf "[";
-    if ($1 == "null") printf "null";
-    else printf $1;
-    if (NR % 3 == 0) printf "],\n";
-    else printf ", ";
-  }'
+# Thin shim — actual flow is in lib/benchmark-common.sh.
+export BENCH_DOWNLOAD_SCRIPT="download-hits-parquet-single"
+export BENCH_RESTARTABLE=yes
+exec ../lib/benchmark-common.sh

gizmosql/check

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -e
+
+. ./util.sh
+
+# A simple TCP probe is the cheapest health check; the Arrow Flight SQL
+# endpoint is auth-gated, so we just check the listener is up.
+exec nc -z "${GIZMOSQL_HOST}" "${GIZMOSQL_PORT}"

gizmosql/data-size

@@ -0,0 +1,4 @@
+#!/bin/bash
+set -eu
+
+wc -c < clickbench.db | awk '{print $1}'

gizmosql/install

@@ -0,0 +1,20 @@
+#!/bin/bash
+set -eu
+
+sudo apt-get update -y
+sudo apt-get install -y unzip netcat-openbsd curl
+
+ARCH=$(uname -m)
+if [ "$ARCH" = "x86_64" ]; then
+    ARCH="amd64"
+elif [ "$ARCH" = "aarch64" ]; then
+    ARCH="arm64"
+fi
+
+# gizmosql_client and gizmosql_server ship together in the same archive.
+if ! command -v gizmosql_server >/dev/null 2>&1; then
+    curl -L -o gizmosql.zip \
+        "https://github.com/gizmodata/gizmosql/releases/latest/download/gizmosql_cli_linux_${ARCH}.zip"
+    unzip -o gizmosql.zip
+    sudo mv gizmosql_server gizmosql_client /usr/local/bin/
+fi

gizmosql/load

@@ -0,0 +1,15 @@
+#!/bin/bash
+set -eu
+
+. ./util.sh
+
+# Idempotent: blow away any prior database.
+rm -f clickbench.db
+
+# Server must be up; gizmosql_client picks up GIZMOSQL_HOST/PORT/USER/PASSWORD
+# from the environment.
+gizmosql_client --file create.sql
+gizmosql_client --file load.sql
+
+rm -f hits.parquet
+sync

gizmosql/query

@@ -0,0 +1,43 @@
+#!/bin/bash
+# Reads a SQL query from stdin, runs it via gizmosql_client.
+# Stdout: query result (empty in trash mode plus a row-count summary).
+# Stderr: query runtime in fractional seconds on the last line, parsed from
+# gizmosql_client's "Run Time: X.XXs" line emitted by .timer on.
+# Exit non-zero on error.
+set -e
+
+. ./util.sh
+query=$(cat)
+
+err_file=$(mktemp)
+trap 'rm -f "$err_file"' EXIT
+
+# .timer on  -> emits "Run Time: <seconds>s" to stderr after each statement.
+# .mode trash -> discards rows; we only care about the timing.
+out=$(printf '.timer on\n.mode trash\n%s\n' "$query" | gizmosql_client 2>"$err_file") \
+    && exit_code=0 || exit_code=$?
+
+err=$(<"$err_file")
+clean_out=$(printf '%s\n' "$out" | tr -d '\r')
+clean_err=$(printf '%s\n' "$err" | tr -d '\r')
+
+if [ "$exit_code" -ne 0 ] \
+   || printf '%s\n' "$clean_err" | grep -qiE 'error|exception|Killed|Segmentation'; then
+    printf '%s\n' "$clean_out"
+    printf '%s\n' "$clean_err" >&2
+    exit 1
+fi
+
+printf '%s\n' "$clean_out"
+
+secs=$(printf '%s\n' "$clean_err" \
+    | grep -oE 'Run Time: [0-9.]+s' \
+    | tail -n1 \
+    | sed -E 's/Run Time: ([0-9.]+)s/\1/')
+
+if [ -z "$secs" ]; then
+    echo "no Run Time in gizmosql_client output" >&2
+    exit 1
+fi
+
+awk -v s="$secs" 'BEGIN { printf "%.3f\n", s }' >&2

gizmosql/run.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+set -eu
+
+. ./util.sh
+
+# Idempotent: if the server is already up, do nothing.
+if nc -z "${GIZMOSQL_HOST}" "${GIZMOSQL_PORT}" 2>/dev/null; then
+    exit 0
+fi
+
+start_gizmosql

gizmosql/start

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+. ./util.sh
+stop_gizmosql || true
+
+# Belt-and-braces: kill any leftover gizmosql_server process.
+pkill -x gizmosql_server 2>/dev/null || true

gizmosql/stop

@@ -1,38 +1,41 @@
 #!/bin/bash
 
-# Variables
-GIZMOSQL_SERVER_URI="jdbc:arrow-flight-sql://localhost:31337?useEncryption=false"
-GIZMOSQL_USERNAME=clickbench
-GIZMOSQL_PASSWORD=clickbench
-PID_FILE="/tmp/gizmosql_server_$$.pid"
+# Env-var names match what gizmosql_client recognizes natively, so the
+# query/load scripts can invoke gizmosql_client without explicit flags.
+# (The server's own username env var is GIZMOSQL_USERNAME — we pass it
+# explicitly via --username.)
+export GIZMOSQL_HOST=localhost
+export GIZMOSQL_PORT=31337
+export GIZMOSQL_USER=clickbench
+export GIZMOSQL_PASSWORD=clickbench
 
-# Function to start the GizmoSQL server
-start_gizmosql() {
-    export GIZMOSQL_PASSWORD="${GIZMOSQL_PASSWORD}"
+# Stable PID path: start and stop run in different bash processes, so $$ won't
+# match between them.
+PID_FILE=/tmp/gizmosql_server.pid
 
+start_gizmosql() {
     nohup gizmosql_server \
-        --username ${GIZMOSQL_USERNAME} \
+        --username "${GIZMOSQL_USER}" \
         --database-filename clickbench.db \
         --print-queries >> gizmosql_server.log 2>&1 &
 
     echo $! > "${PID_FILE}"
 
-    # Wait for server to be ready
-    echo "Waiting for gizmosql_server to start..."
-    while ! nc -z localhost 31337 2>/dev/null; do
+    echo "Waiting for gizmosql_server to start..." >&2
+    while ! nc -z "${GIZMOSQL_HOST}" "${GIZMOSQL_PORT}" 2>/dev/null; do
         sleep 1
     done
-    echo "gizmosql_server is ready (PID: $(cat ${PID_FILE}))"
+    echo "gizmosql_server is ready (PID: $(cat ${PID_FILE}))" >&2
 }
 
-# Function to stop the GizmoSQL server
 stop_gizmosql() {
     if [ -f "${PID_FILE}" ]; then
-        local pid=$(cat "${PID_FILE}")
+        local pid
+        pid=$(cat "${PID_FILE}")
         if kill -0 "$pid" 2>/dev/null; then
-            echo "Stopping gizmosql_server (PID: $pid)..."
+            echo "Stopping gizmosql_server (PID: $pid)..." >&2
             kill "$pid"
-            wait "$pid" 2>/dev/null
+            wait "$pid" 2>/dev/null || true
         fi
         rm -f "${PID_FILE}"
     fi