Draft enable ODBC global setup/teardown

Author: alinaliBQ

cpp/src/arrow/compute/registry.cc

@@ -30,14 +30,31 @@
 #include "arrow/util/config.h"  // For ARROW_COMPUTE
 #include "arrow/util/logging.h"
 
+#include <iostream> // -AL- TEMP remove later
+
 namespace arrow {
 namespace compute {
 
 class FunctionRegistry::FunctionRegistryImpl {
  public:
   explicit FunctionRegistryImpl(FunctionRegistryImpl* parent = NULLPTR)
-      : parent_(parent) {}
-  ~FunctionRegistryImpl() {}
+      : parent_(parent) {// -AL- TEMP remove later
+    std::cout << "-AL- FunctionRegistryImpl constructor called\n";
+  }
+  ~FunctionRegistryImpl() { // -AL- TEMP remove later
+    size_t name_size = name_to_function_.size();
+    std::cout << "-AL- ~FunctionRegistryImpl name_to_function_ size:" << name_size <<
+      "\n";
+
+    //auto it = name_to_function_.find(std::string("split_pattern"));
+    //auto func = it->second;
+    //for (auto& kv : name_to_function_) {
+    //  kv.second.reset();
+    //}
+    //name_to_function_.clear();
+
+    std::cout << "-AL- ~FunctionRegistryImpl destructor called\n";
+  }
 
   Status CanAddFunction(std::shared_ptr<Function> function, bool allow_overwrite) {
     if (parent_ != NULLPTR) {
@@ -127,6 +144,9 @@ class FunctionRegistry::FunctionRegistryImpl {
 
   const Function* cast_function() { return cast_function_; }
 
+  void ClearFunctioRegistry() { name_to_function_.clear();
+  }
+
  private:
   // must not acquire mutex
   Status CanAddFunctionName(const std::string& name, bool allow_overwrite) {
@@ -215,6 +235,7 @@ class FunctionRegistry::FunctionRegistryImpl {
 };
 
 std::unique_ptr<FunctionRegistry> FunctionRegistry::Make() {
+  std::cout << "-AL- Make is called once TEMP \n";
   return std::unique_ptr<FunctionRegistry>(new FunctionRegistry());
 }
 
@@ -277,9 +298,14 @@ int FunctionRegistry::num_functions() const { return impl_->num_functions(); }
 
 const Function* FunctionRegistry::cast_function() const { return impl_->cast_function(); }
 
+void FunctionRegistry::ClearFunctioRegistry() {
+  impl_->ClearFunctioRegistry();
+}
+
 namespace internal {
 
 static std::unique_ptr<FunctionRegistry> CreateBuiltInRegistry() {
+  std::cout << "-AL- CreateBuiltInRegistry is called once TEMP \n";
   auto registry = FunctionRegistry::Make();
 
   // Register core kernels

cpp/src/arrow/compute/registry.h

@@ -111,6 +111,9 @@ class ARROW_EXPORT FunctionRegistry {
   ///
   /// Helpful for get cast function as needed.
   const Function* cast_function() const;
+  
+  // -AL- todo docs?
+  void ClearFunctioRegistry();
 
  private:
   FunctionRegistry();

cpp/src/arrow/flight/sql/odbc/tests/CMakeLists.txt

@@ -34,6 +34,7 @@ add_arrow_test(flight_sql_odbc_test
                SOURCES
                odbc_test_suite.cc
                odbc_test_suite.h
+               odbc_test_util.h
                connection_test.cc
                # Enable Protobuf cleanup after test execution
                # GH-46889: move protobuf_test_util to a more common location

cpp/src/arrow/flight/sql/odbc/tests/odbc_test_suite.cc

@@ -20,6 +20,7 @@
 #include "arrow/flight/sql/odbc/odbc_impl/flight_sql_connection.h"
 
 #include "arrow/flight/sql/odbc/tests/odbc_test_suite.h"
+#include "arrow/flight/sql/odbc/tests/odbc_test_util.h"
 
 // For DSN registration
 #include "arrow/flight/sql/odbc/odbc_impl/config/configuration.h"
@@ -28,6 +29,13 @@
 
 namespace arrow::flight::sql::odbc {
 
+// -AL- todo rename later
+auto alinatest_env = ::testing::AddGlobalTestEnvironment(new AlinaTestEnvironment);
+
+AlinaTestEnvironment* GetAlinaTestEnv() {
+  return ::arrow::internal::checked_cast<AlinaTestEnvironment*>(alinatest_env);
+}
+
 void ODBCRemoteTestBase::AllocEnvConnHandles(SQLINTEGER odbc_ver) {
   // Allocate an environment handle
   ASSERT_EQ(SQL_SUCCESS, SQLAllocEnv(&env));
@@ -54,12 +62,16 @@ void ODBCRemoteTestBase::ConnectWithString(std::string connect_str) {
   SQLWCHAR out_str[kOdbcBufferSize];
   SQLSMALLINT out_str_len;
 
+  // -AL- once local conn handles are removed,can rename back to conn
+   SQLHDBC global_conn = GetAlinaTestEnv()->getConnHandle();
+  //SQLHDBC global_conn = conn;  //-AL- TEMP
+
   // Connecting to ODBC server.
   ASSERT_EQ(SQL_SUCCESS,
-            SQLDriverConnect(conn, NULL, &connect_str0[0],
+            SQLDriverConnect(global_conn, NULL, &connect_str0[0],
                              static_cast<SQLSMALLINT>(connect_str0.size()), out_str,
                              kOdbcBufferSize, &out_str_len, SQL_DRIVER_NOPROMPT))
-      << GetOdbcErrorMessage(SQL_HANDLE_DBC, conn);
+       << GetOdbcErrorMessage(SQL_HANDLE_DBC, global_conn);
 
   // GH-47710: TODO Allocate a statement using alloc handle
   // ASSERT_EQ(SQL_SUCCESS, SQLAllocHandle(SQL_HANDLE_STMT, conn, &stmt));
@@ -69,9 +81,12 @@ void ODBCRemoteTestBase::Disconnect() {
   // GH-47710: TODO Close statement
   // EXPECT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_STMT, stmt));
 
+    // -AL- once local conn handles are removed,can rename back to conn
+  SQLHDBC global_conn = GetAlinaTestEnv()->getConnHandle();
+
   // Disconnect from ODBC
-  EXPECT_EQ(SQL_SUCCESS, SQLDisconnect(conn))
-      << GetOdbcErrorMessage(SQL_HANDLE_DBC, conn);
+  EXPECT_EQ(SQL_SUCCESS, SQLDisconnect(global_conn))
+      << GetOdbcErrorMessage(SQL_HANDLE_DBC, global_conn);
 
   FreeEnvConnHandles();
 }

cpp/src/arrow/flight/sql/odbc/tests/odbc_test_util.h

@@ -0,0 +1,83 @@
+// 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.
+
+#include <gtest/gtest.h>
+
+#include "arrow/flight/sql/odbc/odbc_impl/platform.h"
+
+#include "arrow/compute/api.h" // -AL- attempt to keep registry alive
+
+#include <sql.h>
+#include <sqlucode.h>
+
+#include <iostream>
+
+namespace arrow::flight::sql::odbc {
+
+// -AL- todo update to actual ODBC allocation
+class AlinaTestEnvironment : public ::testing::Environment {
+ public:
+  void SetUp() override {
+    int x = 1;
+    // -AL- todo add env_v2 for v2 after global setup/teardown works.
+
+    // Allocate an environment handle
+    ASSERT_EQ(SQL_SUCCESS, SQLAllocEnv(&env));
+
+    ASSERT_EQ(SQL_SUCCESS,
+              SQLSetEnvAttr(
+                  env, SQL_ATTR_ODBC_VERSION,
+                  reinterpret_cast<SQLPOINTER>(static_cast<intptr_t>(SQL_OV_ODBC3)), 0));
+
+    // Allocate a connection using alloc handle
+    ASSERT_EQ(SQL_SUCCESS, SQLAllocHandle(SQL_HANDLE_DBC, env, &conn));
+    std::cout << "-AL- AlinaTestEnvironment::SetUp\n";
+  }
+
+  void TearDown() override {
+
+
+    // -AL- this doesn't work
+    //// Remove function registry before test exits
+    auto reg = arrow::compute::GetFunctionRegistry();
+    reg->ClearFunctioRegistry();
+    // delete reg;
+
+
+    int y = 1;
+    // Free connection handle
+    EXPECT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_DBC, conn));
+
+    // Free environment handle
+    EXPECT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_ENV, env));
+    std::cout << "-AL- AlinaTestEnvironment::TearDown\n";
+
+  }
+
+  SQLHENV getEnvHandle() { return env; }
+
+  SQLHDBC getConnHandle() { return conn; }
+
+ private:
+  /** ODBC Environment. */
+  SQLHENV env = 0;
+
+  /** ODBC Connect. */
+  SQLHDBC conn = 0;
+};
+
+}  // namespace arrow::flight::sql::odbc