Skip to content

GH-49783: [C++][FlightRPC][ODBC] Reuse connections across test suite #49784

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
justing-bq wants to merge 4 commits into
base: main
Choose a base branch
from
Open

GH-49783: [C++][FlightRPC][ODBC] Reuse connections across test suite #49784

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
04f782a
Reuse connections across test suite
justing-bq Apr 13, 2026
10967b5
Address feedback
justing-bq Apr 20, 2026
930a7ca
Set ODBC handles as test fixture fields
justing-bq Apr 21, 2026
1f5db13
Address more feedback
justing-bq Apr 29, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
529 changes: 265 additions & 264 deletions cpp/src/arrow/flight/sql/odbc/tests/columns_test.cc
View file
Open in desktop

Large diffs are not rendered by default.

157 changes: 82 additions & 75 deletions cpp/src/arrow/flight/sql/odbc/tests/connection_attr_test.cc
View file
Open in desktop

Large diffs are not rendered by default.

340 changes: 171 additions & 169 deletions cpp/src/arrow/flight/sql/odbc/tests/connection_info_test.cc
View file
Open in desktop

Large diffs are not rendered by default.

98 changes: 50 additions & 48 deletions cpp/src/arrow/flight/sql/odbc/tests/connection_test.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -155,7 +155,7 @@ TYPED_TEST(ConnectionTest, TestSQLGetEnvAttrOutputNTS) {
SQLINTEGER output_nts;

ASSERT_EQ(SQL_SUCCESS,
SQLGetEnvAttr(env, SQL_ATTR_OUTPUT_NTS, &output_nts, 0, nullptr));
SQLGetEnvAttr(this->env, SQL_ATTR_OUTPUT_NTS, &output_nts, 0, nullptr));

ASSERT_EQ(SQL_TRUE, output_nts);
}
Expand All @@ -165,7 +165,8 @@ TYPED_TEST(ConnectionTest, DISABLED_TestSQLGetEnvAttrGetLength) {
// Windows. Windows driver manager ignores the length pointer.
// This test case can be potentially used on macOS/Linux
SQLINTEGER length;
ASSERT_EQ(SQL_SUCCESS, SQLGetEnvAttr(env, SQL_ATTR_ODBC_VERSION, nullptr, 0, &length));
ASSERT_EQ(SQL_SUCCESS,
SQLGetEnvAttr(this->env, SQL_ATTR_ODBC_VERSION, nullptr, 0, &length));

EXPECT_EQ(sizeof(SQLINTEGER), length);
}
Expand All @@ -174,7 +175,8 @@ TYPED_TEST(ConnectionTest, DISABLED_TestSQLGetEnvAttrNullValuePointer) {
// Test is disabled because call to SQLGetEnvAttr is handled by the driver manager on
// Windows. The Windows driver manager doesn't error out when null pointer is passed.
// This test case can be potentially used on macOS/Linux
ASSERT_EQ(SQL_ERROR, SQLGetEnvAttr(env, SQL_ATTR_ODBC_VERSION, nullptr, 0, nullptr));
ASSERT_EQ(SQL_ERROR,
SQLGetEnvAttr(this->env, SQL_ATTR_ODBC_VERSION, nullptr, 0, nullptr));
}

