Fix tests on Linux

Author: justing-bq

ci/scripts/cpp_test.sh

@@ -55,7 +55,6 @@ if ! type minio >/dev/null 2>&1; then
 fi
 case "$(uname)" in
   Linux)
-    exclude_tests+=("arrow-flight-sql-odbc-test")
     n_jobs=$(nproc)
     ;;
   Darwin)

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

@@ -46,6 +46,9 @@ TYPED_TEST_SUITE(ColumnsOdbcV2Test, TestTypesOdbcV2);
 
 namespace {
 // Helper functions
+
+// GH-49702: TODO Disabled on Linux due to BlockingQueue issue
+#ifndef __linux__
 void CheckSQLColumns(
     SQLHSTMT stmt, const std::wstring& expected_table,
     const std::wstring& expected_column, const SQLINTEGER& expected_data_type,
@@ -125,6 +128,7 @@ void CheckRemoteSQLColumns(
                   expected_octet_char_length, expected_ordinal_position,
                   expected_is_nullable);
 }
+#endif  // __linux__
 
 void CheckSQLColAttribute(SQLHSTMT stmt, SQLUSMALLINT idx,
                           const std::string& expected_column_name,
@@ -415,6 +419,8 @@ TYPED_TEST(ColumnsTest, SQLColumnsTestInputData) {
   ValidateFetch(stmt, SQL_SUCCESS);
 }
 
+// GH-49702: TODO Disabled on Linux due to BlockingQueue issue
+#ifndef __linux__
 TEST_F(ColumnsMockTest, TestSQLColumnsAllColumns) {
   // Check table pattern and column pattern returns all columns
 
@@ -1209,6 +1215,7 @@ TEST_F(ColumnsMockTest, TestSQLColumnsTableColumnPattern) {
   // There is no more column
   EXPECT_EQ(SQL_NO_DATA, SQLFetch(stmt));
 }
+#endif  // __linux__
 
 TEST_F(ColumnsMockTest, TestSQLColumnsInvalidTablePattern) {
   ASSIGN_SQLWCHAR_ARR(table_pattern, L"non-existent-table");
@@ -1224,8 +1231,7 @@ TEST_F(ColumnsMockTest, TestSQLColumnsInvalidTablePattern) {
 TYPED_TEST(ColumnsTest, SQLColAttributeTestInputData) {
   ASSIGN_SQLWCHAR_ARR_AND_LEN(wsql, L"SELECT 1 as col1;");
 
-  ASSERT_EQ(SQL_SUCCESS, SQLExecDirect(stmt, wsql, wsql_len))
-      << GetOdbcErrorMessage(SQL_HANDLE_DBC, conn);
+  ASSERT_EQ(SQL_SUCCESS, SQLExecDirect(stmt, wsql, wsql_len));
 
   ASSERT_EQ(SQL_SUCCESS, SQLFetch(stmt));
 
@@ -2560,10 +2566,6 @@ TEST_F(ColumnsMockTest, SQLDescribeColUnicodeTableMetadata) {
 
   ASSIGN_SQLWCHAR_ARR_AND_LEN(sql_query, L"SELECT * from 数据 LIMIT 1;");
 
-  ASSIGN_SQLWCHAR_ARR_AND_LEN(expected_column_name, L"资料");
-  SQLSMALLINT expected_column_data_type = SQL_WVARCHAR;
-  SQLULEN expected_column_size = 0;
-
   ASSERT_EQ(SQL_SUCCESS, SQLExecDirect(stmt, sql_query, sql_query_len));
 
   ASSERT_EQ(SQL_SUCCESS, SQLFetch(stmt));
@@ -2572,13 +2574,14 @@ TEST_F(ColumnsMockTest, SQLDescribeColUnicodeTableMetadata) {
             SQLDescribeCol(stmt, column_index, column_name, buf_char_len, &name_length,
                            &column_data_type, &column_size, &decimal_digits, &nullable));
 
-  EXPECT_EQ(name_length, expected_column_name_len);
+  std::wstring expected_column_name_wstr = std::wstring(L"资料");
+  size_t expected_column_name_len = expected_column_name_wstr.length();
 
   std::wstring returned(column_name, column_name + name_length);
-  std::wstring expected_col_name_str = ConvertToWString(expected_column_name);
-  EXPECT_EQ(expected_col_name_str, returned);
-  EXPECT_EQ(expected_column_data_type, column_data_type);
-  EXPECT_EQ(expected_column_size, column_size);
+  EXPECT_EQ(expected_column_name_wstr, returned);
+  EXPECT_EQ(expected_column_name_len, name_length);
+  EXPECT_EQ(SQL_WVARCHAR, column_data_type);
+  EXPECT_EQ(0, column_size);
   EXPECT_EQ(0, decimal_digits);
   EXPECT_EQ(SQL_NULLABLE, nullable);
 

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

@@ -33,6 +33,13 @@ using TestTypes =
     ::testing::Types<FlightSQLODBCMockTestBase, FlightSQLODBCRemoteTestBase>;
 TYPED_TEST_SUITE(ConnectionAttributeTest, TestTypes);
 
+template <typename T>
+class ConnectionAttributePreConnectTest : public T {};
+
+using TestTypesHandle = ::testing::Types<FlightSQLOdbcEnvConnHandleMockTestBase,
+                                         FlightSQLOdbcEnvConnHandleRemoteTestBase>;
+TYPED_TEST_SUITE(ConnectionAttributePreConnectTest, TestTypesHandle);
+
 #ifdef SQL_ATTR_ASYNC_DBC_EVENT
 TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrAsyncDbcEventUnsupported) {
   ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(conn, SQL_ATTR_ASYNC_DBC_EVENT, 0, 0));
@@ -114,31 +121,33 @@ TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrTraceDMOnly) {
 }
 #endif  // __APPLE__
 
-TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrTracefileDMOnly) {
+TYPED_TEST(ConnectionAttributePreConnectTest, TestSQLSetConnectAttrTracefileDMOnly) {
   // Verify DM-only attribute is handled by Driver Manager
 
   // Use placeholder value as we want the call to fail, or else
   // the driver manager will produce a trace file.
   std::wstring trace_file = L"invalid/file/path";
   std::vector<SQLWCHAR> trace_file0(trace_file.begin(), trace_file.end());
+
+#ifdef _WIN32
   ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(conn, SQL_ATTR_TRACEFILE, &trace_file0[0],
                                          static_cast<SQLINTEGER>(trace_file0.size())));
-#ifdef __APPLE__
-  VerifyOdbcErrorState(SQL_HANDLE_DBC, conn, kErrorStateHYC00);
-#else
   VerifyOdbcErrorState(SQL_HANDLE_DBC, conn, kErrorStateHY000);
-#endif  // __APPLE__
+#else  // Mac & Linux
+  ASSERT_EQ(SQL_SUCCESS, SQLSetConnectAttr(conn, SQL_ATTR_TRACEFILE, &trace_file0[0],
+                                           static_cast<SQLINTEGER>(trace_file0.size())));
+#endif
 }
 
 TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrTranslateLabDMOnly) {
   // Verify DM-only attribute is handled by Driver Manager
   ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(conn, SQL_ATTR_TRANSLATE_LIB, 0, 0));
   // Checks for invalid argument return error
-#ifdef __APPLE__
-  VerifyOdbcErrorState(SQL_HANDLE_DBC, conn, kErrorStateHYC00);
-#else
+#ifdef _WIN32
   VerifyOdbcErrorState(SQL_HANDLE_DBC, conn, kErrorStateHY024);
-#endif  // __APPLE__
+#else  // Mac & Linux
+  VerifyOdbcErrorState(SQL_HANDLE_DBC, conn, kErrorStateHYC00);
+#endif
 }
 
 TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrTranslateOptionUnsupported) {
@@ -162,8 +171,8 @@ TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrDbcInfoTokenSetOnly) {
 }
 #endif
 
-// iODBC does not treat SQL_ATTR_ODBC_CURSORS as DM-only
-#ifndef __APPLE__
+// Driver Manager behavior tests for Windows only.
+#ifdef _WIN32
 TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrOdbcCursorsDMOnly) {
   // Verify that DM-only attribute is handled by driver manager
   SQLULEN cursor_attr;
@@ -172,15 +181,13 @@ TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrOdbcCursorsDMOnly) {
   EXPECT_EQ(SQL_CUR_USE_DRIVER, cursor_attr);
 }
 
