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 covers the JDBC 4.2 conversions that every accessor
already exposes through its primitive getters, in this resolution
order:

1. null type -> SQLException with SQLState 22023.
2. String.class -> delegate to getString(). JDBC 4.2 Table B-5
   mandates this conversion for every column type, so handling it
   ahead of the raw-Object fallback means callers don't depend on
   getObject() returning a String.
3. Primitive wrapper / BigDecimal / byte[] -> delegate to the matching
   primitive getter. This covers numeric narrowing
   (getObject(col, Integer.class) on a BIGINT column) and honours
   wasNull so a null column returns null instead of an auto-boxed 0.
4. Otherwise raw + isInstance, accepting any supertype/interface match.
5. Anything left throws SQLFeatureNotSupportedException (matching the
   JDBC spec's expectation for unsupported conversions, and consistent
   with the existing TimeStampVectorAccessor override).

Accessors with richer needs (timestamp accessors return Instant,
OffsetDateTime, etc.) keep their overrides; the
testGetObjectWithInstantClassUsesOverride test pins that the
override path still wins over the new base default.

Tests in StreamingResultSetMethodTest cover:
- getObjectWithClassUsesAccessorBaseFallback: identity case
  (VARCHAR -> String) goes through the inherited String fast-path.
- getObjectWithSupertypeOrInterfaceReturnsValue: Object.class and
  CharSequence.class both work via isInstance — proves polymorphic
  callers (raw Object holders, generic tooling) aren't blocked.
- 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.
- getObjectWithClassReturnsNullForNullValue: a null column value
  short-circuits and returns null regardless of the requested type;
  wasNull() is true afterwards.
TimeStampVectorAccessorTest.testGetObjectWithInstantClassUsesOverride
pins that subclass overrides take precedence over the new base
fallback.

Author: mkaufmann

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

