test: add end-to-end DatabaseMetaData integration tests against local Hyper (#172)

Existing DatabaseMetaData coverage was unit-test-only with mocked gRPC
responses, which couldn't catch mismatches between QueryMetadataUtil's
type mapping and what a real pg_catalog returns.

Test harness:
- DatabaseAttachInterceptor: gRPC ClientInterceptor that attaches a
named .hyper database to every ExecuteQuery call. Lets a JDBC connection
target a specific database file without touching the caller's
QueryParam.
- HyperDatabaseSetup: raw-gRPC (JDBC-independent) utility that creates a
temp .hyper database and populates a test table covering every supported
type — bool, smallint, int, bigint, double precision, numeric, text,
varchar, char, date, time, timestamp, timestamptz, interval, json, oid,
int[], text[], plus explicit nullable / NOT NULL int columns.
- hyper_with_database.yaml: hyperd config with DATABASE_HYPER_EXTERNAL
authorization, fixed init-user, and experimental_data_type_persistence
so arrays survive in non-temp tables.
- HyperServerConfig.databasePath: new -d flag passthrough for hyperd.
- HyperServerManager.ConfigFile.WITH_DATABASE: new config profile.

Tests:

DatabaseMetadataIntegrationTest boots hyperd with -d, creates a real
database via the interceptor, and exercises getSchemas / getTables /
getColumns against actual pg_catalog rows.

The suite is deliberately a living bug list: every assertion that pins
current-but-incorrect behaviour carries a BUG: comment stating the
spec-correct value. Fixing the underlying defect will break the
assertion and force the override to be deleted.

The single strongest test is a cross-check between DatabaseMetaData
.getColumns() (pg_catalog path, via QueryMetadataUtil) and
ResultSetMetaData from SELECT * WHERE false (Arrow schema path, via
ArrowToColumnTypeMapper). The two paths both claim to describe the same
column and must agree — today they disagree for 14 of 20 cross-checked
columns. The test encodes the exact set of known disagreements, so any
fix to either path immediately surfaces.

Bugs surfaced (all in QueryMetadataUtil unless noted):
- dbTypeToSql keys on pg-internal short names (int2, int4, float8, ...)
but the SQL template calls format_type() which emits long forms
(smallint, integer, double precision, ...). 7 of the 15 map entries are
unreachable; DATA_TYPE falls through to raw pg type OIDs instead of
java.sql.Types values.
- No prefix/contains handling for parameterised types, so 'character
varying(255)', 'character(1)', 'array(integer)', 'array(text)' never
match.
- COLUMN_SIZE is hardcoded to 255 regardless of the column.
- DECIMAL_DIGITS is hardcoded to 2 regardless of atttypmod.
- interval and json have no JDBC mapping at all.
- DECIMAL (Arrow) vs NUMERIC (pg_catalog) disagreement for numeric().
- oid is reported as INTEGER via Arrow but BIGINT via pg_catalog.
- ArrowToColumnTypeMapper.visit(Interval) throws, so any SELECT that
materialises an interval column crashes the driver.

Not covered: 32-bit floats (hyperd rejects 'real' locally with 'This
database does not support 32-bit floating points') and bytea.

Author: mkaufmann

jdbc-core/src/main/java/com/salesforce/datacloud/jdbc/interceptor/DatabaseAttachInterceptor.java

@@ -0,0 +1,75 @@
+/**
+ * This file is part of https://github.com/forcedotcom/datacloud-jdbc which is released under the
+ * Apache 2.0 license. See https://github.com/forcedotcom/datacloud-jdbc/blob/main/LICENSE.txt
+ */
+package com.salesforce.datacloud.jdbc.interceptor;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ForwardingClientCall;
+import io.grpc.MethodDescriptor;
+import salesforce.cdp.hyperdb.v1.AttachedDatabase;
+import salesforce.cdp.hyperdb.v1.QueryParam;
+
+/**
+ * A gRPC {@link ClientInterceptor} that attaches a database to every {@code ExecuteQuery} call.
+ *
+ * <p>This interceptor rewrites outgoing {@link QueryParam} messages to
+ * include the configured {@link AttachedDatabase} entry, which makes a Hyper
+ * database available in SQL under the given alias.</p>
+ *
+ * <p>Usage example:
+ * <pre>{@code
+ *   var interceptor = new DatabaseAttachInterceptor("/tmp/test.hyper", "default");
+ *   var channel = ManagedChannelBuilder.forAddress("127.0.0.1", port)
+ *       .usePlaintext()
+ *       .intercept(interceptor)
+ *       .build();
+ * }</pre>
+ */
+public class DatabaseAttachInterceptor implements ClientInterceptor {
+
+    private static final String EXECUTE_QUERY_METHOD = "salesforce.hyperdb.grpc.v1.HyperService/ExecuteQuery";
+
+    private final AttachedDatabase attachedDatabase;
+
+    /**
+     * Creates an interceptor that attaches the given database under the given alias.
+     *
+     * @param databasePath the path to the Hyper database (e.g. a file path or {@code hyper.external:} URI)
+     * @param alias        the SQL alias under which the database is accessible
+     */
+    public DatabaseAttachInterceptor(String databasePath, String alias) {
+        this.attachedDatabase = AttachedDatabase.newBuilder()
+                .setPath(databasePath)
+                .setAlias(alias)
+                .build();
+    }
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+            MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+        ClientCall<ReqT, RespT> call = next.newCall(method, callOptions);
+
+        if (!EXECUTE_QUERY_METHOD.equals(method.getFullMethodName())) {
+            return call;
+        }
+
+        return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(call) {
+            @Override
+            public void sendMessage(ReqT message) {
+                if (message instanceof QueryParam) {
+                    QueryParam original = (QueryParam) message;
+                    @SuppressWarnings("unchecked")
+                    ReqT rewritten = (ReqT)
+                            original.toBuilder().addDatabases(attachedDatabase).build();
+                    super.sendMessage(rewritten);
+                } else {
+                    super.sendMessage(message);
+                }
+            }
+        };
+    }
+}