-// iODBC needs to be compiled with tracing enabled to handle SQL_ATTR_TRACE
 TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrTraceDMOnly) {
   // Verify that DM-only attribute is handled by driver manager
   SQLUINTEGER trace;
   ASSERT_EQ(SQL_SUCCESS, SQLGetConnectAttr(conn, SQL_ATTR_TRACE, &trace, 0, nullptr));
   EXPECT_EQ(SQL_OPT_TRACE_OFF, trace);
 }
 
-// iODBC needs to be compiled with tracing enabled to handle SQL_ATTR_TRACEFILE
 TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrTraceFileDMOnly) {
   // Verify that DM-only attribute is handled by driver manager
   SQLWCHAR out_str[kOdbcBufferSize];
@@ -194,7 +201,7 @@ TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrTraceFileDMOnly) {
       ODBC::SqlWcharToString(out_str, static_cast<SQLSMALLINT>(out_str_len));
   EXPECT_FALSE(out_connection_string.empty());
 }
-#endif  // __APPLE__
+#endif  // _WIN32
 
 TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrTranslateLibUnsupported) {
   SQLWCHAR out_str[kOdbcBufferSize];
@@ -221,11 +228,16 @@ TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrTxnIsolationUnsupported
 #ifdef SQL_ATTR_ASYNC_DBC_FUNCTIONS_ENABLE
 TYPED_TEST(ConnectionAttributeTest,
            TestSQLGetConnectAttrAsyncDbcFunctionsEnableUnsupported) {
-  // Verifies that the Windows driver manager returns HY114 for unsupported functionality
   SQLUINTEGER enable;
+#  ifdef _WIN32
+  // Verifies that the Windows driver manager returns HY114 for unsupported functionality
   ASSERT_EQ(SQL_ERROR,
             SQLGetConnectAttr(conn, SQL_ATTR_ASYNC_DBC_FUNCTIONS_ENABLE, &enable, 0, 0));
   VerifyOdbcErrorState(SQL_HANDLE_DBC, conn, kErrorStateHY114);
+#  else  // Mac & Linux
+  ASSERT_EQ(SQL_SUCCESS,
+            SQLGetConnectAttr(conn, SQL_ATTR_ASYNC_DBC_FUNCTIONS_ENABLE, &enable, 0, 0));
+#  endif
 }
 #endif
 
@@ -350,14 +362,23 @@ TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrLoginTimeoutValid) {
   EXPECT_EQ(42, timeout);
 }
 
