fix: provide default getObject(Class) fallback in QueryJDBCAccessor

QueryJDBCAccessor.getObject(Class) threw "Operation not supported" no
matter what. That's a problem: JDBC says
ResultSet.getObject(int, Class<T>) is supposed to return the value as
T when the conversion is trivial, but every accessor that didn't
override it would throw, even on the identity case like
getObject(col, String.class) against a VARCHAR. Callers had to either
know which accessors implement typed conversion or wrap calls in
catch-and-retry.

The new default does the obvious thing: reject null type with SQLState
22023, fetch the raw object, return null if it's null, return it cast
to T if type.isInstance(raw), otherwise throw a typed conversion
error. Accessors with richer needs (timestamp accessors return
Instant, OffsetDateTime, etc.) keep their overrides.
TimeStampVectorAccessor and TimeStampTZVectorAccessor are the two
that have them today.

Tests in StreamingResultSetMethodTest cover:
- getObjectWithClassUsesAccessorBaseFallback: identity case
  (VARCHAR -> String) returns the value via the inherited fallback.
- getObjectWithNullClassThrows: null type parameter raises
  SQLException with the expected "must not be null" message.
- getObjectWithIncompatibleClassThrows: requesting an unrelated type
  (String column, StringBuilder asked) raises the typed conversion
  error rather than returning null or the raw value.
- getObjectWithClassReturnsNullForNullValue: a null column value
  short-circuits and returns null regardless of the requested type;
  wasNull() is true afterwards.
The existing QueryJDBCAccessorTest still passes since it doesn't
touch getObject(Class). Null-type rejection is also pinned by
TimeStampVectorAccessorTest and
TimeZoneIntegrationTest.testGetObjectWithNullTypeThrows.

Author: mkaufmann

jdbc-core/src/main/java/com/salesforce/datacloud/jdbc/core/accessor/QueryJDBCAccessor.java

@@ -193,9 +193,28 @@ public Reader getNCharacterStream() throws SQLException {
         throw getOperationNotSupported(this.getClass());
     }
 
-    @Override
-    public <T> T getObject(Class<T> aClass) throws SQLException {
-        throw getOperationNotSupported(aClass.getClass());
+    /**
+     * Default {@code getObject(Class)} implementation: take the raw object produced by
+     * {@link #getObject()} and return it if {@code type.isInstance(raw)}, otherwise raise a
+     * conversion error. Accessors that need richer conversion (e.g. an Arrow {@code TIMESTAMP}
+     * vector returning {@link java.time.Instant} / {@link java.time.OffsetDateTime}) override
+     * this; everyone else inherits this generic path so callers do not need to special-case
+     * "accessor implements typed getObject" vs "accessor does not".
+     */
+    @Override
+    public <T> T getObject(Class<T> type) throws SQLException {
+        if (type == null) {
+            throw new SQLException("type parameter must not be null", "22023");
+        }
+        Object raw = getObject();
+        if (raw == null) {
+            return null;
+        }
+        if (type.isInstance(raw)) {
+            return type.cast(raw);
+        }
+        throw new SQLException("Cannot convert column value to " + type.getName() + "; actual type is "
+                + raw.getClass().getName());
     }
 
     private static SQLException getOperationNotSupported(final Class<?> type) {

jdbc-core/src/test/java/com/salesforce/datacloud/jdbc/core/StreamingResultSetMethodTest.java

@@ -38,10 +38,24 @@ class StreamingResultSetMethodTest {
 
     @SneakyThrows
     private StreamingResultSet createResultSet() {
+        return createSingleVarCharResultSet(false);
+    }
+
+    @SneakyThrows
+    private StreamingResultSet createResultSetWithNullValue() {
+        return createSingleVarCharResultSet(true);
+    }
+
+    @SneakyThrows
+    private StreamingResultSet createSingleVarCharResultSet(boolean nullValue) {
         val allocator = ext.getRootAllocator();
         val vector = new VarCharVector("col1", allocator);
         vector.allocateNew();
-        vector.set(0, "hello".getBytes(StandardCharsets.UTF_8));
+        if (nullValue) {
+            vector.setNull(0);
+        } else {
+            vector.set(0, "hello".getBytes(StandardCharsets.UTF_8));
+        }
         vector.setValueCount(1);
 
         val root = new VectorSchemaRoot(Arrays.asList(vector.getField()), Arrays.asList(vector));
@@ -143,6 +157,52 @@ void methodsThrowAfterClose() throws Exception {
                 .hasMessageContaining("closed");
     }
 
+    @Test
+    void getObjectWithClassUsesAccessorBaseFallback() throws Exception {
+        // VarCharVectorAccessor does not override getObject(Class); it inherits the default in
+        // QueryJDBCAccessor that does raw + isInstance. Pin that this delivers a String for a
+        // VARCHAR column — regressing the base-class fallback breaks every accessor that does
+        // not implement typed conversion of its own.
+        try (val rs = createResultSet()) {
+            rs.next();
+            assertThat(rs.getObject(1, String.class)).isEqualTo("hello");
+        }
+    }
+
+    @Test
+    void getObjectWithNullClassThrows() throws Exception {
+        try (val rs = createResultSet()) {
+            rs.next();
+            assertThatThrownBy(() -> rs.getObject(1, (Class<?>) null))
+                    .isInstanceOf(SQLException.class)
+                    .hasMessageContaining("must not be null");
+        }
+    }
+
+    @Test
+    void getObjectWithIncompatibleClassThrows() throws Exception {
+        // VarCharVectorAccessor returns a String. Asking for an unrelated type (StringBuilder
+        // here) cannot be satisfied by isInstance, so the fallback should surface a typed
+        // conversion error rather than silently returning null or the raw string.
+        try (val rs = createResultSet()) {
+            rs.next();
+            assertThatThrownBy(() -> rs.getObject(1, StringBuilder.class))
+                    .isInstanceOf(SQLException.class)
+                    .hasMessageContaining("Cannot convert");
+        }
+    }
+
+    @Test
+    void getObjectWithClassReturnsNullForNullValue() throws Exception {
+        // A null column value should round-trip as null regardless of the requested type — the
+        // fallback short-circuits before the isInstance check.
+        try (val rs = createResultSetWithNullValue()) {
+            rs.next();
+            assertThat(rs.getObject(1, String.class)).isNull();
+            assertThat(rs.wasNull()).isTrue();
+        }
+    }
+
     @Test
     void queryId() throws Exception {
         try (val rs = createResultSet()) {