@@ -193,9 +193,103 @@ 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 covering the JDBC 4.2 conversions
+     * accessible from a {@link Object} or primitive getter.
+     *
+     * <p>Resolution order:
+     * <ol>
+     *   <li>{@code null} type → {@code SQLException} with SQLState {@code 22023}.
+     *   <li>{@link String} → delegate to {@link #getString()} (JDBC 4.2 Table B-5 mandates this
+     *       conversion for every column type).
+     *   <li>Primitive wrapper / {@link java.math.BigDecimal} / {@code byte[]} → delegate to the
+     *       matching primitive getter so numeric narrowing (e.g. {@code Integer.class} on a
+     *       BIGINT column) works. {@link #wasNull()} is honoured: a null column returns
+     *       {@code null} regardless of which wrapper was requested.
+     *   <li>Otherwise, take the raw object from {@link #getObject()} and return it via
+     *       {@code type.isInstance} when it fits.
+     *   <li>Anything left throws {@link SQLFeatureNotSupportedException}.
+     * </ol>
+     *
+     * <p>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");
+        }
+
+        // String works on every column type per JDBC 4.2 Table B-5; handle it before the
+        // raw-object fallback so callers don't depend on getObject() returning a String.
+        if (type == String.class) {
+            return type.cast(getString());
+        }
+
+        // Primitive-wrapper and java.math/byte[] conversions: delegate to the matching getter
+        // and short-circuit to null on the wasNull case so primitive defaults (0, false) don't
+        // leak as auto-boxed wrappers.
+        Object value = invokePrimitiveGetter(type);
+        if (value != PRIMITIVE_GETTER_MISS) {
+            return wasNull ? null : type.cast(value);
+        }
+
+        // Generic raw-object path: works whenever the column's natural Object representation
+        // is already an instance of the requested type (identity, supertype, or interface).
+        // Concrete accessors set wasNull inside getObject(); set it defensively here too so
+        // a callsite reading a null does not see stale state from an earlier non-null read.
+        Object raw = getObject();
+        if (raw == null) {
+            wasNull = true;
+            return null;
+        }
+        if (type.isInstance(raw)) {
+            return type.cast(raw);
+        }
+        throw new SQLFeatureNotSupportedException(
+                "Cannot convert column value of type " + raw.getClass().getName() + " to " + type.getName());
+    }
+
+    /** Sentinel returned when {@link #invokePrimitiveGetter} did not match the requested type. */
+    private static final Object PRIMITIVE_GETTER_MISS = new Object();
+
+    /**
+     * Returns the value of the matching primitive getter for {@code type}, auto-boxed for
+     * non-Object return types. Returns {@link #PRIMITIVE_GETTER_MISS} (a distinct sentinel from
+     * {@code null}, which is a legitimate return for {@code byte[].class}) when no primitive
+     * getter matches, so the caller can fall back to the raw-object path.
+     */
+    private Object invokePrimitiveGetter(Class<?> type) throws SQLException {
+        if (type == Boolean.class) {
+            return getBoolean();
+        }
+        if (type == Byte.class) {
+            return getByte();
+        }
+        if (type == Short.class) {
+            return getShort();
+        }
+        if (type == Integer.class) {
+            return getInt();
+        }
+        if (type == Long.class) {
+            return getLong();
+        }
+        if (type == Float.class) {
+            return getFloat();
+        }
+        if (type == Double.class) {
+            return getDouble();
+        }
+        if (type == BigDecimal.class) {
+            return getBigDecimal();
+        }
+        if (type == byte[].class) {
+            return getBytes();
+        }
+        return PRIMITIVE_GETTER_MISS;
     }
 
     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,65 @@ 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 getObjectWithSupertypeOrInterfaceReturnsValue() throws Exception {
+        // The isInstance check accepts any supertype or interface the raw object implements,
+        // not just the exact runtime class. Polymorphic callers (e.g. Object.class for
+        // generic introspection, CharSequence.class for tools that don't care about
+        // String-vs-StringBuffer) need this to work.
+        try (val rs = createResultSet()) {
+            rs.next();
+            assertThat((String) rs.getObject(1, Object.class)).isEqualTo("hello");
+            assertThat(rs.getObject(1, CharSequence.class).toString()).isEqualTo("hello");
+        }
+    }
+
     @Test
     void queryId() throws Exception {
         try (val rs = createResultSet()) {

jdbc-core/src/test/java/com/salesforce/datacloud/jdbc/core/accessor/impl/TimeStampVectorAccessorTest.java

@@ -755,6 +755,34 @@ void testGetObjectWithAllTypesForNaiveTimestamp() {
         }
     }
 
+    /**
+     * The {@link QueryJDBCAccessor} base class added a default {@code getObject(Class)} that
+     * handles String, primitive wrappers and the raw-Object isInstance case, but does not know
+     * about {@link Instant}. Pin that asking for {@code Instant.class} on a TIMESTAMP column
+     * still goes through this accessor's override (which does know how to build an Instant)
+     * rather than falling through to the base default — otherwise the override would silently
+     * dead-code itself if someone reordered method-resolution.
+     */
+    @Test
+    @SneakyThrows
+    void testGetObjectWithInstantClassUsesOverride() {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTimeZone(TimeZone.getTimeZone("UTC"));
+        List<Integer> monthNumber = getRandomMonthNumber();
+        val values = getMilliSecondValues(calendar, monthNumber);
+
+        try (val vector = extension.createTimeStampMilliVector(values)) {
+            val i = new AtomicInteger(0);
+            val sut = new TimeStampVectorAccessor(vector, i::get);
+
+            // First row: the override produces a real Instant matching the underlying value;
+            // the base class would have rejected Instant.class with SQLFeatureNotSupportedException.
+            Instant instant = sut.getObject(Instant.class);
+            collector.assertThat(instant).isNotNull();
+            collector.assertThat(instant.toEpochMilli()).isEqualTo(values.get(0));
+        }
+    }
+
     @Test
     @SneakyThrows
     void testGetObjectWithAllTypesForTimestampTZ() {