+#ifdef __linux__
+// On Linux, SQL_ATTR_PACKET_SIZE can only be set before connection
+// which is why use a different test fixture for Linux.
+TYPED_TEST(ConnectionAttributePreConnectTest, TestSQLSetConnectAttrPacketSizeValid) {
+#else  // Windows & Mac
 TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrPacketSizeValid) {
-  // The driver always returns 0. PACKET_SIZE value is unused by the driver.
-
+#endif
   // Check default value first
   SQLUINTEGER size = -1;
+#ifdef __linux__
+  ASSERT_EQ(SQL_ERROR, SQLGetConnectAttr(conn, SQL_ATTR_PACKET_SIZE, &size, 0, nullptr));
+  VerifyOdbcErrorState(SQL_HANDLE_DBC, conn, kErrorState08003);
+#else  // Windows & Mac
   ASSERT_EQ(SQL_SUCCESS,
             SQLGetConnectAttr(conn, SQL_ATTR_PACKET_SIZE, &size, 0, nullptr));
   EXPECT_EQ(0, size);
+#endif
 
   ASSERT_EQ(SQL_SUCCESS, SQLSetConnectAttr(conn, SQL_ATTR_PACKET_SIZE,
                                            reinterpret_cast<SQLPOINTER>(0), 0));
@@ -367,12 +388,18 @@ TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrPacketSizeValid) {
             SQLGetConnectAttr(conn, SQL_ATTR_PACKET_SIZE, &size, 0, nullptr));
   EXPECT_EQ(0, size);
 
