fix: provide default getObject(Class) fallback in QueryJDBCAccessor

Replace the base-class stub that threw `Operation not supported`
unconditionally with a generic raw-Object + isInstance fallback. JDBC's
`ResultSet.getObject(int, Class<T>)` is documented to deliver the column
value as an instance of the requested type when the conversion is
trivial; pre-this-change every accessor that did not explicitly
implement typed conversion would throw, even for the identity case
(`getObject(col, String.class)` on a VARCHAR column). Callers had to
either special-case "accessor implements typed getObject" vs "does not"
or wrap the call in catch-and-retry.

The new default checks for null type, fetches the raw object, returns
null on null, returns the raw object cast to T when the type is
assignable, and otherwise raises a typed conversion error. Accessors
that need richer conversion (e.g. timestamp -> Instant /
OffsetDateTime / ZonedDateTime / LocalDateTime) still override and are
unaffected.

Bundles `StreamingResultSetMethodTest.getObjectWithClassUsesAccessorBaseFallback`
which pins the inherited path end-to-end on a VARCHAR column whose
accessor does not implement typed conversion. Existing
`QueryJDBCAccessorTest` continues to pass since it does not exercise
`getObject(Class)`; null-type rejection is already pinned by
`TimeStampVectorAccessorTest`.

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()) {