feat(c/driver/sqlite): support the ADBC_INFO_DRIVER_ADBC_VERSION info key added in ADBC spec 1.1.0 (#3843)

The `ADBC_INFO_DRIVER_ADBC_VERSION` key was added in ADBC ​​1.1.0, but
it seems that it was not added to the SQLite driver.

Author: eitsupi

c/driver/sqlite/sqlite.cc

@@ -621,8 +621,9 @@ class SqliteConnection : public driver::Connection<SqliteConnection> {
 
   Result<std::vector<driver::InfoValue>> InfoImpl(const std::vector<uint32_t>& codes) {
     static std::vector<uint32_t> kDefaultCodes{
-        ADBC_INFO_VENDOR_NAME,    ADBC_INFO_VENDOR_VERSION,       ADBC_INFO_DRIVER_NAME,
-        ADBC_INFO_DRIVER_VERSION, ADBC_INFO_DRIVER_ARROW_VERSION,
+        ADBC_INFO_VENDOR_NAME,          ADBC_INFO_VENDOR_VERSION,
+        ADBC_INFO_DRIVER_NAME,          ADBC_INFO_DRIVER_VERSION,
+        ADBC_INFO_DRIVER_ARROW_VERSION, ADBC_INFO_DRIVER_ADBC_VERSION,
     };
     std::reference_wrapper<const std::vector<uint32_t>> codes_ref(codes);
     if (codes.empty()) {
@@ -648,6 +649,9 @@ class SqliteConnection : public driver::Connection<SqliteConnection> {
         case ADBC_INFO_DRIVER_ARROW_VERSION:
           result.emplace_back(code, NANOARROW_VERSION);
           break;
+        case ADBC_INFO_DRIVER_ADBC_VERSION:
+          result.emplace_back(code, static_cast<int64_t>(ADBC_VERSION_1_1_0));
+          break;
         default:
           // Ignore
           continue;

c/driver/sqlite/sqlite_test.cc

@@ -158,6 +158,8 @@ class SqliteQuirks : public adbc_validation::DriverQuirks {
         return "SQLite";
       case ADBC_INFO_VENDOR_VERSION:
         return "3.";
+      case ADBC_INFO_DRIVER_ADBC_VERSION:
+        return ADBC_VERSION_1_1_0;
       default:
         return std::nullopt;
     }
@@ -264,10 +266,8 @@ TEST_F(SqliteConnectionTest, GetInfoMetadata) {
 
   adbc_validation::StreamReader reader;
   std::vector<uint32_t> info = {
-      ADBC_INFO_DRIVER_NAME,
-      ADBC_INFO_DRIVER_VERSION,
-      ADBC_INFO_VENDOR_NAME,
-      ADBC_INFO_VENDOR_VERSION,
+      ADBC_INFO_DRIVER_NAME, ADBC_INFO_DRIVER_VERSION, ADBC_INFO_DRIVER_ADBC_VERSION,
+      ADBC_INFO_VENDOR_NAME, ADBC_INFO_VENDOR_VERSION,
   };
   ASSERT_THAT(AdbcConnectionGetInfo(&connection, info.data(), info.size(),
                                     &reader.stream.value, &error),
@@ -283,31 +283,37 @@ TEST_F(SqliteConnectionTest, GetInfoMetadata) {
       ASSERT_FALSE(ArrowArrayViewIsNull(reader.array_view->children[0], row));
       const uint32_t code =
           reader.array_view->children[0]->buffer_views[1].data.as_uint32[row];
+      const uint32_t offset =
+          reader.array_view->children[1]->buffer_views[1].data.as_int32[row];
       seen.push_back(code);
 
-      int str_child_index = 0;
-      struct ArrowArrayView* str_child =
-          reader.array_view->children[1]->children[str_child_index];
+      struct ArrowArrayView* str_child = reader.array_view->children[1]->children[0];
+      struct ArrowArrayView* int_child = reader.array_view->children[1]->children[2];
       switch (code) {
         case ADBC_INFO_DRIVER_NAME: {
-          ArrowStringView val = ArrowArrayViewGetStringUnsafe(str_child, 0);
+          ArrowStringView val = ArrowArrayViewGetStringUnsafe(str_child, offset);
           EXPECT_EQ("ADBC SQLite Driver", std::string(val.data, val.size_bytes));
           break;
         }
         case ADBC_INFO_DRIVER_VERSION: {
-          ArrowStringView val = ArrowArrayViewGetStringUnsafe(str_child, 1);
+          ArrowStringView val = ArrowArrayViewGetStringUnsafe(str_child, offset);
           EXPECT_EQ("(unknown)", std::string(val.data, val.size_bytes));
           break;
         }
         case ADBC_INFO_VENDOR_NAME: {
-          ArrowStringView val = ArrowArrayViewGetStringUnsafe(str_child, 2);
+          ArrowStringView val = ArrowArrayViewGetStringUnsafe(str_child, offset);
           EXPECT_EQ("SQLite", std::string(val.data, val.size_bytes));
           break;
         }
         case ADBC_INFO_VENDOR_VERSION: {
-          ArrowStringView val = ArrowArrayViewGetStringUnsafe(str_child, 3);
+          ArrowStringView val = ArrowArrayViewGetStringUnsafe(str_child, offset);
           EXPECT_THAT(std::string(val.data, val.size_bytes),
                       ::testing::MatchesRegex("3\\..*"));
+          break;
+        }
+        case ADBC_INFO_DRIVER_ADBC_VERSION: {
+          EXPECT_EQ(ADBC_VERSION_1_1_0, ArrowArrayViewGetIntUnsafe(int_child, offset));
+          break;
         }
         default:
           // Ignored

python/adbc_driver_manager/tests/test_dbapi.py

@@ -62,6 +62,7 @@ def test_attrs(sqlite):
 def test_info(sqlite):
     info = sqlite.adbc_get_info()
     assert set(info.keys()) == {
+        "driver_adbc_version",
         "driver_arrow_version",
         "driver_name",
         "driver_version",

python/adbc_driver_manager/tests/test_lowlevel.py

@@ -118,11 +118,12 @@ def test_database_set_options(sqlite_raw):
 def test_connection_get_info(sqlite_raw):
     _, conn = sqlite_raw
     codes = [
-        adbc_driver_manager.AdbcInfoCode.VENDOR_NAME,
+        adbc_driver_manager.AdbcInfoCode.VENDOR_NAME.value,
         adbc_driver_manager.AdbcInfoCode.VENDOR_VERSION.value,
-        adbc_driver_manager.AdbcInfoCode.DRIVER_NAME,
+        adbc_driver_manager.AdbcInfoCode.DRIVER_NAME.value,
         adbc_driver_manager.AdbcInfoCode.DRIVER_VERSION.value,
         adbc_driver_manager.AdbcInfoCode.DRIVER_ARROW_VERSION.value,
+        103,  # ADBC_INFO_DRIVER_ADBC_VERSION (not yet in AdbcInfoCode enum)
     ]
     handle = conn.get_info()
     table = _import(handle).read_all()

ruby/test/test-connection.rb

@@ -68,7 +68,8 @@ def test_all
                      vendor_version: "X.Y.Z",
                      driver_name: "ADBC SQLite Driver",
                      driver_version: "(unknown)",
-                     driver_arrow_version: "X.Y.Z"
+                     driver_arrow_version: "X.Y.Z",
+                     driver_adbc_version: ADBC::VERSION_1_1_0,
                    },
                    info)
     end

rust/driver_manager/tests/driver_manager_sqlite.rs

@@ -163,7 +163,7 @@ fn test_connection_get_info() {
     let mut driver = get_driver();
     let database = get_database(&mut driver);
     let connection = database.new_connection().unwrap();
-    common::test_connection_get_info(&connection, 5);
+    common::test_connection_get_info(&connection, 6);
 }
 
 #[test]