feat: Avatical Removal Part 3/3 - Remove Avatica dependency completely (#166)

Completes the removal of Apache Calcite Avatica from jdbc-core. The
driver no longer depends on Avatica for result set handling, cursor
management, type accessors
- Remove Avatica from StreamingResultSet: no longer extends
AvaticaResultSet. Implements DataCloudResultSet directly with all JDBC
ResultSet methods delegating to QueryJDBCAccessor instances. Adds proper
checkClosed() guards on all methods.
- Remove Avatica cursor layer: delete MetadataCursor (extended
AbstractCursor) and MetadataResultSet (extended AvaticaResultSet).
Replace with DataCloudMetadataResultSet, a standalone metadata result
set implementation.
- Extract DataCloudQueryAccessor interface: defines the accessor
contract (all typed getters) that QueryJDBCAccessor implements,
replacing the dependency on Avatica's AbstractCursor.Accessor.
- Rename for clarity: SimpleResultSetMetaData →
DataCloudResultSetMetaData, SimpleMetadataResultSet →
DataCloudMetadataResultSet, DataCloudAccessor → DataCloudQueryAccessor.

Author: carolinesheng

buildSrc/src/main/kotlin/shading.gradle.kts

@@ -38,7 +38,7 @@ abstract class ShadingExtension @Inject constructor(
         "META-INF/LICENSE*", "META-INF/NOTICE*",
         "META-INF/*.SF", "META-INF/*.DSA", "META-INF/*.RSA", "META-INF/*.xml",
         "**/*.proto", "org.slf4j",
-        "META-INF/services/com.fasterxml.*", "org.apache.calcite.avatica.remote.Driver",
+        "META-INF/services/com.fasterxml.*",
         ".netbeans_automatic_build", "git.properties", "google-http-client.properties",
         "storage.v1.json", "pipes-fork-server-default-log4j2.xml",
         "dependencies.properties", "arrow-git.properties"
@@ -73,9 +73,6 @@ abstract class ShadingExtension @Inject constructor(
             relocate("okhttp3", "$shadeBase.okhttp3")
             relocate("okio", "$shadeBase.okio")
             relocate("org.apache.arrow", "$shadeBase.org.apache.arrow")
-            relocate("org.apache.calcite", "$shadeBase.org.apache.calcite") {
-                exclude("org.apache.calcite.avatica.remote.Driver")
-            }
             relocate("org.apache.commons", "$shadeBase.org.apache.commons")
             relocate("org.apache.hc", "$shadeBase.org.apache.hc")
 

gradle/libs.versions.toml

@@ -20,8 +20,6 @@ net-jodah-failsafe = "3.3.2"
 netty = "4.1.132.Final"
 # This is soft pinned to 4.* (as we didn't invest in the upgrade yet) in `buildSrc/src/main/kotlin/version-updates.gradle.kts`
 okhttp3 = "4.12.0"
-# @pin this version as the following versions have a breaking Cursor change, that - with the upcoming Avactica removal - we currently don't want to invest in
-org-apache-calcite-avatica-core = "1.26.0"
 org-apache-commons-commons-lang3 = "3.20.0"
 # This is soft pinned to 3.* (as the driver is targetting in Spark 3) in `buildSrc/src/main/kotlin/version-updates.gradle.kts`
 org-apache-spark = "3.5.8"
@@ -43,7 +41,6 @@ slf4j = "2.0.17"
 [libraries]
 apache-arrow-memory-netty = { module = "org.apache.arrow:arrow-memory-netty", version.ref = "arrow" }
 apache-arrow-vector = { module = "org.apache.arrow:arrow-vector", version.ref = "arrow" }
-apache-calcite-avatica = { module = "org.apache.calcite.avatica:avatica-core", version.ref = "org-apache-calcite-avatica-core" }
 apache-commons-lang3 = { module = "org.apache.commons:commons-lang3", version.ref = "org-apache-commons-commons-lang3" }
 apache-httpcomponents-httpclient = { module = "org.apache.httpcomponents.client5:httpclient5", version.ref = "apache-httpcomponents-httpclient" }
 assertj = { module = "org.assertj:assertj-core", version.ref = "org-assertj-assertj-core" }

jdbc-core/build.gradle.kts

@@ -18,7 +18,6 @@ dependencies {
     implementation(project(":jdbc-util"))
     implementation(libs.slf4j.api)
     implementation(libs.bundles.arrow)
-    implementation(libs.apache.calcite.avatica)
     implementation(libs.guava)
     implementation(libs.jackson.databind)
     implementation(libs.failsafe)

jdbc-core/src/main/java/com/salesforce/datacloud/jdbc/core/ArrowStreamReaderCursor.java

@@ -6,11 +6,11 @@
 
 import static com.salesforce.datacloud.jdbc.util.ThrowingFunction.rethrowFunction;
 
+import com.salesforce.datacloud.jdbc.core.accessor.QueryJDBCAccessor;
 import com.salesforce.datacloud.jdbc.core.accessor.QueryJDBCAccessorFactory;
 import java.io.IOException;
 import java.sql.SQLException;
 import java.time.ZoneId;
-import java.util.Calendar;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
@@ -20,12 +20,9 @@
 import org.apache.arrow.vector.FieldVector;
 import org.apache.arrow.vector.VectorSchemaRoot;
 import org.apache.arrow.vector.ipc.ArrowStreamReader;
-import org.apache.calcite.avatica.ColumnMetaData;
-import org.apache.calcite.avatica.util.AbstractCursor;
-import org.apache.calcite.avatica.util.ArrayImpl;
 
 @Slf4j
-class ArrowStreamReaderCursor extends AbstractCursor {
+class ArrowStreamReaderCursor implements AutoCloseable {
 
     private static final int INIT_ROW_NUMBER = -1;
 
@@ -42,26 +39,19 @@ class ArrowStreamReaderCursor extends AbstractCursor {
         this.sessionZone = sessionZone;
     }
 
-    private void wasNullConsumer(boolean wasNull) {
-        this.wasNull[0] = wasNull;
-    }
-
     @SneakyThrows
     private VectorSchemaRoot getSchemaRoot() {
         return reader.getVectorSchemaRoot();
     }
 
-    @Override
-    @SneakyThrows
-    public List<Accessor> createAccessors(
-            List<ColumnMetaData> types, Calendar localCalendar, ArrayImpl.Factory factory) {
+    List<QueryJDBCAccessor> createAccessors() {
         return getSchemaRoot().getFieldVectors().stream()
                 .map(rethrowFunction(this::createAccessor))
                 .collect(Collectors.toList());
     }
 
-    private Accessor createAccessor(FieldVector vector) throws SQLException {
-        return QueryJDBCAccessorFactory.createAccessor(vector, currentIndex::get, this::wasNullConsumer, sessionZone);
+    private QueryJDBCAccessor createAccessor(FieldVector vector) throws SQLException {
+        return QueryJDBCAccessorFactory.createAccessor(vector, currentIndex::get, sessionZone);
     }
 
     private boolean loadNextBatch() throws IOException {
@@ -73,7 +63,6 @@ private boolean loadNextBatch() throws IOException {
     }
 
     @SneakyThrows
-    @Override
     public boolean next() {
         val current = currentIndex.incrementAndGet();
         val total = getSchemaRoot().getRowCount();
@@ -94,11 +83,6 @@ public boolean next() {
         }
     }
 
-    @Override
-    protected Getter createGetter(int i) {
-        throw new UnsupportedOperationException();
-    }
-
     @SneakyThrows
     @Override
     public void close() {

jdbc-core/src/main/java/com/salesforce/datacloud/jdbc/core/ColumnNameResolver.java

@@ -4,11 +4,11 @@
  */
 package com.salesforce.datacloud.jdbc.core;
 
+import com.salesforce.datacloud.jdbc.core.metadata.ColumnMetadata;
 import java.sql.SQLException;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import org.apache.calcite.avatica.ColumnMetaData;
 
 /**
  * Resolves column names to their JDBC indices using fast HashMap lookups.
@@ -35,25 +35,19 @@ public final class ColumnNameResolver {
      *
      * @param columns the column metadata list
      */
-    public ColumnNameResolver(List<ColumnMetaData> columns) {
+    public ColumnNameResolver(List<ColumnMetadata> columns) {
         this.exactColumnLabelMap = new HashMap<>(columns.size());
         this.lowercaseColumnLabelMap = new HashMap<>(columns.size());
-
-        // First pass: index exact labels to ordinals
-        for (ColumnMetaData columnMetaData : columns) {
-            if (columnMetaData.label != null) {
-                // Use putIfAbsent to ensure first occurrence (lowest ordinal) wins for duplicates
-                exactColumnLabelMap.putIfAbsent(columnMetaData.label, columnMetaData.ordinal);
-            }
-        }
-
-        // Second pass: index lowercase labels to ordinals, but only if the lowercase key doesn't exist yet
+        // Index lowercase labels to ordinals, but only if the lowercase key doesn't exist yet
         // This ensures the first column with a given lowercase name wins (lowest ordinal)
-        for (ColumnMetaData columnMetaData : columns) {
-            if (columnMetaData.label != null) {
-                String lowerLabel = columnMetaData.label.toLowerCase();
+        for (int i = 0; i < columns.size(); i++) {
+            ColumnMetadata col = columns.get(i);
+            String label = col.getName();
+            if (label != null) {
+                // Use putIfAbsent to ensure first occurrence (lowest ordinal) wins for duplicates
+                exactColumnLabelMap.putIfAbsent(label, i);
                 // Only add if this lowercase key hasn't been seen yet (preserves first occurrence)
-                lowercaseColumnLabelMap.putIfAbsent(lowerLabel, columnMetaData.ordinal);
+                lowercaseColumnLabelMap.putIfAbsent(label.toLowerCase(), i);
             }
         }
     }
@@ -71,14 +65,13 @@ public int findColumn(String columnLabel) throws SQLException {
         // First try exact match (case-sensitive)
         Integer index = exactColumnLabelMap.get(columnLabel);
         if (index != null) {
-            // Avatica uses 0-based ordinals, but JDBC uses 1-based indices
+            // Internal ordinals are 0-based, but JDBC uses 1-based indices
             return index + 1;
         }
 
         // Fallback to lowercase match (case-insensitive)
         index = lowercaseColumnLabelMap.get(columnLabel.toLowerCase());
         if (index != null) {
-            // Avatica uses 0-based ordinals, but JDBC uses 1-based indices
             return index + 1;
         }
 

jdbc-core/src/main/java/com/salesforce/datacloud/jdbc/core/DataCloudConnection.java

@@ -10,6 +10,8 @@
 import static com.salesforce.datacloud.jdbc.util.ArrowUtils.toColumnMetaData;
 
 import com.google.protobuf.Empty;
+import com.salesforce.datacloud.jdbc.core.metadata.ColumnMetadata;
+import com.salesforce.datacloud.jdbc.core.metadata.DataCloudResultSetMetaData;
 import com.salesforce.datacloud.jdbc.core.partial.DataCloudQueryPolling;
 import com.salesforce.datacloud.jdbc.exception.DataCloudJDBCException;
 import com.salesforce.datacloud.jdbc.exception.QueryExceptionHandler;
@@ -47,7 +49,6 @@
 import java.sql.Struct;
 import java.time.Duration;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
@@ -61,9 +62,6 @@
 import lombok.NonNull;
 import lombok.extern.slf4j.Slf4j;
 import lombok.val;
-import org.apache.calcite.avatica.AvaticaResultSetMetaData;
-import org.apache.calcite.avatica.ColumnMetaData;
-import org.apache.calcite.avatica.Meta;
 import salesforce.cdp.hyperdb.v1.CancelQueryParam;
 import salesforce.cdp.hyperdb.v1.HyperServiceGrpc;
 
@@ -279,11 +277,8 @@ public DataCloudResultSet getChunkBasedResultSet(String queryId, long chunkId) t
     public ResultSetMetaData getSchemaForQueryId(String queryId) throws SQLException {
         try {
             val schema = QuerySchemaAccessor.getArrowSchema(QueryAccessGrpcClient.of(queryId, getStub()));
-            List<ColumnMetaData> columns = toColumnMetaData(schema.getFields());
-            // Create metadata directly without full ResultSet infrastructure
-            Meta.Signature signature = new Meta.Signature(
-                    columns, null, Collections.emptyList(), Collections.emptyMap(), null, Meta.StatementType.SELECT);
-            return new AvaticaResultSetMetaData(null, null, signature);
+            List<ColumnMetadata> columns = toColumnMetaData(schema.getFields());
+            return new DataCloudResultSetMetaData(columns);
         } catch (StatusRuntimeException ex) {
             throw createException(connectionProperties.isIncludeCustomerDetailInReason(), null, queryId, ex);
         }

jdbc-core/src/main/java/com/salesforce/datacloud/jdbc/core/DataCloudDatabaseMetadata.java

@@ -10,7 +10,6 @@
 import static com.salesforce.datacloud.jdbc.core.QueryMetadataUtil.createSchemaResultSet;
 import static com.salesforce.datacloud.jdbc.core.QueryMetadataUtil.createTableResultSet;
 import static com.salesforce.datacloud.jdbc.core.QueryMetadataUtil.createTableTypesResultSet;
-import static com.salesforce.datacloud.jdbc.util.Constants.*;
 
 import com.google.common.collect.ImmutableList;
 import com.salesforce.datacloud.jdbc.config.DriverVersion;
@@ -688,39 +687,39 @@ public ResultSet getColumns(String catalog, String schemaPattern, String tableNa
     @Override
     public ResultSet getColumnPrivileges(String catalog, String schema, String table, String columnNamePattern)
             throws SQLException {
-        return MetadataResultSet.of();
+        return DataCloudMetadataResultSet.empty();
     }
 
     @Override
     public ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern)
             throws SQLException {
-        return MetadataResultSet.of();
+        return DataCloudMetadataResultSet.empty();
     }
 
     @Override
     public ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable)
             throws SQLException {
-        return MetadataResultSet.of();
+        return DataCloudMetadataResultSet.empty();
     }
 
     @Override
     public ResultSet getVersionColumns(String catalog, String schema, String table) throws SQLException {
-        return MetadataResultSet.of();
+        return DataCloudMetadataResultSet.empty();
     }
 
     @Override
     public ResultSet getPrimaryKeys(String catalog, String schema, String table) throws SQLException {
-        return MetadataResultSet.of();
+        return DataCloudMetadataResultSet.empty();
     }
 
     @Override
     public ResultSet getImportedKeys(String catalog, String schema, String table) throws SQLException {
-        return MetadataResultSet.of();
+        return DataCloudMetadataResultSet.empty();
     }
 
     @Override
     public ResultSet getExportedKeys(String catalog, String schema, String table) throws SQLException {
-        return MetadataResultSet.of();
+        return DataCloudMetadataResultSet.empty();
     }
 
     @Override
@@ -732,18 +731,18 @@ public ResultSet getCrossReference(
             String foreignSchema,
             String foreignTable)
             throws SQLException {
-        return MetadataResultSet.of();
+        return DataCloudMetadataResultSet.empty();
     }
 
     @Override
     public ResultSet getTypeInfo() throws SQLException {
-        return MetadataResultSet.of();
+        return DataCloudMetadataResultSet.empty();
     }
 
     @Override
     public ResultSet getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate)
             throws SQLException {
-        return MetadataResultSet.of();
+        return DataCloudMetadataResultSet.empty();
     }
 
     @Override

…d/jdbc/core/SimpleMetadataResultSet.java …dbc/core/DataCloudMetadataResultSet.javajdbc-core/src/main/java/com/salesforce/datacloud/jdbc/core/SimpleMetadataResultSet.java renamed to jdbc-core/src/main/java/com/salesforce/datacloud/jdbc/core/DataCloudMetadataResultSet.java jdbc-core/src/main/java/com/salesforce/datacloud/jdbc/core/SimpleMetadataResultSet.java renamed to jdbc-core/src/main/java/com/salesforce/datacloud/jdbc/core/DataCloudMetadataResultSet.java

@@ -5,47 +5,55 @@
 package com.salesforce.datacloud.jdbc.core;
 
 import com.salesforce.datacloud.jdbc.core.metadata.ColumnMetadata;
-import com.salesforce.datacloud.jdbc.core.metadata.SimpleResultSetMetaData;
+import com.salesforce.datacloud.jdbc.core.metadata.DataCloudResultSetMetaData;
 import com.salesforce.datacloud.jdbc.core.resultset.ColumnAccessor;
 import com.salesforce.datacloud.jdbc.core.resultset.SimpleResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
+import java.util.Collections;
 import java.util.List;
 import java.util.OptionalLong;
 
 /**
  * Custom ResultSet implementation for metadata queries
  */
-public class SimpleMetadataResultSet extends SimpleResultSet<SimpleMetadataResultSet> {
+public class DataCloudMetadataResultSet extends SimpleResultSet<DataCloudMetadataResultSet> {
 
     private final List<Object> data;
     private int currentRow = -1;
     private boolean closed = false;
 
-    private SimpleMetadataResultSet(
-            SimpleResultSetMetaData metadata, ColumnAccessor<SimpleMetadataResultSet>[] accessors, List<Object> data) {
+    private DataCloudMetadataResultSet(
+            DataCloudResultSetMetaData metadata,
+            ColumnAccessor<DataCloudMetadataResultSet>[] accessors,
+            List<Object> data) {
         super(metadata, accessors, false);
         this.data = data;
     }
 
-    public static SimpleMetadataResultSet of(SimpleResultSetMetaData metadata, List<Object> data) throws SQLException {
+    public static DataCloudMetadataResultSet empty() throws SQLException {
+        return of(new DataCloudResultSetMetaData(Collections.emptyList()), Collections.emptyList());
+    }
+
+    public static DataCloudMetadataResultSet of(DataCloudResultSetMetaData metadata, List<Object> data)
+            throws SQLException {
         @SuppressWarnings("unchecked")
-        ColumnAccessor<SimpleMetadataResultSet>[] accessors = new ColumnAccessor[metadata.getColumnCount()];
+        ColumnAccessor<DataCloudMetadataResultSet>[] accessors = new ColumnAccessor[metadata.getColumnCount()];
         for (int i = 0; i < metadata.getColumnCount(); i++) {
             final int columnIndex = i;
             accessors[i] = createAccessor(metadata.getColumn(i + 1), columnIndex);
         }
 
-        return new SimpleMetadataResultSet(metadata, accessors, data);
+        return new DataCloudMetadataResultSet(metadata, accessors, data);
     }
 
     /**
      * Creates a ColumnAccessor for a specific column.
      */
-    private static ColumnAccessor<SimpleMetadataResultSet> createAccessor(ColumnMetadata column, int columnIndex) {
-        return new ColumnAccessor<SimpleMetadataResultSet>() {
+    private static ColumnAccessor<DataCloudMetadataResultSet> createAccessor(ColumnMetadata column, int columnIndex) {
+        return new ColumnAccessor<DataCloudMetadataResultSet>() {
             @Override
-            public String getString(SimpleMetadataResultSet resultSet) throws SQLException {
+            public String getString(DataCloudMetadataResultSet resultSet) throws SQLException {
                 Object value = getValue(resultSet, columnIndex);
                 if (value == null) {
                     return null;
@@ -54,7 +62,7 @@ public String getString(SimpleMetadataResultSet resultSet) throws SQLException {
             }
 
             @Override
-            public Boolean getBoolean(SimpleMetadataResultSet resultSet) throws SQLException {
+            public Boolean getBoolean(DataCloudMetadataResultSet resultSet) throws SQLException {
                 Object value = getValue(resultSet, columnIndex);
                 if (value == null) {
                     return null;
@@ -66,7 +74,7 @@ public Boolean getBoolean(SimpleMetadataResultSet resultSet) throws SQLException
             }
 
             @Override
-            public OptionalLong getAnyInteger(SimpleMetadataResultSet resultSet) throws SQLException {
+            public OptionalLong getAnyInteger(DataCloudMetadataResultSet resultSet) throws SQLException {
                 Object value = getValue(resultSet, columnIndex);
                 if (value == null) {
                     return OptionalLong.empty();
@@ -81,7 +89,7 @@ public OptionalLong getAnyInteger(SimpleMetadataResultSet resultSet) throws SQLE
             /**
              * Helper method to get the value for the current row and column.
              */
-            private Object getValue(SimpleMetadataResultSet resultSet, int columnIndex) throws SQLException {
+            private Object getValue(DataCloudMetadataResultSet resultSet, int columnIndex) throws SQLException {
                 if (resultSet.closed) {
                     throw new SQLException("ResultSet is closed");
                 }