-  // Attempt to set to non-zero value, driver should return warning and not error
+  // Attempt to set to non-zero value,
+#ifdef __linux__
+  EXPECT_EQ(SQL_SUCCESS, SQLSetConnectAttr(conn, SQL_ATTR_PACKET_SIZE,
+                                           reinterpret_cast<SQLPOINTER>(2), 0));
+#else  // Windows & Mac
+  // driver should return warning and not error
   EXPECT_EQ(SQL_SUCCESS_WITH_INFO, SQLSetConnectAttr(conn, SQL_ATTR_PACKET_SIZE,
                                                      reinterpret_cast<SQLPOINTER>(2), 0));
 
   // Verify warning status
   VerifyOdbcErrorState(SQL_HANDLE_DBC, conn, kErrorState01S02);
+#endif
 }
 
 }  // namespace arrow::flight::sql::odbc

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

@@ -143,6 +143,9 @@ TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDataSourceName) {
 }
 
 #ifdef SQL_DRIVER_AWARE_POOLING_SUPPORTED
+// GH-49782: TODO Disabled on Linux until SQL_DRIVER_AWARE_POOLING_SUPPORTED is
+// implemented in the driver.
+#  ifndef __linux__
 TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverAwarePoolingSupported) {
   // According to Microsoft documentation, ODBC driver does not need to implement
   // SQL_DRIVER_AWARE_POOLING_SUPPORTED and the Driver Manager will ignore the
@@ -153,7 +156,8 @@ TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverAwarePoolingSupported) {
 
   EXPECT_EQ(static_cast<SQLUINTEGER>(SQL_DRIVER_AWARE_POOLING_NOT_CAPABLE), value);
 }
-#endif
+#  endif  // __linux__
+#endif    // SQL_DRIVER_AWARE_POOLING_SUPPORTED
 
 // These information types are implemented by the Driver Manager alone.
 TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverHdbc) {
@@ -329,9 +333,11 @@ TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoOdbcVer) {
 
   std::wstring result = ConvertToWString(value);
 
-#ifdef __APPLE__
+#if defined(__APPLE__)
   EXPECT_EQ(std::wstring(L"03.52.0000"), result);
-#else
+#elif defined(__linux__)
+  EXPECT_EQ(std::wstring(L"03.52"), result);
+#else   // WINDOWS
   EXPECT_EQ(std::wstring(L"03.80.0000"), result);
 #endif  // __APPLE__
 }

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