TEST(SQLSetEnvAttr, TestSQLSetEnvAttrOutputNTSValid) {
Expand Down Expand Up @@ -227,10 +229,10 @@ TYPED_TEST(ConnectionHandleTest, TestSQLDriverConnect) {

// Connecting to ODBC server.
ASSERT_EQ(SQL_SUCCESS,
SQLDriverConnect(conn, NULL, &connect_str0[0],
SQLDriverConnect(this->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, this->conn);

// Check that out_str has same content as connect_str
std::string out_connection_string = ODBC::SqlWcharToString(out_str, out_str_len);
Expand All @@ -242,8 +244,8 @@ TYPED_TEST(ConnectionHandleTest, TestSQLDriverConnect) {
ASSERT_TRUE(CompareConnPropertyMap(out_properties, in_properties));

// Disconnect from ODBC
ASSERT_EQ(SQL_SUCCESS, SQLDisconnect(conn))
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, conn);
ASSERT_EQ(SQL_SUCCESS, SQLDisconnect(this->conn))
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, this->conn);
}

TYPED_TEST(ConnectionHandleTest, TestSQLDriverConnectDsn) {
Expand All @@ -269,17 +271,17 @@ TYPED_TEST(ConnectionHandleTest, TestSQLDriverConnectDsn) {

// Connecting to ODBC server.
ASSERT_EQ(SQL_SUCCESS,
SQLDriverConnect(conn, NULL, &connect_str0[0],
SQLDriverConnect(this->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, this->conn);

// Remove DSN
ASSERT_TRUE(UnregisterDsn(wdsn));

// Disconnect from ODBC
ASSERT_EQ(SQL_SUCCESS, SQLDisconnect(conn))
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, conn);
ASSERT_EQ(SQL_SUCCESS, SQLDisconnect(this->conn))
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, this->conn);
}

TYPED_TEST(ConnectionHandleTest, TestSQLConnect) {
Expand All @@ -301,17 +303,17 @@ TYPED_TEST(ConnectionHandleTest, TestSQLConnect) {

// Connecting to ODBC server. Empty uid and pwd should be ignored.
ASSERT_EQ(SQL_SUCCESS,
SQLConnect(conn, dsn0.data(), static_cast<SQLSMALLINT>(dsn0.size()),
SQLConnect(this->conn, dsn0.data(), static_cast<SQLSMALLINT>(dsn0.size()),
uid0.data(), static_cast<SQLSMALLINT>(uid0.size()), pwd0.data(),
static_cast<SQLSMALLINT>(pwd0.size())))
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, conn);
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, this->conn);

// Remove DSN
ASSERT_TRUE(UnregisterDsn(wdsn));

// Disconnect from ODBC
ASSERT_EQ(SQL_SUCCESS, SQLDisconnect(conn))
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, conn);
ASSERT_EQ(SQL_SUCCESS, SQLDisconnect(this->conn))
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, this->conn);
}

TEST_F(ConnectionRemoteTest, TestSQLConnectInputUidPwd) {
Expand Down Expand Up @@ -342,17 +344,17 @@ TEST_F(ConnectionRemoteTest, TestSQLConnectInputUidPwd) {

// Connecting to ODBC server.
ASSERT_EQ(SQL_SUCCESS,
SQLConnect(conn, dsn0.data(), static_cast<SQLSMALLINT>(dsn0.size()),
SQLConnect(this->conn, dsn0.data(), static_cast<SQLSMALLINT>(dsn0.size()),
uid0.data(), static_cast<SQLSMALLINT>(uid0.size()), pwd0.data(),
static_cast<SQLSMALLINT>(pwd0.size())))
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, conn);
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, this->conn);

// Remove DSN
ASSERT_TRUE(UnregisterDsn(wdsn));

// Disconnect from ODBC
ASSERT_EQ(SQL_SUCCESS, SQLDisconnect(conn))
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, conn);
ASSERT_EQ(SQL_SUCCESS, SQLDisconnect(this->conn))
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, this->conn);
}

TEST_F(ConnectionRemoteTest, TestSQLConnectInvalidUid) {
Expand Down Expand Up @@ -384,11 +386,11 @@ TEST_F(ConnectionRemoteTest, TestSQLConnectInvalidUid) {
// UID specified in DSN will take precedence,
// so connection still fails despite passing valid uid in SQLConnect call
ASSERT_EQ(SQL_ERROR,
SQLConnect(conn, dsn0.data(), static_cast<SQLSMALLINT>(dsn0.size()),
SQLConnect(this->conn, dsn0.data(), static_cast<SQLSMALLINT>(dsn0.size()),
uid0.data(), static_cast<SQLSMALLINT>(uid0.size()), pwd0.data(),
static_cast<SQLSMALLINT>(pwd0.size())));

VerifyOdbcErrorState(SQL_HANDLE_DBC, conn, kErrorState28000);
VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, kErrorState28000);

// Remove DSN
ASSERT_TRUE(UnregisterDsn(wdsn));
Expand Down Expand Up @@ -416,17 +418,17 @@ TEST_F(ConnectionRemoteTest, TestSQLConnectDSNPrecedence) {

// Connecting to ODBC server.
ASSERT_EQ(SQL_SUCCESS,
SQLConnect(conn, dsn0.data(), static_cast<SQLSMALLINT>(dsn0.size()),
SQLConnect(this->conn, dsn0.data(), static_cast<SQLSMALLINT>(dsn0.size()),
uid0.data(), static_cast<SQLSMALLINT>(uid0.size()), pwd0.data(),
static_cast<SQLSMALLINT>(pwd0.size())))
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, conn);
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, this->conn);

// Remove DSN
ASSERT_TRUE(UnregisterDsn(wdsn));

// Disconnect from ODBC
ASSERT_EQ(SQL_SUCCESS, SQLDisconnect(conn))
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, conn);
ASSERT_EQ(SQL_SUCCESS, SQLDisconnect(this->conn))
<< GetOdbcErrorMessage(SQL_HANDLE_DBC, this->conn);
}

