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: getObjectWithClassUsesAccessorBaseFallback in
StreamingResultSetMethodTest exercises the inherited path on a
VARCHAR column. The existing QueryJDBCAccessorTest still passes since
it doesn't touch getObject(Class). Null-type rejection is already
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

@@ -143,6 +143,18 @@ 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 queryId() throws Exception {
         try (val rs = createResultSet()) {