@@ -309,15 +309,20 @@ TYPED_TEST(ErrorsTest, TestSQLGetDiagRecInputData) {
   EXPECT_EQ(SQL_NO_DATA, SQLGetDiagRec(SQL_HANDLE_DBC, conn, 1, nullptr, nullptr, nullptr,
                                        0, nullptr));
 
-  // Invalid handle
 #ifdef __APPLE__
   // MacOS ODBC driver manager requires connection handle
   EXPECT_EQ(SQL_INVALID_HANDLE,
             SQLGetDiagRec(0, conn, 1, nullptr, nullptr, nullptr, 0, nullptr));
 #else
-  EXPECT_EQ(SQL_INVALID_HANDLE,
+  // Linux & Windows driver managers have different expected return values
+#  ifdef __linux__
+  SQLRETURN expected_rc = SQL_ERROR;
+#  else  // Windows
+  SQLRETURN expected_rc = SQL_INVALID_HANDLE;
+#  endif
+  EXPECT_EQ(expected_rc,
             SQLGetDiagRec(0, nullptr, 0, nullptr, nullptr, nullptr, 0, nullptr));
-#endif  // __APPLE__
+#endif
 }
 
 TYPED_TEST(ErrorsOdbcV2Test, TestSQLErrorInputData) {
@@ -485,13 +490,13 @@ TYPED_TEST(ErrorsOdbcV2Test, TestSQLErrorEnvErrorFromDriverManager) {
   EXPECT_EQ(0, native_error);
 
   // Function sequence error state from driver manager
-#ifdef _WIN32
-  // Windows Driver Manager returns S1010
-  EXPECT_EQ(kErrorStateS1010, SqlWcharToString(sql_state));
-#else
-  // unix Driver Manager returns HY010
+#ifdef __APPLE__
+  // MacOS Driver Manager returns HY010
   EXPECT_EQ(kErrorStateHY010, SqlWcharToString(sql_state));
-#endif  // _WIN32
+#else  // Linux & Windows
+  // Linux & Windows Driver Managers returns S1010
+  EXPECT_EQ(kErrorStateS1010, SqlWcharToString(sql_state));
+#endif
 
   std::string msg = SqlWcharToString(message);
   EXPECT_FALSE(msg.empty());

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

@@ -40,8 +40,9 @@ using TestTypesOdbcV2 =
     ::testing::Types<FlightSQLOdbcV2MockTestBase, FlightSQLOdbcV2RemoteTestBase>;
 TYPED_TEST_SUITE(GetFunctionsOdbcV2Test, TestTypesOdbcV2);
 
-// MacOS driver manager iODBC does not support SQLGetFunctions for ODBC 3.x or 2.x driver
-#ifndef __APPLE__
+// Unix driver managers iODBC and Unix-ODBC do not support SQLGetFunctions
+// for ODBC 3.x or 2.x driver
+#ifdef _WIN32
 TYPED_TEST(GetFunctionsTest, TestSQLGetFunctionsAllFunctions) {
   // Verify driver manager return values for SQLGetFunctions
 
@@ -217,6 +218,6 @@ TYPED_TEST(GetFunctionsOdbcV2Test, TestSQLGetFunctionsUnsupportedSingleAPI) {
     api_exists = -1;
   }
 }
-#endif  // __APPLE__
+#endif  // _WIN32
 
 }  // namespace arrow::flight::sql::odbc

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

@@ -235,6 +235,7 @@ bool CompareConnPropertyMap(Connection::ConnPropertyMap map1,
 /// Get error message from ODBC driver using SQLGetDiagRec
 std::string GetOdbcErrorMessage(SQLSMALLINT handle_type, SQLHANDLE handle);
 
+static constexpr std::string_view kErrorState00000 = "00000";
 static constexpr std::string_view kErrorState01004 = "01004";
 static constexpr std::string_view kErrorState01S02 = "01S02";
 static constexpr std::string_view kErrorState01S07 = "01S07";

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

@@ -424,7 +424,11 @@ TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrAsyncEnableUnsupported) {
 TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrAsyncStmtEventUnsupported) {
   // Driver does not support asynchronous notification
   ValidateSetStmtAttrErrorCode(stmt, SQL_ATTR_ASYNC_STMT_EVENT, 0, SQL_ERROR,
+#  ifdef __linux__
+                               kErrorStateHYC00);
+#  else  // Windows & Mac
                                kErrorStateHY118);
+#  endif
 }
 #endif