TEST_F(ConnectionRemoteTest, TestSQLDriverConnectInvalidUid) {
Expand All @@ -442,29 +444,29 @@ TEST_F(ConnectionRemoteTest, TestSQLDriverConnectInvalidUid) {

// Connecting to ODBC server.
ASSERT_EQ(SQL_ERROR,
SQLDriverConnect(conn, NULL, &connect_str0[0],
SQLDriverConnect(this->conn, NULL, &connect_str0[0],
static_cast<SQLSMALLINT>(connect_str0.size()), out_str,
kOdbcBufferSize, &out_str_len, SQL_DRIVER_NOPROMPT));

VerifyOdbcErrorState(SQL_HANDLE_DBC, conn, kErrorState28000);
VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, kErrorState28000);

std::string out_connection_string = ODBC::SqlWcharToString(out_str, out_str_len);
ASSERT_TRUE(out_connection_string.empty());
}

TYPED_TEST(ConnectionHandleTest, TestSQLDisconnectWithoutConnection) {
// Attempt to disconnect without a connection, expect to fail
ASSERT_EQ(SQL_ERROR, SQLDisconnect(conn));
ASSERT_EQ(SQL_ERROR, SQLDisconnect(this->conn));

// Expect ODBC driver manager to return error state
VerifyOdbcErrorState(SQL_HANDLE_DBC, conn, kErrorState08003);
VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, kErrorState08003);
}

