feat(rust/driver/snowflake): add adbc_snowflake crate with Go driver wrapper

.github/workflows/rust.yml

@@ -70,6 +70,15 @@ jobs:
         run: |
           rustup toolchain install stable --no-self-update
           rustup default stable
+      - name: Get required Go version
+        run: |
+          (. ../.env && echo "GO_VERSION=${GO}") >> $GITHUB_ENV
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "${{ env.GO_VERSION }}"
+          check-latest: true
+          cache: true
+          cache-dependency-path: go/adbc/go.sum
       - uses: actions/download-artifact@v4
         with:
           name: driver-manager-${{ matrix.os }}

rust/Cargo.toml

@@ -16,7 +16,7 @@
 # under the License.
 
 [workspace]
-members = ["core", "drivers/*"]
+members = ["core", "driver/*"]
 resolver = "2"
 
 [workspace.package]

rust/driver/snowflake/Cargo.toml

@@ -0,0 +1,29 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+[package]
+name = "adbc_snowflake"
+description = "Snowflake Arrow Database Connectivity (ADBC) driver"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+
+[dependencies]
+adbc_core = { path = "../../core", features = ["driver_manager"] }
+arrow-array.workspace = true
+arrow-schema.workspace = true

rust/driver/snowflake/README.md

@@ -0,0 +1,20 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# Snowflake driver for Arrow Database Connectivity (ADBC)

rust/driver/snowflake/build.rs

@@ -0,0 +1,57 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::{env, error::Error, path::PathBuf, process::Command};
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR")?);
+    let go_dir = manifest_dir.ancestors().nth(3).unwrap().join("go");
+    let go_pkg = go_dir.join("adbc/pkg/snowflake");
+
+    let out_dir = PathBuf::from(env::var("OUT_DIR")?);
+    let archive = out_dir.join("libsnowflake.a");
+
+    // Build the Go driver
+    let status = Command::new("go")
+        .current_dir(go_pkg.as_path())
+        .arg("build")
+        .arg("-tags")
+        .arg("driverlib")
+        .arg("-buildmode=c-archive")
+        .arg("-o")
+        .arg(&archive)
+        .arg(".")
+        .status()?;
+    assert!(status.success(), "Go build failed");
+
+    // Rebuild when the Go pkg changes.
+    println!("cargo:rerun-if-changed={}", go_pkg.display());
+
+    // Link the driver statically.
+    println!("cargo:rustc-link-search=native={}", out_dir.display());
+    println!("cargo:rustc-link-lib=static=snowflake");
+
+    // Link other dependencies.
+    println!("cargo:rustc-link-lib=resolv");
+    #[cfg(target_os = "macos")]
+    {
+        println!("cargo:rustc-link-lib=framework=CoreFoundation");
+        println!("cargo:rustc-link-lib=framework=Security");
+    }
+
+    Ok(())
+}

rust/driver/snowflake/src/connection.rs

@@ -0,0 +1,131 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::collections::HashSet;
+
+use adbc_core::{
+    driver_manager::ManagedConnection,
+    error::Result,
+    options::{InfoCode, OptionConnection, OptionValue},
+    Connection, Optionable,
+};
+use arrow_array::RecordBatchReader;
+use arrow_schema::Schema;
+
+use crate::SnowflakeStatement;
+
+/// Snowflake ADBC Connection.
+pub struct SnowflakeConnection(pub(crate) ManagedConnection);
+
+impl Optionable for SnowflakeConnection {
+    type Option = OptionConnection;
+
+    fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()> {
+        self.0.set_option(key, value)
+    }
+
+    fn get_option_string(&self, key: Self::Option) -> Result<String> {
+        self.0.get_option_string(key)
+    }
+
+    fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>> {
+        self.0.get_option_bytes(key)
+    }
+
+    fn get_option_int(&self, key: Self::Option) -> Result<i64> {
+        self.0.get_option_int(key)
+    }
+
+    fn get_option_double(&self, key: Self::Option) -> Result<f64> {
+        self.0.get_option_double(key)
+    }
+}
+
+impl Connection for SnowflakeConnection {
+    type StatementType = SnowflakeStatement;
+
+    fn new_statement(&mut self) -> Result<Self::StatementType> {
+        self.0.new_statement().map(SnowflakeStatement)
+    }
+
+    fn cancel(&mut self) -> Result<()> {
+        self.0.cancel()
+    }
+
+    fn get_info(&self, codes: Option<HashSet<InfoCode>>) -> Result<impl RecordBatchReader + Send> {
+        self.0.get_info(codes)
+    }
+
+    fn get_objects(
+        &self,
+        depth: adbc_core::options::ObjectDepth,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        table_type: Option<Vec<&str>>,
+        column_name: Option<&str>,
+    ) -> Result<impl RecordBatchReader + Send> {
+        self.0.get_objects(
+            depth,
+            catalog,
+            db_schema,
+            table_name,
+            table_type,
+            column_name,
+        )
+    }
+
+    fn get_table_schema(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: &str,
+    ) -> Result<Schema> {
+        self.0.get_table_schema(catalog, db_schema, table_name)
+    }
+
+    fn get_table_types(&self) -> Result<impl RecordBatchReader + Send> {
+        self.0.get_table_types()
+    }
+
+    fn get_statistic_names(&self) -> Result<impl RecordBatchReader + Send> {
+        self.0.get_statistic_names()
+    }
+
+    fn get_statistics(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        approximate: bool,
+    ) -> Result<impl RecordBatchReader + Send> {
+        self.0
+            .get_statistics(catalog, db_schema, table_name, approximate)
+    }
+
+    fn commit(&mut self) -> Result<()> {
+        self.0.commit()
+    }
+
+    fn rollback(&mut self) -> Result<()> {
+        self.0.rollback()
+    }
+
+    fn read_partition(&self, partition: impl AsRef<[u8]>) -> Result<impl RecordBatchReader + Send> {
+        self.0.read_partition(partition)
+    }
+}

rust/driver/snowflake/src/database.rs

@@ -0,0 +1,69 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use adbc_core::{
+    driver_manager::ManagedDatabase,
+    error::Result,
+    options::{OptionConnection, OptionDatabase, OptionValue},
+    Database, Optionable,
+};
+
+use crate::SnowflakeConnection;
+
+/// Snowflake ADBC Database.
+pub struct SnowflakeDatabase(pub(crate) ManagedDatabase);
+
+impl Optionable for SnowflakeDatabase {
+    type Option = OptionDatabase;
+
+    fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()> {
+        self.0.set_option(key, value)
+    }
+
+    fn get_option_string(&self, key: Self::Option) -> Result<String> {
+        self.0.get_option_string(key)
+    }
+
+    fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>> {
+        self.0.get_option_bytes(key)
+    }
+
+    fn get_option_int(&self, key: Self::Option) -> Result<i64> {
+        self.0.get_option_int(key)
+    }
+
+    fn get_option_double(&self, key: Self::Option) -> Result<f64> {
+        self.0.get_option_double(key)
+    }
+}
+
+impl Database for SnowflakeDatabase {
+    type ConnectionType = SnowflakeConnection;
+
+    fn new_connection(&mut self) -> Result<Self::ConnectionType> {
+        self.0.new_connection().map(SnowflakeConnection)
+    }
+
+    fn new_connection_with_opts(
+        &mut self,
+        opts: impl IntoIterator<Item = (OptionConnection, OptionValue)>,
+    ) -> Result<Self::ConnectionType> {
+        self.0
+            .new_connection_with_opts(opts)
+            .map(SnowflakeConnection)
+    }
+}