TYPED_TEST(ConnectionTest, TestSQLAllocFreeStmt) {
SQLHSTMT statement;

// Allocate a statement using alloc statement
ASSERT_EQ(SQL_SUCCESS, SQLAllocStmt(conn, &statement));
ASSERT_EQ(SQL_SUCCESS, SQLAllocStmt(this->conn, &statement));

// Close statement handle
ASSERT_EQ(SQL_SUCCESS, SQLFreeStmt(statement, SQL_CLOSE));
Expand All @@ -487,23 +489,23 @@ TYPED_TEST(ConnectionHandleTest, TestCloseConnectionWithOpenStatement) {

// Connecting to ODBC server.
ASSERT_EQ(SQL_SUCCESS,
SQLDriverConnect(conn, NULL, &connect_str0[0],
SQLDriverConnect(this->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, this->conn);

// Allocate a statement using alloc statement
ASSERT_EQ(SQL_SUCCESS, SQLAllocStmt(conn, &statement));
ASSERT_EQ(SQL_SUCCESS, SQLAllocStmt(this->conn, &statement));

// Disconnect from ODBC without closing the statement first
ASSERT_EQ(SQL_SUCCESS, SQLDisconnect(conn));
ASSERT_EQ(SQL_SUCCESS, SQLDisconnect(this->conn));
}

TYPED_TEST(ConnectionTest, TestSQLAllocFreeDesc) {
SQLHDESC descriptor;

// Allocate a descriptor using alloc handle
ASSERT_EQ(SQL_SUCCESS, SQLAllocHandle(SQL_HANDLE_DESC, conn, &descriptor));
ASSERT_EQ(SQL_SUCCESS, SQLAllocHandle(SQL_HANDLE_DESC, this->conn, &descriptor));

// Free descriptor handle
ASSERT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_DESC, descriptor));
Expand All @@ -513,37 +515,37 @@ TYPED_TEST(ConnectionTest, TestSQLSetStmtAttrDescriptor) {
SQLHDESC apd_descriptor, ard_descriptor;

// Allocate an APD descriptor using alloc handle
ASSERT_EQ(SQL_SUCCESS, SQLAllocHandle(SQL_HANDLE_DESC, conn, &apd_descriptor));
ASSERT_EQ(SQL_SUCCESS, SQLAllocHandle(SQL_HANDLE_DESC, this->conn, &apd_descriptor));

// Allocate an ARD descriptor using alloc handle
ASSERT_EQ(SQL_SUCCESS, SQLAllocHandle(SQL_HANDLE_DESC, conn, &ard_descriptor));
ASSERT_EQ(SQL_SUCCESS, SQLAllocHandle(SQL_HANDLE_DESC, this->conn, &ard_descriptor));

// Save implicitly allocated internal APD and ARD descriptor pointers
SQLPOINTER internal_apd, internal_ard = nullptr;

EXPECT_EQ(SQL_SUCCESS, SQLGetStmtAttr(stmt, SQL_ATTR_APP_PARAM_DESC, &internal_apd,
sizeof(internal_apd), 0));
EXPECT_EQ(SQL_SUCCESS, SQLGetStmtAttr(this->stmt, SQL_ATTR_APP_PARAM_DESC,
&internal_apd, sizeof(internal_apd), 0));

EXPECT_EQ(SQL_SUCCESS, SQLGetStmtAttr(stmt, SQL_ATTR_APP_ROW_DESC, &internal_ard,
EXPECT_EQ(SQL_SUCCESS, SQLGetStmtAttr(this->stmt, SQL_ATTR_APP_ROW_DESC, &internal_ard,
sizeof(internal_ard), 0));

// Set APD descriptor to explicitly allocated handle
EXPECT_EQ(SQL_SUCCESS, SQLSetStmtAttr(stmt, SQL_ATTR_APP_PARAM_DESC,
EXPECT_EQ(SQL_SUCCESS, SQLSetStmtAttr(this->stmt, SQL_ATTR_APP_PARAM_DESC,
reinterpret_cast<SQLPOINTER>(apd_descriptor), 0));

// Set ARD descriptor to explicitly allocated handle
EXPECT_EQ(SQL_SUCCESS, SQLSetStmtAttr(stmt, SQL_ATTR_APP_ROW_DESC,
EXPECT_EQ(SQL_SUCCESS, SQLSetStmtAttr(this->stmt, SQL_ATTR_APP_ROW_DESC,
reinterpret_cast<SQLPOINTER>(ard_descriptor), 0));

// Verify APD and ARD descriptors are set to explicitly allocated pointers
SQLPOINTER value = nullptr;
EXPECT_EQ(SQL_SUCCESS,
SQLGetStmtAttr(stmt, SQL_ATTR_APP_PARAM_DESC, &value, sizeof(value), 0));
EXPECT_EQ(SQL_SUCCESS, SQLGetStmtAttr(this->stmt, SQL_ATTR_APP_PARAM_DESC, &value,
sizeof(value), 0));

EXPECT_EQ(apd_descriptor, value);

EXPECT_EQ(SQL_SUCCESS,
SQLGetStmtAttr(stmt, SQL_ATTR_APP_ROW_DESC, &value, sizeof(value), 0));
SQLGetStmtAttr(this->stmt, SQL_ATTR_APP_ROW_DESC, &value, sizeof(value), 0));

EXPECT_EQ(ard_descriptor, value);

Expand All @@ -555,13 +557,13 @@ TYPED_TEST(ConnectionTest, TestSQLSetStmtAttrDescriptor) {
// Verify APD and ARD descriptors has been reverted to implicit descriptors
value = nullptr;

EXPECT_EQ(SQL_SUCCESS,
SQLGetStmtAttr(stmt, SQL_ATTR_APP_PARAM_DESC, &value, sizeof(value), 0));
EXPECT_EQ(SQL_SUCCESS, SQLGetStmtAttr(this->stmt, SQL_ATTR_APP_PARAM_DESC, &value,
sizeof(value), 0));

EXPECT_EQ(internal_apd, value);

EXPECT_EQ(SQL_SUCCESS,
SQLGetStmtAttr(stmt, SQL_ATTR_APP_ROW_DESC, &value, sizeof(value), 0));
SQLGetStmtAttr(this->stmt, SQL_ATTR_APP_ROW_DESC, &value, sizeof(value), 0));

EXPECT_EQ(internal_ard, value);
}
Expand Down
Loading
Loading