diff --git a/cpp/src/arrow/flight/sql/odbc/tests/columns_test.cc b/cpp/src/arrow/flight/sql/odbc/tests/columns_test.cc index df1c93d74aad..001ada2ed830 100644 --- a/cpp/src/arrow/flight/sql/odbc/tests/columns_test.cc +++ b/cpp/src/arrow/flight/sql/odbc/tests/columns_test.cc @@ -25,6 +25,29 @@ #include namespace arrow::flight::sql::odbc { + +template +class ColumnsTest : public T { + public: + using List = std::list; +}; + +class ColumnsMockTest : public FlightSQLODBCMockTestBase {}; +class ColumnsRemoteTest : public FlightSQLODBCRemoteTestBase {}; +using TestTypes = ::testing::Types; +TYPED_TEST_SUITE(ColumnsTest, TestTypes); + +template +class ColumnsOdbcV2Test : public T { + public: + using List = std::list; +}; + +class ColumnsOdbcV2MockTest : public FlightSQLOdbcV2MockTestBase {}; +class ColumnsOdbcV2RemoteTest : public FlightSQLOdbcV2RemoteTestBase {}; +using TestTypesOdbcV2 = ::testing::Types; +TYPED_TEST_SUITE(ColumnsOdbcV2Test, TestTypesOdbcV2); + // Helper functions void checkSQLColumns( SQLHSTMT stmt, const std::wstring& expected_table, @@ -357,9 +380,7 @@ void CheckSQLColAttributesNumeric(SQLHSTMT stmt, const std::wstring& wsql, ASSERT_EQ(expected_attr_numeric, num_val); } -TYPED_TEST(FlightSQLODBCTestBase, SQLColumnsTestInputData) { - this->Connect(); - +TYPED_TEST(ColumnsTest, SQLColumnsTestInputData) { SQLWCHAR catalog_name[] = L""; SQLWCHAR schema_name[] = L""; SQLWCHAR table_name[] = L""; @@ -388,13 +409,10 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLColumnsTestInputData) { // All values and sizes are nulls EXPECT_EQ(SQL_SUCCESS, SQLColumns(this->stmt, 0, 0, 0, 0, 0, 0, 0, 0)); ValidateFetch(this->stmt, SQL_SUCCESS); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColumnsAllColumns) { +TEST_F(ColumnsMockTest, TestSQLColumnsAllColumns) { // Check table pattern and column pattern returns all columns - this->Connect(); // Attempt to get all columns SQLWCHAR table_pattern[] = L"%"; @@ -548,17 +566,14 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLColumnsAllColumns) { 8, // expected_octet_char_length 4, // expected_ordinal_position std::wstring(L"YES")); // expected_is_nullable - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColumnsAllTypes) { +TEST_F(ColumnsMockTest, TestSQLColumnsAllTypes) { // Limitation: Mock server returns incorrect values for column size for some columns. // For character and binary type columns, the driver calculates buffer length and char // octet length from column size. // Checks filtering table with table name pattern - this->Connect(); this->CreateTableAllDataType(); // Attempt to get all columns from AllTypesTable @@ -654,15 +669,12 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLColumnsAllTypes) { // There should be no more column data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColumnsUnicode) { +TEST_F(ColumnsMockTest, TestSQLColumnsUnicode) { // Limitation: Mock server returns incorrect values for column size for some columns. // For character and binary type columns, the driver calculates buffer length and char // octet length from column size. - this->Connect(); this->CreateUnicodeTable(); // Attempt to get all columns @@ -695,14 +707,11 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLColumnsUnicode) { // There should be no more column data EXPECT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColumnsAllTypes) { +TEST_F(ColumnsRemoteTest, TestSQLColumnsAllTypes) { // GH-47159: Return NUM_PREC_RADIX based on whether COLUMN_SIZE contains number of // digits or bits - this->Connect(); SQLWCHAR table_pattern[] = L"ODBCTest"; SQLWCHAR column_pattern[] = L"%"; @@ -901,14 +910,11 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColumnsAllTypes) { // There is no more column EXPECT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColumnsAllTypesODBCVer2) { +TEST_F(ColumnsOdbcV2RemoteTest, TestSQLColumnsAllTypesODBCVer2) { // GH-47159: Return NUM_PREC_RADIX based on whether COLUMN_SIZE contains number of // digits or bits - this->Connect(SQL_OV_ODBC2); SQLWCHAR table_pattern[] = L"ODBCTest"; SQLWCHAR column_pattern[] = L"%"; @@ -1106,14 +1112,11 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColumnsAllTypesODBCVer2) { // There is no more column EXPECT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColumnscolumn_pattern) { +TEST_F(ColumnsMockTest, TestSQLColumnscolumn_pattern) { // Checks filtering table with column name pattern. // Only check table and column name - this->Connect(); SQLWCHAR table_pattern[] = L"%"; SQLWCHAR column_pattern[] = L"id"; @@ -1163,14 +1166,11 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLColumnscolumn_pattern) { // There is no more column EXPECT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColumnsTablecolumn_pattern) { +TEST_F(ColumnsMockTest, TestSQLColumnsTablecolumn_pattern) { // Checks filtering table with table and column name pattern. // Only check table and column name - this->Connect(); SQLWCHAR table_pattern[] = L"foreignTable"; SQLWCHAR column_pattern[] = L"id"; @@ -1200,13 +1200,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLColumnsTablecolumn_pattern) { // There is no more column EXPECT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColumnsInvalidtable_pattern) { - this->Connect(); - +TEST_F(ColumnsMockTest, TestSQLColumnsInvalidtable_pattern) { SQLWCHAR table_pattern[] = L"non-existent-table"; SQLWCHAR column_pattern[] = L"%"; @@ -1215,13 +1211,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLColumnsInvalidtable_pattern) { // There is no column from filter EXPECT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, SQLColAttributeTestInputData) { - this->Connect(); - +TYPED_TEST(ColumnsTest, SQLColAttributeTestInputData) { std::wstring wsql = L"SELECT 1 as col1;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -1249,13 +1241,9 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLColAttributeTestInputData) { SQLColAttribute(this->stmt, idx, SQL_COLUMN_TABLE_NAME, 0, 0, 0, 0)); EXPECT_EQ(SQL_SUCCESS, SQLColAttribute(this->stmt, idx, SQL_DESC_COUNT, 0, 0, 0, 0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, SQLColAttributeGetCharacterLen) { - this->Connect(); - +TYPED_TEST(ColumnsTest, SQLColAttributeGetCharacterLen) { std::wstring wsql = L"SELECT 1 as col1;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -1270,13 +1258,9 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLColAttributeGetCharacterLen) { ASSERT_EQ(SQL_SUCCESS, SQLColAttribute(this->stmt, 1, SQL_DESC_BASE_COLUMN_NAME, 0, 0, &character_attr_len, 0)); EXPECT_EQ(4 * ODBC::GetSqlWCharSize(), character_attr_len); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, SQLColAttributeInvalidFieldId) { - this->Connect(); - +TYPED_TEST(ColumnsTest, SQLColAttributeInvalidFieldId) { std::wstring wsql = L"SELECT 1 as col1;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -1296,13 +1280,9 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLColAttributeInvalidFieldId) { (SQLSMALLINT)character_attr.size(), &character_attr_len, 0)); // Verify invalid descriptor field identifier error state is returned VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_HY091); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, SQLColAttributeInvalidColId) { - this->Connect(); - +TYPED_TEST(ColumnsTest, SQLColAttributeInvalidColId) { std::wstring wsql = L"SELECT 1 as col1;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -1321,12 +1301,9 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLColAttributeInvalidColId) { &character_attr_len, 0)); // Verify invalid descriptor index error state is returned VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_07009); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributeAllTypes) { - this->Connect(); +TEST_F(ColumnsMockTest, TestSQLColAttributeAllTypes) { this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; @@ -1404,13 +1381,10 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributeAllTypes) { 8, // expected_octet_length SQL_PRED_NONE, // expected_searchable SQL_FALSE); // expected_unsigned_column - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributesAllTypesODBCVer2) { +TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributesAllTypesODBCVer2) { // Tests ODBC 2.0 API SQLColAttributes - this->Connect(SQL_OV_ODBC2); this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; @@ -1467,13 +1441,10 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributesAllTypesODBCVer2) { SQL_NULLABLE, // expected_column_nullability SQL_PRED_NONE, // expected_searchable SQL_FALSE); // expected_unsigned_column - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributeAllTypes) { +TEST_F(ColumnsRemoteTest, TestSQLColAttributeAllTypes) { // Test assumes there is a table $scratch.ODBCTest in remote server - this->Connect(); std::wstring wsql = L"SELECT * from $scratch.ODBCTest;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -1635,14 +1606,10 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributeAllTypes) { 16, // expected_octet_length SQL_SEARCHABLE, // expected_searchable SQL_TRUE); // expected_unsigned_column - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributeAllTypesODBCVer2) { +TEST_F(ColumnsOdbcV2RemoteTest, TestSQLColAttributeAllTypesODBCVer2) { // Test assumes there is a table $scratch.ODBCTest in remote server - this->Connect(SQL_OV_ODBC2); - std::wstring wsql = L"SELECT * from $scratch.ODBCTest;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -1803,15 +1770,11 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributeAllTypesODBCVer2) { 16, // expected_octet_length SQL_SEARCHABLE, // expected_searchable SQL_TRUE); // expected_unsigned_column - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributesAllTypesODBCVer2) { +TEST_F(ColumnsOdbcV2RemoteTest, TestSQLColAttributesAllTypesODBCVer2) { // Tests ODBC 2.0 API SQLColAttributes // Test assumes there is a table $scratch.ODBCTest in remote server - this->Connect(SQL_OV_ODBC2); - std::wstring wsql = L"SELECT * from $scratch.ODBCTest;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -1927,13 +1890,10 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributesAllTypesODBCVer2) { SQL_NULLABLE, // expected_column_nullability SQL_SEARCHABLE, // expected_searchable SQL_TRUE); // expected_unsigned_column - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLColAttributeCaseSensitive) { +TYPED_TEST(ColumnsTest, TestSQLColAttributeCaseSensitive) { // Arrow limitation: returns SQL_FALSE for case sensitive column - this->Connect(); std::wstring wsql = this->GetQueryAllDataTypes(); // Int column @@ -1941,14 +1901,11 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLColAttributeCaseSensitive) { SQLFreeStmt(this->stmt, SQL_CLOSE); // Varchar column CheckSQLColAttributeNumeric(this->stmt, wsql, 28, SQL_DESC_CASE_SENSITIVE, SQL_FALSE); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLColAttributesCaseSensitive) { +TYPED_TEST(ColumnsOdbcV2Test, TestSQLColAttributesCaseSensitive) { // Arrow limitation: returns SQL_FALSE for case sensitive column // Tests ODBC 2.0 API SQLColAttributes - this->Connect(SQL_OV_ODBC2); std::wstring wsql = this->GetQueryAllDataTypes(); // Int column @@ -1957,202 +1914,146 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLColAttributesCaseSensitive) { // Varchar column CheckSQLColAttributesNumeric(this->stmt, wsql, 28, SQL_COLUMN_CASE_SENSITIVE, SQL_FALSE); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributeUniqueValue) { +TEST_F(ColumnsMockTest, TestSQLColAttributeUniqueValue) { // Mock server limitation: returns false for auto-increment column - this->Connect(); this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; CheckSQLColAttributeNumeric(this->stmt, wsql, 1, SQL_DESC_AUTO_UNIQUE_VALUE, SQL_FALSE); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributesAutoIncrement) { +TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributesAutoIncrement) { // Tests ODBC 2.0 API SQLColAttributes // Mock server limitation: returns false for auto-increment column - this->Connect(SQL_OV_ODBC2); this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; CheckSQLColAttributeNumeric(this->stmt, wsql, 1, SQL_COLUMN_AUTO_INCREMENT, SQL_FALSE); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributeBasetable_name) { - this->Connect(); +TEST_F(ColumnsMockTest, TestSQLColAttributeBasetable_name) { this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_BASE_TABLE_NAME, std::wstring(L"AllTypesTable")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributestable_name) { +TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributestable_name) { // Tests ODBC 2.0 API SQLColAttributes - this->Connect(SQL_OV_ODBC2); this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; CheckSQLColAttributesString(this->stmt, wsql, 1, SQL_COLUMN_TABLE_NAME, std::wstring(L"AllTypesTable")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributecatalog_name) { +TEST_F(ColumnsMockTest, TestSQLColAttributecatalog_name) { // Mock server limitattion: mock doesn't return catalog for result metadata, // and the defautl catalog should be 'main' - this->Connect(); this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_CATALOG_NAME, std::wstring(L"")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributecatalog_name) { +TEST_F(ColumnsRemoteTest, TestSQLColAttributecatalog_name) { // Remote server does not have catalogs - this->Connect(); std::wstring wsql = L"SELECT * from $scratch.ODBCTest;"; CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_CATALOG_NAME, std::wstring(L"")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributesQualifierName) { +TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributesQualifierName) { // Mock server limitattion: mock doesn't return catalog for result metadata, // and the defautl catalog should be 'main' // Tests ODBC 2.0 API SQLColAttributes - this->Connect(SQL_OV_ODBC2); this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_COLUMN_QUALIFIER_NAME, std::wstring(L"")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributesQualifierName) { +TEST_F(ColumnsOdbcV2RemoteTest, TestSQLColAttributesQualifierName) { // Remote server does not have catalogs // Tests ODBC 2.0 API SQLColAttributes - this->Connect(SQL_OV_ODBC2); - std::wstring wsql = L"SELECT * from $scratch.ODBCTest;"; CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_COLUMN_QUALIFIER_NAME, std::wstring(L"")); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLColAttributeCount) { - this->Connect(); - +TYPED_TEST(ColumnsTest, TestSQLColAttributeCount) { std::wstring wsql = this->GetQueryAllDataTypes(); // Pass 0 as column number, driver should ignore it CheckSQLColAttributeNumeric(this->stmt, wsql, 0, SQL_DESC_COUNT, 32); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributeLocalTypeName) { - this->Connect(); - +TEST_F(ColumnsMockTest, TestSQLColAttributeLocalTypeName) { std::wstring wsql = this->GetQueryAllDataTypes(); // Mock server doesn't have local type name CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_LOCAL_TYPE_NAME, std::wstring(L"")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributeLocalTypeName) { - this->Connect(); - +TEST_F(ColumnsRemoteTest, TestSQLColAttributeLocalTypeName) { std::wstring wsql = this->GetQueryAllDataTypes(); CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_LOCAL_TYPE_NAME, std::wstring(L"INTEGER")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributeschema_name) { - this->Connect(); +TEST_F(ColumnsMockTest, TestSQLColAttributeschema_name) { this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; // Mock server doesn't have schemas CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_SCHEMA_NAME, std::wstring(L"")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributeschema_name) { +TEST_F(ColumnsRemoteTest, TestSQLColAttributeschema_name) { // Test assumes there is a table $scratch.ODBCTest in remote server - this->Connect(); std::wstring wsql = L"SELECT * from $scratch.ODBCTest;"; // Remote server limitation: doesn't return schema name, expected schema name is // $scratch CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_SCHEMA_NAME, std::wstring(L"")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributesOwnerName) { +TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributesOwnerName) { // Tests ODBC 2.0 API SQLColAttributes - this->Connect(SQL_OV_ODBC2); this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; // Mock server doesn't have schemas CheckSQLColAttributesString(this->stmt, wsql, 1, SQL_COLUMN_OWNER_NAME, std::wstring(L"")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributesOwnerName) { +TEST_F(ColumnsOdbcV2RemoteTest, TestSQLColAttributesOwnerName) { // Test assumes there is a table $scratch.ODBCTest in remote server // Tests ODBC 2.0 API SQLColAttributes - this->Connect(SQL_OV_ODBC2); - std::wstring wsql = L"SELECT * from $scratch.ODBCTest;"; // Remote server limitation: doesn't return schema name, expected schema name is // $scratch CheckSQLColAttributesString(this->stmt, wsql, 1, SQL_COLUMN_OWNER_NAME, std::wstring(L"")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributetable_name) { - this->Connect(); +TEST_F(ColumnsMockTest, TestSQLColAttributetable_name) { this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_TABLE_NAME, std::wstring(L"AllTypesTable")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributeTypeName) { - this->Connect(); +TEST_F(ColumnsMockTest, TestSQLColAttributeTypeName) { this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; @@ -2164,13 +2065,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributeTypeName) { std::wstring(L"BINARY")); CheckSQLColAttributeString(this->stmt, L"", 4, SQL_DESC_TYPE_NAME, std::wstring(L"DOUBLE")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributeTypeName) { - this->Connect(); - +TEST_F(ColumnsRemoteTest, TestSQLColAttributeTypeName) { std::wstring wsql = L"SELECT * from $scratch.ODBCTest;"; CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_TYPE_NAME, std::wstring(L"INTEGER")); @@ -2190,13 +2087,10 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributeTypeName) { std::wstring(L"TIME")); CheckSQLColAttributeString(this->stmt, L"", 9, SQL_DESC_TYPE_NAME, std::wstring(L"TIMESTAMP")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributesTypeName) { +TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributesTypeName) { // Tests ODBC 2.0 API SQLColAttributes - this->Connect(SQL_OV_ODBC2); this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; @@ -2209,14 +2103,10 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLColAttributesTypeName) { std::wstring(L"BINARY")); CheckSQLColAttributesString(this->stmt, L"", 4, SQL_COLUMN_TYPE_NAME, std::wstring(L"DOUBLE")); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributesTypeName) { +TEST_F(ColumnsOdbcV2RemoteTest, TestSQLColAttributesTypeName) { // Tests ODBC 2.0 API SQLColAttributes - this->Connect(SQL_OV_ODBC2); - std::wstring wsql = L"SELECT * from $scratch.ODBCTest;"; CheckSQLColAttributesString(this->stmt, wsql, 1, SQL_COLUMN_TYPE_NAME, std::wstring(L"INTEGER")); @@ -2236,44 +2126,29 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLColAttributesTypeName) { std::wstring(L"TIME")); CheckSQLColAttributesString(this->stmt, L"", 9, SQL_COLUMN_TYPE_NAME, std::wstring(L"TIMESTAMP")); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLColAttributeUnnamed) { - this->Connect(); - +TYPED_TEST(ColumnsTest, TestSQLColAttributeUnnamed) { std::wstring wsql = this->GetQueryAllDataTypes(); CheckSQLColAttributeNumeric(this->stmt, wsql, 1, SQL_DESC_UNNAMED, SQL_NAMED); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLColAttributeUpdatable) { - this->Connect(); - +TYPED_TEST(ColumnsTest, TestSQLColAttributeUpdatable) { std::wstring wsql = this->GetQueryAllDataTypes(); // Mock server and remote server do not return updatable information CheckSQLColAttributeNumeric(this->stmt, wsql, 1, SQL_DESC_UPDATABLE, SQL_ATTR_READWRITE_UNKNOWN); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLColAttributesUpdatable) { +TYPED_TEST(ColumnsOdbcV2Test, TestSQLColAttributesUpdatable) { // Tests ODBC 2.0 API SQLColAttributes - this->Connect(SQL_OV_ODBC2); - std::wstring wsql = this->GetQueryAllDataTypes(); // Mock server and remote server do not return updatable information CheckSQLColAttributesNumeric(this->stmt, wsql, 1, SQL_COLUMN_UPDATABLE, SQL_ATTR_READWRITE_UNKNOWN); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, SQLDescribeColValidateInput) { - this->Connect(); +TEST_F(ColumnsMockTest, SQLDescribeColValidateInput) { this->CreateTestTables(); SQLWCHAR sql_query[] = L"SELECT * FROM TestTable LIMIT 1;"; @@ -2312,14 +2187,11 @@ TEST_F(FlightSQLODBCMockTestBase, SQLDescribeColValidateInput) { buf_char_len, &name_length, &data_type, &column_size, &decimal_digits, &nullable)); VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_07009); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, SQLDescribeColQueryAllDataTypesMetadata) { +TEST_F(ColumnsMockTest, SQLDescribeColQueryAllDataTypesMetadata) { // Mock server has a limitation where only SQL_WVARCHAR column type values are returned // from SELECT AS queries - this->Connect(); SQLWCHAR column_name[1024]; SQLSMALLINT buf_char_len = @@ -2385,13 +2257,9 @@ TEST_F(FlightSQLODBCMockTestBase, SQLDescribeColQueryAllDataTypesMetadata) { decimal_digits = 0; nullable = 0; } - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, SQLDescribeColQueryAllDataTypesMetadata) { - this->Connect(); - +TEST_F(ColumnsRemoteTest, SQLDescribeColQueryAllDataTypesMetadata) { SQLWCHAR column_name[1024]; SQLSMALLINT buf_char_len = static_cast(sizeof(column_name) / ODBC::GetSqlWCharSize()); @@ -2463,13 +2331,10 @@ TEST_F(FlightSQLODBCRemoteTestBase, SQLDescribeColQueryAllDataTypesMetadata) { decimal_digits = 0; nullable = 0; } - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, SQLDescribeColODBCTestTableMetadata) { +TEST_F(ColumnsRemoteTest, SQLDescribeColODBCTestTableMetadata) { // Test assumes there is a table $scratch.ODBCTest in remote server - this->Connect(); SQLWCHAR column_name[1024]; SQLSMALLINT buf_char_len = @@ -2521,14 +2386,10 @@ TEST_F(FlightSQLODBCRemoteTestBase, SQLDescribeColODBCTestTableMetadata) { decimal_digits = 0; nullable = 0; } - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, SQLDescribeColODBCTestTableMetadataODBC2) { +TEST_F(ColumnsOdbcV2RemoteTest, SQLDescribeColODBCTestTableMetadataODBC2) { // Test assumes there is a table $scratch.ODBCTest in remote server - this->Connect(SQL_OV_ODBC2); - SQLWCHAR column_name[1024]; SQLSMALLINT buf_char_len = static_cast(sizeof(column_name) / ODBC::GetSqlWCharSize()); @@ -2579,12 +2440,9 @@ TEST_F(FlightSQLODBCRemoteTestBase, SQLDescribeColODBCTestTableMetadataODBC2) { decimal_digits = 0; nullable = 0; } - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, SQLDescribeColAllTypesTableMetadata) { - this->Connect(); +TEST_F(ColumnsMockTest, SQLDescribeColAllTypesTableMetadata) { this->CreateTableAllDataType(); SQLWCHAR column_name[1024]; @@ -2631,12 +2489,9 @@ TEST_F(FlightSQLODBCMockTestBase, SQLDescribeColAllTypesTableMetadata) { decimal_digits = 0; nullable = 0; } - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, SQLDescribeColUnicodeTableMetadata) { - this->Connect(); +TEST_F(ColumnsMockTest, SQLDescribeColUnicodeTableMetadata) { this->CreateUnicodeTable(); SQLWCHAR column_name[1024]; @@ -2672,13 +2527,9 @@ TEST_F(FlightSQLODBCMockTestBase, SQLDescribeColUnicodeTableMetadata) { EXPECT_EQ(column_size, expected_column_size); EXPECT_EQ(0, decimal_digits); EXPECT_EQ(SQL_NULLABLE, nullable); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, SQLColumnsGetMetadataBySQLDescribeCol) { - this->Connect(); - +TYPED_TEST(ColumnsTest, SQLColumnsGetMetadataBySQLDescribeCol) { SQLWCHAR column_name[1024]; SQLSMALLINT buf_char_len = static_cast(sizeof(column_name) / ODBC::GetSqlWCharSize()); @@ -2731,13 +2582,9 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLColumnsGetMetadataBySQLDescribeCol) { decimal_digits = 0; nullable = 0; } - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, SQLColumnsGetMetadataBySQLDescribeColODBC2) { - this->Connect(SQL_OV_ODBC2); - +TYPED_TEST(ColumnsOdbcV2Test, SQLColumnsGetMetadataBySQLDescribeColODBC2) { SQLWCHAR column_name[1024]; SQLSMALLINT buf_char_len = static_cast(sizeof(column_name) / ODBC::GetSqlWCharSize()); @@ -2798,7 +2645,5 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLColumnsGetMetadataBySQLDescribeColODBC2) { decimal_digits = 0; nullable = 0; } - - this->Disconnect(); } } // namespace arrow::flight::sql::odbc diff --git a/cpp/src/arrow/flight/sql/odbc/tests/connection_attr_test.cc b/cpp/src/arrow/flight/sql/odbc/tests/connection_attr_test.cc index db30d8f6f615..3197d86b969c 100644 --- a/cpp/src/arrow/flight/sql/odbc/tests/connection_attr_test.cc +++ b/cpp/src/arrow/flight/sql/odbc/tests/connection_attr_test.cc @@ -26,92 +26,70 @@ namespace arrow::flight::sql::odbc { -#ifdef SQL_ATTR_ASYNC_DBC_EVENT -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrAsyncDbcEventUnsupported) { - this->Connect(); +template +class ConnectionAttributeTest : public T { + public: + using List = std::list; +}; + +using TestTypes = + ::testing::Types; +TYPED_TEST_SUITE(ConnectionAttributeTest, TestTypes); +#ifdef SQL_ATTR_ASYNC_DBC_EVENT +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrAsyncDbcEventUnsupported) { ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(this->conn, SQL_ATTR_ASYNC_DBC_EVENT, 0, 0)); // Driver Manager on Windows returns error code HY118 VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HY118); - - this->Disconnect(); } #endif #ifdef SQL_ATTR_ASYNC_ENABLE -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrAyncEnableUnsupported) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrAyncEnableUnsupported) { ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(this->conn, SQL_ATTR_ASYNC_ENABLE, 0, 0)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HYC00); - - this->Disconnect(); } #endif #ifdef SQL_ATTR_ASYNC_DBC_PCALLBACK -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrAyncDbcPcCallbackUnsupported) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrAyncDbcPcCallbackUnsupported) { ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(this->conn, SQL_ATTR_ASYNC_DBC_PCALLBACK, 0, 0)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HYC00); - - this->Disconnect(); } #endif #ifdef SQL_ATTR_ASYNC_DBC_PCONTEXT -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrAyncDbcPcContextUnsupported) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrAyncDbcPcContextUnsupported) { ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(this->conn, SQL_ATTR_ASYNC_DBC_PCONTEXT, 0, 0)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HYC00); - - this->Disconnect(); } #endif -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrAutoIpdReadOnly) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrAutoIpdReadOnly) { // Verify read-only attribute cannot be set ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(this->conn, SQL_ATTR_AUTO_IPD, 0, 0)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HY092); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrConnectionDeadReadOnly) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrConnectionDeadReadOnly) { // Verify read-only attribute cannot be set ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(this->conn, SQL_ATTR_CONNECTION_DEAD, 0, 0)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HY092); - - this->Disconnect(); } #ifdef SQL_ATTR_DBC_INFO_TOKEN -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrDbcInfoTokenUnsupported) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrDbcInfoTokenUnsupported) { ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(this->conn, SQL_ATTR_DBC_INFO_TOKEN, 0, 0)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HYC00); - - this->Disconnect(); } #endif -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrEnlistInDtcUnsupported) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrEnlistInDtcUnsupported) { ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(this->conn, SQL_ATTR_ENLIST_IN_DTC, 0, 0)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HYC00); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrOdbcCursorsDMOnly) { +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrOdbcCursorsDMOnly) { this->AllocEnvConnHandles(); // Verify DM-only attribute is settable via Driver Manager @@ -121,33 +99,22 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrOdbcCursorsDMOnly) { std::string connect_str = this->GetConnectionString(); this->ConnectWithString(connect_str); - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrQuietModeReadOnly) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrQuietModeReadOnly) { // Verify read-only attribute cannot be set ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(this->conn, SQL_ATTR_QUIET_MODE, 0, 0)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HY092); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrTraceDMOnly) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrTraceDMOnly) { // Verify DM-only attribute is settable via Driver Manager ASSERT_EQ(SQL_SUCCESS, SQLSetConnectAttr(this->conn, SQL_ATTR_TRACE, reinterpret_cast(SQL_OPT_TRACE_OFF), 0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrTracefileDMOnly) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrTracefileDMOnly) { // Verify DM-only attribute is handled by Driver Manager // Use placeholder value as we want the call to fail, or else @@ -157,80 +124,52 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrTracefileDMOnly) { ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(this->conn, SQL_ATTR_TRACEFILE, &trace_file0[0], static_cast(trace_file0.size()))); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HY000); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrTranslateLabDMOnly) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrTranslateLabDMOnly) { // Verify DM-only attribute is handled by Driver Manager ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(this->conn, SQL_ATTR_TRANSLATE_LIB, 0, 0)); // Checks for invalid argument return error VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HY024); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrTranslateOptionUnsupported) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrTranslateOptionUnsupported) { ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(this->conn, SQL_ATTR_TRANSLATE_OPTION, 0, 0)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HYC00); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrTxnIsolationUnsupported) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrTxnIsolationUnsupported) { ASSERT_EQ(SQL_ERROR, SQLSetConnectAttr(this->conn, SQL_ATTR_TXN_ISOLATION, reinterpret_cast(SQL_TXN_READ_UNCOMMITTED), 0)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HYC00); - - this->Disconnect(); } #ifdef SQL_ATTR_DBC_INFO_TOKEN -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrDbcInfoTokenSetOnly) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrDbcInfoTokenSetOnly) { // Verify that set-only attribute cannot be read SQLPOINTER ptr = NULL; ASSERT_EQ(SQL_ERROR, SQLGetConnectAttr(this->conn, SQL_ATTR_DBC_INFO_TOKEN, ptr, 0, 0)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HY092); - - this->Disconnect(); } #endif -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrOdbcCursorsDMOnly) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrOdbcCursorsDMOnly) { // Verify that DM-only attribute is handled by driver manager SQLULEN cursor_attr; ASSERT_EQ(SQL_SUCCESS, SQLGetConnectAttr(this->conn, SQL_ATTR_ODBC_CURSORS, &cursor_attr, 0, 0)); EXPECT_EQ(SQL_CUR_USE_DRIVER, cursor_attr); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrTraceDMOnly) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrTraceDMOnly) { // Verify that DM-only attribute is handled by driver manager SQLUINTEGER trace; ASSERT_EQ(SQL_SUCCESS, SQLGetConnectAttr(this->conn, SQL_ATTR_TRACE, &trace, 0, 0)); EXPECT_EQ(SQL_OPT_TRACE_OFF, trace); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrTraceFileDMOnly) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrTraceFileDMOnly) { // Verify that DM-only attribute is handled by driver manager SQLWCHAR out_str[ODBC_BUFFER_SIZE]; SQLINTEGER out_str_len; @@ -242,156 +181,104 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrTraceFileDMOnly) { std::string out_connection_string = ODBC::SqlWcharToString(out_str, static_cast(out_str_len)); EXPECT_TRUE(!out_connection_string.empty()); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrTranslateLibUnsupported) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrTranslateLibUnsupported) { SQLWCHAR out_str[ODBC_BUFFER_SIZE]; SQLINTEGER out_str_len; ASSERT_EQ(SQL_ERROR, SQLGetConnectAttr(this->conn, SQL_ATTR_TRANSLATE_LIB, out_str, ODBC_BUFFER_SIZE, &out_str_len)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HYC00); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrTranslateOptionUnsupported) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrTranslateOptionUnsupported) { SQLINTEGER option; ASSERT_EQ(SQL_ERROR, SQLGetConnectAttr(this->conn, SQL_ATTR_TRANSLATE_OPTION, &option, 0, 0)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HYC00); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrTxnIsolationUnsupported) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrTxnIsolationUnsupported) { SQLINTEGER isolation; ASSERT_EQ(SQL_ERROR, SQLGetConnectAttr(this->conn, SQL_ATTR_TXN_ISOLATION, &isolation, 0, 0)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HYC00); - - this->Disconnect(); } #ifdef SQL_ATTR_ASYNC_DBC_FUNCTIONS_ENABLE -TYPED_TEST(FlightSQLODBCTestBase, +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrAsyncDbcFunctionsEnableUnsupported) { - this->Connect(); - // Verifies that the Windows driver manager returns HY114 for unsupported functionality SQLUINTEGER enable; ASSERT_EQ(SQL_ERROR, SQLGetConnectAttr(this->conn, SQL_ATTR_ASYNC_DBC_FUNCTIONS_ENABLE, &enable, 0, 0)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HY114); - - this->Disconnect(); } #endif // Tests for supported attributes #ifdef SQL_ATTR_ASYNC_DBC_EVENT -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrAsyncDbcEventDefault) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrAsyncDbcEventDefault) { SQLPOINTER ptr = NULL; ASSERT_EQ(SQL_SUCCESS, SQLGetConnectAttr(this->conn, SQL_ATTR_ASYNC_DBC_EVENT, ptr, 0, 0)); EXPECT_EQ(reinterpret_cast(NULL), ptr); - - this->Disconnect(); } #endif #ifdef SQL_ATTR_ASYNC_DBC_PCALLBACK -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrAsyncDbcPcallbackDefault) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrAsyncDbcPcallbackDefault) { SQLPOINTER ptr = NULL; ASSERT_EQ(SQL_SUCCESS, SQLGetConnectAttr(this->conn, SQL_ATTR_ASYNC_DBC_PCALLBACK, ptr, 0, 0)); EXPECT_EQ(reinterpret_cast(NULL), ptr); - - this->Disconnect(); } #endif #ifdef SQL_ATTR_ASYNC_DBC_PCONTEXT -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrAsyncDbcPcontextDefault) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrAsyncDbcPcontextDefault) { SQLPOINTER ptr = NULL; ASSERT_EQ(SQL_SUCCESS, SQLGetConnectAttr(this->conn, SQL_ATTR_ASYNC_DBC_PCONTEXT, ptr, 0, 0)); EXPECT_EQ(reinterpret_cast(NULL), ptr); - - this->Disconnect(); } #endif -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrAsyncEnableDefault) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrAsyncEnableDefault) { SQLULEN enable; ASSERT_EQ(SQL_SUCCESS, SQLGetConnectAttr(this->conn, SQL_ATTR_ASYNC_ENABLE, &enable, 0, 0)); EXPECT_EQ(SQL_ASYNC_ENABLE_OFF, enable); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrAutoIpdDefault) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrAutoIpdDefault) { SQLUINTEGER ipd; ASSERT_EQ(SQL_SUCCESS, SQLGetConnectAttr(this->conn, SQL_ATTR_AUTO_IPD, &ipd, 0, 0)); EXPECT_EQ(static_cast(SQL_FALSE), ipd); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrAutocommitDefault) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrAutocommitDefault) { SQLUINTEGER auto_commit; ASSERT_EQ(SQL_SUCCESS, SQLGetConnectAttr(this->conn, SQL_ATTR_AUTOCOMMIT, &auto_commit, 0, 0)); EXPECT_EQ(SQL_AUTOCOMMIT_ON, auto_commit); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrEnlistInDtcDefault) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrEnlistInDtcDefault) { SQLPOINTER ptr = NULL; ASSERT_EQ(SQL_SUCCESS, SQLGetConnectAttr(this->conn, SQL_ATTR_ENLIST_IN_DTC, ptr, 0, 0)); EXPECT_EQ(reinterpret_cast(NULL), ptr); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetConnectAttrQuietModeDefault) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLGetConnectAttrQuietModeDefault) { HWND ptr = NULL; ASSERT_EQ(SQL_SUCCESS, SQLGetConnectAttr(this->conn, SQL_ATTR_QUIET_MODE, ptr, 0, 0)); EXPECT_EQ(reinterpret_cast(NULL), ptr); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrAccessModeValid) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrAccessModeValid) { // The driver always returns SQL_MODE_READ_WRITE // Check default value first @@ -416,13 +303,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrAccessModeValid) { // Verify warning status VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_01S02); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrConnectionTimeoutValid) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrConnectionTimeoutValid) { // Check default value first SQLUINTEGER timeout = -1; ASSERT_EQ(SQL_SUCCESS, @@ -436,13 +319,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrConnectionTimeoutValid) { ASSERT_EQ(SQL_SUCCESS, SQLGetConnectAttr(this->conn, SQL_ATTR_CONNECTION_TIMEOUT, &timeout, 0, 0)); EXPECT_EQ(42, timeout); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrLoginTimeoutValid) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrLoginTimeoutValid) { // Check default value first SQLUINTEGER timeout = -1; ASSERT_EQ(SQL_SUCCESS, @@ -456,13 +335,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrLoginTimeoutValid) { ASSERT_EQ(SQL_SUCCESS, SQLGetConnectAttr(this->conn, SQL_ATTR_LOGIN_TIMEOUT, &timeout, 0, 0)); EXPECT_EQ(42, timeout); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrPacketSizeValid) { - this->Connect(); - +TYPED_TEST(ConnectionAttributeTest, TestSQLSetConnectAttrPacketSizeValid) { // The driver always returns 0. PACKET_SIZE value is unused by the driver. // Check default value first @@ -485,8 +360,6 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetConnectAttrPacketSizeValid) { // Verify warning status VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_01S02); - - this->Disconnect(); } } // namespace arrow::flight::sql::odbc diff --git a/cpp/src/arrow/flight/sql/odbc/tests/connection_info_test.cc b/cpp/src/arrow/flight/sql/odbc/tests/connection_info_test.cc index 7cccde1b65bd..6271f8589e28 100644 --- a/cpp/src/arrow/flight/sql/odbc/tests/connection_info_test.cc +++ b/cpp/src/arrow/flight/sql/odbc/tests/connection_info_test.cc @@ -26,6 +26,16 @@ namespace arrow::flight::sql::odbc { +template +class ConnectionInfoTest : public T { + public: + using List = std::list; +}; + +class ConnectionInfoMockTest : public FlightSQLODBCMockTestBase {}; +using TestTypes = ::testing::Types; +TYPED_TEST_SUITE(ConnectionInfoTest, TestTypes); + // Helper Functions // Validate unsigned short SQLUSMALLINT return value @@ -115,95 +125,58 @@ void ValidateNotEmptySQLWCHAR(SQLHDBC connection, SQLUSMALLINT info_type, // Driver Information -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoActiveEnvironments) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoActiveEnvironments) { Validate(this->conn, SQL_ACTIVE_ENVIRONMENTS, static_cast(0)); - - this->Disconnect(); } #ifdef SQL_ASYNC_DBC_FUNCTIONS -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoAsyncDbcFunctions) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAsyncDbcFunctions) { Validate(this->conn, SQL_ASYNC_DBC_FUNCTIONS, static_cast(SQL_ASYNC_DBC_NOT_CAPABLE)); - - this->Disconnect(); } #endif -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoAsyncMode) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAsyncMode) { Validate(this->conn, SQL_ASYNC_MODE, static_cast(SQL_AM_NONE)); - - this->Disconnect(); } #ifdef SQL_ASYNC_NOTIFICATION -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoAsyncNotification) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAsyncNotification) { Validate(this->conn, SQL_ASYNC_NOTIFICATION, static_cast(SQL_ASYNC_NOTIFICATION_NOT_CAPABLE)); - - this->Disconnect(); } #endif -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoBatchRowCount) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoBatchRowCount) { Validate(this->conn, SQL_BATCH_ROW_COUNT, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoBatchSupport) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoBatchSupport) { Validate(this->conn, SQL_BATCH_SUPPORT, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDataSourceName) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDataSourceName) { Validate(this->conn, SQL_DATA_SOURCE_NAME, (SQLWCHAR*)L""); - - this->Disconnect(); } #ifdef SQL_DRIVER_AWARE_POOLING_SUPPORTED -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDriverAwarePoolingSupported) { +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverAwarePoolingSupported) { // A driver does not need to implement SQL_DRIVER_AWARE_POOLING_SUPPORTED and the // Driver Manager will not honor to the driver's return value. - this->Connect(); Validate(this->conn, SQL_DRIVER_AWARE_POOLING_SUPPORTED, static_cast(SQL_DRIVER_AWARE_POOLING_NOT_CAPABLE)); - - this->Disconnect(); } #endif // These information types are implemented by the Driver Manager alone. -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDriverHdbc) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverHdbc) { // Value returned from driver manager is the connection address ValidateGreaterThan(this->conn, SQL_DRIVER_HDBC, static_cast(0)); - - this->Disconnect(); } // These information types are implemented by the Driver Manager alone. -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDriverHdesc) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverHdesc) { SQLHDESC descriptor; // Allocate a descriptor using alloc handle @@ -217,1087 +190,576 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDriverHdesc) { // Free descriptor handle ASSERT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_DESC, descriptor)); - - this->Disconnect(); } // These information types are implemented by the Driver Manager alone. -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDriverHenv) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverHenv) { // Value returned from driver manager is the env address ValidateGreaterThan(this->conn, SQL_DRIVER_HENV, static_cast(0)); - - this->Disconnect(); } // These information types are implemented by the Driver Manager alone. -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDriverHlib) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverHlib) { ValidateGreaterThan(this->conn, SQL_DRIVER_HLIB, static_cast(0)); - - this->Disconnect(); } // These information types are implemented by the Driver Manager alone. -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDriverHstmt) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverHstmt) { // Value returned from driver manager is the stmt address SQLHSTMT local_stmt = this->stmt; ASSERT_EQ(SQL_SUCCESS, SQLGetInfo(this->conn, SQL_DRIVER_HSTMT, &local_stmt, 0, 0)); EXPECT_GT(local_stmt, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDriverName) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverName) { Validate(this->conn, SQL_DRIVER_NAME, (SQLWCHAR*)L"Arrow Flight ODBC Driver"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDriverOdbcVer) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverOdbcVer) { Validate(this->conn, SQL_DRIVER_ODBC_VER, (SQLWCHAR*)L"03.80"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDriverVer) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverVer) { Validate(this->conn, SQL_DRIVER_VER, (SQLWCHAR*)L"00.09.0000.0"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDynamicCursorAttributes1) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDynamicCursorAttributes1) { Validate(this->conn, SQL_DYNAMIC_CURSOR_ATTRIBUTES1, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDynamicCursorAttributes2) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDynamicCursorAttributes2) { Validate(this->conn, SQL_DYNAMIC_CURSOR_ATTRIBUTES2, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoForwardOnlyCursorAttributes1) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoForwardOnlyCursorAttributes1) { Validate(this->conn, SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1, static_cast(SQL_CA1_NEXT)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoForwardOnlyCursorAttributes2) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoForwardOnlyCursorAttributes2) { Validate(this->conn, SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2, static_cast(SQL_CA2_READ_ONLY_CONCURRENCY)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoFileUsage) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoFileUsage) { Validate(this->conn, SQL_FILE_USAGE, static_cast(SQL_FILE_NOT_SUPPORTED)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoGetDataExtensions) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoGetDataExtensions) { Validate(this->conn, SQL_GETDATA_EXTENSIONS, static_cast(SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoSchemaViews) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoSchemaViews) { Validate(this->conn, SQL_INFO_SCHEMA_VIEWS, static_cast(SQL_ISV_TABLES | SQL_ISV_COLUMNS | SQL_ISV_VIEWS)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoKeysetCursorAttributes1) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoKeysetCursorAttributes1) { Validate(this->conn, SQL_KEYSET_CURSOR_ATTRIBUTES1, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoKeysetCursorAttributes2) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoKeysetCursorAttributes2) { Validate(this->conn, SQL_KEYSET_CURSOR_ATTRIBUTES2, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxAsyncConcurrentStatements) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxAsyncConcurrentStatements) { Validate(this->conn, SQL_MAX_ASYNC_CONCURRENT_STATEMENTS, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxConcurrentActivities) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxConcurrentActivities) { Validate(this->conn, SQL_MAX_CONCURRENT_ACTIVITIES, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxDriverConnections) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxDriverConnections) { Validate(this->conn, SQL_MAX_DRIVER_CONNECTIONS, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoOdbcInterfaceConformance) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoOdbcInterfaceConformance) { Validate(this->conn, SQL_ODBC_INTERFACE_CONFORMANCE, static_cast(SQL_OIC_CORE)); - - this->Disconnect(); } // case SQL_ODBC_STANDARD_CLI_CONFORMANCE: - mentioned in SQLGetInfo spec with no // description and there is no constant for this. -TYPED_TEST(FlightSQLODBCTestBase, DISABLED_TestSQLGetInfoOdbcStandardCliConformance) { +TYPED_TEST(ConnectionInfoTest, DISABLED_TestSQLGetInfoOdbcStandardCliConformance) { // Type commented out in odbc_connection.cc - this->Connect(); - // Type does not exist in sql.h // Validate(this->conn, SQL_ODBC_STANDARD_CLI_CONFORMANCE, // static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoOdbcVer) { +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoOdbcVer) { // This is implemented only in the Driver Manager. - this->Connect(); Validate(this->conn, SQL_ODBC_VER, (SQLWCHAR*)L"03.80.0000"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoParamArrayRowCounts) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoParamArrayRowCounts) { Validate(this->conn, SQL_PARAM_ARRAY_ROW_COUNTS, static_cast(SQL_PARC_NO_BATCH)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoParamArraySelects) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoParamArraySelects) { Validate(this->conn, SQL_PARAM_ARRAY_SELECTS, static_cast(SQL_PAS_NO_SELECT)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoRowUpdates) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoRowUpdates) { Validate(this->conn, SQL_ROW_UPDATES, (SQLWCHAR*)L"N"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoSearchPatternEscape) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoSearchPatternEscape) { Validate(this->conn, SQL_SEARCH_PATTERN_ESCAPE, (SQLWCHAR*)L"\\"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoServerName) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoServerName) { ValidateNotEmptySQLWCHAR(this->conn, SQL_SERVER_NAME, false); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoStaticCursorAttributes1) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoStaticCursorAttributes1) { Validate(this->conn, SQL_STATIC_CURSOR_ATTRIBUTES1, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoStaticCursorAttributes2) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoStaticCursorAttributes2) { Validate(this->conn, SQL_STATIC_CURSOR_ATTRIBUTES2, static_cast(0)); - - this->Disconnect(); } // DBMS Product Information -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDatabaseName) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDatabaseName) { Validate(this->conn, SQL_DATABASE_NAME, (SQLWCHAR*)L""); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDbmsName) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDbmsName) { ValidateNotEmptySQLWCHAR(this->conn, SQL_DBMS_NAME, false); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDbmsVer) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDbmsVer) { ValidateNotEmptySQLWCHAR(this->conn, SQL_DBMS_VER, false); - - this->Disconnect(); } // Data Source Information -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoAccessibleProcedures) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAccessibleProcedures) { Validate(this->conn, SQL_ACCESSIBLE_PROCEDURES, (SQLWCHAR*)L"N"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoAccessibleTables) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAccessibleTables) { Validate(this->conn, SQL_ACCESSIBLE_TABLES, (SQLWCHAR*)L"Y"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoBookmarkPersistence) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoBookmarkPersistence) { Validate(this->conn, SQL_BOOKMARK_PERSISTENCE, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoCatalogTerm) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCatalogTerm) { Validate(this->conn, SQL_CATALOG_TERM, (SQLWCHAR*)L""); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoCollationSeq) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCollationSeq) { Validate(this->conn, SQL_COLLATION_SEQ, (SQLWCHAR*)L""); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoConcatNullBehavior) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConcatNullBehavior) { Validate(this->conn, SQL_CONCAT_NULL_BEHAVIOR, static_cast(SQL_CB_NULL)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoCursorCommitBehavior) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCursorCommitBehavior) { Validate(this->conn, SQL_CURSOR_COMMIT_BEHAVIOR, static_cast(SQL_CB_CLOSE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoCursorRollbackBehavior) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCursorRollbackBehavior) { Validate(this->conn, SQL_CURSOR_ROLLBACK_BEHAVIOR, static_cast(SQL_CB_CLOSE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoCursorSensitivity) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCursorSensitivity) { Validate(this->conn, SQL_CURSOR_SENSITIVITY, static_cast(SQL_UNSPECIFIED)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDataSourceReadOnly) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDataSourceReadOnly) { Validate(this->conn, SQL_DATA_SOURCE_READ_ONLY, (SQLWCHAR*)L"N"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDefaultTxnIsolation) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDefaultTxnIsolation) { Validate(this->conn, SQL_DEFAULT_TXN_ISOLATION, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDescribeParameter) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDescribeParameter) { Validate(this->conn, SQL_DESCRIBE_PARAMETER, (SQLWCHAR*)L"N"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMultResultSets) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMultResultSets) { Validate(this->conn, SQL_MULT_RESULT_SETS, (SQLWCHAR*)L"N"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMultipleActiveTxn) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMultipleActiveTxn) { Validate(this->conn, SQL_MULTIPLE_ACTIVE_TXN, (SQLWCHAR*)L"N"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoNeedLongDataLen) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoNeedLongDataLen) { Validate(this->conn, SQL_NEED_LONG_DATA_LEN, (SQLWCHAR*)L"N"); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoNullCollation) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoNullCollation) { Validate(this->conn, SQL_NULL_COLLATION, static_cast(SQL_NC_START)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoProcedureTerm) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoProcedureTerm) { Validate(this->conn, SQL_PROCEDURE_TERM, (SQLWCHAR*)L""); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoSchemaTerm) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoSchemaTerm) { Validate(this->conn, SQL_SCHEMA_TERM, (SQLWCHAR*)L"schema"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoScrollOptions) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoScrollOptions) { Validate(this->conn, SQL_SCROLL_OPTIONS, static_cast(SQL_SO_FORWARD_ONLY)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoTableTerm) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoTableTerm) { Validate(this->conn, SQL_TABLE_TERM, (SQLWCHAR*)L"table"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoTxnCapable) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoTxnCapable) { Validate(this->conn, SQL_TXN_CAPABLE, static_cast(SQL_TC_NONE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoTxnIsolationOption) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoTxnIsolationOption) { Validate(this->conn, SQL_TXN_ISOLATION_OPTION, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoUserName) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoUserName) { Validate(this->conn, SQL_USER_NAME, (SQLWCHAR*)L""); - - this->Disconnect(); } // Supported SQL -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoAggregateFunctions) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAggregateFunctions) { Validate( this->conn, SQL_AGGREGATE_FUNCTIONS, static_cast(SQL_AF_ALL | SQL_AF_AVG | SQL_AF_COUNT | SQL_AF_DISTINCT | SQL_AF_MAX | SQL_AF_MIN | SQL_AF_SUM)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoAlterDomain) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAlterDomain) { Validate(this->conn, SQL_ALTER_DOMAIN, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, DISABLED_TestSQLGetInfoAlterSchema) { +TYPED_TEST(ConnectionInfoTest, DISABLED_TestSQLGetInfoAlterSchema) { // Type commented out in odbc_connection.cc - this->Connect(); - // Type does not exist in sql.h // Validate(this->conn, SQL_ALTER_SCHEMA, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoAlterTable) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAlterTable) { Validate(this->conn, SQL_ALTER_TABLE, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, DISABLED_TestSQLGetInfoAnsiSqlDatetimeLiterals) { +TYPED_TEST(ConnectionInfoTest, DISABLED_TestSQLGetInfoAnsiSqlDatetimeLiterals) { // Type commented out in odbc_connection.cc - this->Connect(); - // Type does not exist in sql.h // Validate(this->conn, SQL_ANSI_SQL_DATETIME_LITERALS, (SQLWCHAR*)L""); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoCatalogLocation) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCatalogLocation) { Validate(this->conn, SQL_CATALOG_LOCATION, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoCatalogName) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCatalogName) { Validate(this->conn, SQL_CATALOG_NAME, (SQLWCHAR*)L"N"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoCatalogNameSeparator) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCatalogNameSeparator) { Validate(this->conn, SQL_CATALOG_NAME_SEPARATOR, (SQLWCHAR*)L""); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoCatalogUsage) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoCatalogUsage) { Validate(this->conn, SQL_CATALOG_USAGE, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoColumnAlias) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoColumnAlias) { Validate(this->conn, SQL_COLUMN_ALIAS, (SQLWCHAR*)L"Y"); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoCorrelationName) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoCorrelationName) { Validate(this->conn, SQL_CORRELATION_NAME, static_cast(SQL_CN_NONE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoCreateAssertion) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCreateAssertion) { Validate(this->conn, SQL_CREATE_ASSERTION, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoCreateCharacterSet) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCreateCharacterSet) { Validate(this->conn, SQL_CREATE_CHARACTER_SET, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoCreateCollation) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCreateCollation) { Validate(this->conn, SQL_CREATE_COLLATION, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoCreateDomain) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCreateDomain) { Validate(this->conn, SQL_CREATE_DOMAIN, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoCreateSchema) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoCreateSchema) { Validate(this->conn, SQL_CREATE_SCHEMA, static_cast(1)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoCreateTable) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoCreateTable) { Validate(this->conn, SQL_CREATE_TABLE, static_cast(1)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoCreateTranslation) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCreateTranslation) { Validate(this->conn, SQL_CREATE_TRANSLATION, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDdlIndex) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDdlIndex) { Validate(this->conn, SQL_DDL_INDEX, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDropAssertion) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropAssertion) { Validate(this->conn, SQL_DROP_ASSERTION, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDropCharacterSet) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropCharacterSet) { Validate(this->conn, SQL_DROP_CHARACTER_SET, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDropCollation) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropCollation) { Validate(this->conn, SQL_DROP_COLLATION, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDropDomain) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropDomain) { Validate(this->conn, SQL_DROP_DOMAIN, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDropSchema) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropSchema) { Validate(this->conn, SQL_DROP_SCHEMA, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDropTable) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropTable) { Validate(this->conn, SQL_DROP_TABLE, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDropTranslation) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropTranslation) { Validate(this->conn, SQL_DROP_TRANSLATION, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoDropView) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropView) { Validate(this->conn, SQL_DROP_VIEW, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoExpressionsInOrderby) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoExpressionsInOrderby) { Validate(this->conn, SQL_EXPRESSIONS_IN_ORDERBY, (SQLWCHAR*)L"N"); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoGroupBy) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoGroupBy) { Validate(this->conn, SQL_GROUP_BY, static_cast(SQL_GB_GROUP_BY_CONTAINS_SELECT)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoIdentifierCase) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoIdentifierCase) { Validate(this->conn, SQL_IDENTIFIER_CASE, static_cast(SQL_IC_MIXED)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoIdentifierQuoteChar) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoIdentifierQuoteChar) { Validate(this->conn, SQL_IDENTIFIER_QUOTE_CHAR, (SQLWCHAR*)L"\""); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoIndexKeywords) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoIndexKeywords) { Validate(this->conn, SQL_INDEX_KEYWORDS, static_cast(SQL_IK_NONE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoInsertStatement) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoInsertStatement) { Validate(this->conn, SQL_INSERT_STATEMENT, static_cast(SQL_IS_INSERT_LITERALS | SQL_IS_INSERT_SEARCHED | SQL_IS_SELECT_INTO)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoIntegrity) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoIntegrity) { Validate(this->conn, SQL_INTEGRITY, (SQLWCHAR*)L"N"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoKeywords) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoKeywords) { ValidateNotEmptySQLWCHAR(this->conn, SQL_KEYWORDS, true); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoLikeEscapeClause) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoLikeEscapeClause) { Validate(this->conn, SQL_LIKE_ESCAPE_CLAUSE, (SQLWCHAR*)L"Y"); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoNonNullableColumns) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoNonNullableColumns) { Validate(this->conn, SQL_NON_NULLABLE_COLUMNS, static_cast(SQL_NNC_NULL)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoOjCapabilities) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoOjCapabilities) { Validate(this->conn, SQL_OJ_CAPABILITIES, static_cast(SQL_OJ_LEFT | SQL_OJ_RIGHT | SQL_OJ_FULL)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoOrderByColumnsInSelect) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoOrderByColumnsInSelect) { Validate(this->conn, SQL_ORDER_BY_COLUMNS_IN_SELECT, (SQLWCHAR*)L"Y"); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoOuterJoins) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoOuterJoins) { Validate(this->conn, SQL_OUTER_JOINS, (SQLWCHAR*)L"N"); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoProcedures) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoProcedures) { Validate(this->conn, SQL_PROCEDURES, (SQLWCHAR*)L"N"); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoQuotedIdentifierCase) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoQuotedIdentifierCase) { Validate(this->conn, SQL_QUOTED_IDENTIFIER_CASE, static_cast(SQL_IC_MIXED)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoSchemaUsage) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoSchemaUsage) { Validate(this->conn, SQL_SCHEMA_USAGE, static_cast(SQL_SU_DML_STATEMENTS)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoSpecialCharacters) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoSpecialCharacters) { Validate(this->conn, SQL_SPECIAL_CHARACTERS, (SQLWCHAR*)L""); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoSqlConformance) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoSqlConformance) { Validate(this->conn, SQL_SQL_CONFORMANCE, static_cast(SQL_SC_SQL92_ENTRY)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoSubqueries) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoSubqueries) { Validate(this->conn, SQL_SUBQUERIES, static_cast(SQL_SQ_CORRELATED_SUBQUERIES | SQL_SQ_COMPARISON | SQL_SQ_EXISTS | SQL_SQ_IN | SQL_SQ_QUANTIFIED)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoUnion) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoUnion) { Validate(this->conn, SQL_UNION, static_cast(SQL_U_UNION | SQL_U_UNION_ALL)); - - this->Disconnect(); } // SQL Limits -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxBinaryLiteralLen) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxBinaryLiteralLen) { Validate(this->conn, SQL_MAX_BINARY_LITERAL_LEN, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoMaxCatalogNameLen) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoMaxCatalogNameLen) { Validate(this->conn, SQL_MAX_CATALOG_NAME_LEN, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxCharLiteralLen) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxCharLiteralLen) { Validate(this->conn, SQL_MAX_CHAR_LITERAL_LEN, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoMaxColumnNameLen) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoMaxColumnNameLen) { Validate(this->conn, SQL_MAX_COLUMN_NAME_LEN, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxColumnsInGroupBy) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxColumnsInGroupBy) { Validate(this->conn, SQL_MAX_COLUMNS_IN_GROUP_BY, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxColumnsInIndex) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxColumnsInIndex) { Validate(this->conn, SQL_MAX_COLUMNS_IN_INDEX, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxColumnsInOrderBy) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxColumnsInOrderBy) { Validate(this->conn, SQL_MAX_COLUMNS_IN_ORDER_BY, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxColumnsInSelect) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxColumnsInSelect) { Validate(this->conn, SQL_MAX_COLUMNS_IN_SELECT, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxColumnsInTable) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxColumnsInTable) { Validate(this->conn, SQL_MAX_COLUMNS_IN_TABLE, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoMaxCursorNameLen) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoMaxCursorNameLen) { Validate(this->conn, SQL_MAX_CURSOR_NAME_LEN, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxIdentifierLen) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxIdentifierLen) { Validate(this->conn, SQL_MAX_IDENTIFIER_LEN, static_cast(65535)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxIndexSize) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxIndexSize) { Validate(this->conn, SQL_MAX_INDEX_SIZE, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxProcedureNameLen) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxProcedureNameLen) { Validate(this->conn, SQL_MAX_PROCEDURE_NAME_LEN, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxRowSize) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxRowSize) { Validate(this->conn, SQL_MAX_ROW_SIZE, (SQLWCHAR*)L""); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoMaxRowSizeIncludesLong) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoMaxRowSizeIncludesLong) { Validate(this->conn, SQL_MAX_ROW_SIZE_INCLUDES_LONG, (SQLWCHAR*)L"N"); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoMaxSchemaNameLen) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoMaxSchemaNameLen) { Validate(this->conn, SQL_MAX_SCHEMA_NAME_LEN, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxStatementLen) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxStatementLen) { Validate(this->conn, SQL_MAX_STATEMENT_LEN, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoMaxTableNameLen) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoMaxTableNameLen) { Validate(this->conn, SQL_MAX_TABLE_NAME_LEN, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoMaxTablesInSelect) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxTablesInSelect) { Validate(this->conn, SQL_MAX_TABLES_IN_SELECT, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoMaxUserNameLen) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoMaxUserNameLen) { Validate(this->conn, SQL_MAX_USER_NAME_LEN, static_cast(0)); - - this->Disconnect(); } // Scalar Function Information -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoConvertFunctions) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertFunctions) { Validate(this->conn, SQL_CONVERT_FUNCTIONS, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoNumericFunctions) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoNumericFunctions) { Validate(this->conn, SQL_NUMERIC_FUNCTIONS, static_cast(4058942)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoStringFunctions) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoStringFunctions) { Validate(this->conn, SQL_STRING_FUNCTIONS, static_cast(SQL_FN_STR_LTRIM | SQL_FN_STR_LENGTH | SQL_FN_STR_REPLACE | SQL_FN_STR_RTRIM)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoSystemFunctions) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoSystemFunctions) { Validate(this->conn, SQL_SYSTEM_FUNCTIONS, static_cast(SQL_FN_SYS_IFNULL | SQL_FN_SYS_USERNAME)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoTimedateAddIntervals) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoTimedateAddIntervals) { Validate(this->conn, SQL_TIMEDATE_ADD_INTERVALS, static_cast(SQL_FN_TSI_FRAC_SECOND | SQL_FN_TSI_SECOND | SQL_FN_TSI_MINUTE | SQL_FN_TSI_HOUR | SQL_FN_TSI_DAY | SQL_FN_TSI_WEEK | SQL_FN_TSI_MONTH | SQL_FN_TSI_QUARTER | SQL_FN_TSI_YEAR)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoTimedateDiffIntervals) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoTimedateDiffIntervals) { Validate(this->conn, SQL_TIMEDATE_DIFF_INTERVALS, static_cast(SQL_FN_TSI_FRAC_SECOND | SQL_FN_TSI_SECOND | SQL_FN_TSI_MINUTE | SQL_FN_TSI_HOUR | SQL_FN_TSI_DAY | SQL_FN_TSI_WEEK | SQL_FN_TSI_MONTH | SQL_FN_TSI_QUARTER | SQL_FN_TSI_YEAR)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoTimedateFunctions) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoTimedateFunctions) { Validate(this->conn, SQL_TIMEDATE_FUNCTIONS, static_cast( SQL_FN_TD_CURRENT_DATE | SQL_FN_TD_CURRENT_TIME | @@ -1307,178 +769,92 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoTimedateFunctions) { SQL_FN_TD_MINUTE | SQL_FN_TD_MONTH | SQL_FN_TD_MONTHNAME | SQL_FN_TD_NOW | SQL_FN_TD_QUARTER | SQL_FN_TD_SECOND | SQL_FN_TD_TIMESTAMPADD | SQL_FN_TD_TIMESTAMPDIFF | SQL_FN_TD_WEEK | SQL_FN_TD_YEAR)); - - this->Disconnect(); } // Conversion Information -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoConvertBigint) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertBigint) { Validate(this->conn, SQL_CONVERT_BIGINT, static_cast(8)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoConvertBinary) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertBinary) { Validate(this->conn, SQL_CONVERT_BINARY, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoConvertBit) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertBit) { Validate(this->conn, SQL_CONVERT_BIT, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoConvertChar) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertChar) { Validate(this->conn, SQL_CONVERT_CHAR, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoConvertDate) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertDate) { Validate(this->conn, SQL_CONVERT_DATE, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoConvertDecimal) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertDecimal) { Validate(this->conn, SQL_CONVERT_DECIMAL, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoConvertDouble) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertDouble) { Validate(this->conn, SQL_CONVERT_DOUBLE, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoConvertFloat) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertFloat) { Validate(this->conn, SQL_CONVERT_FLOAT, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoConvertInteger) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertInteger) { Validate(this->conn, SQL_CONVERT_INTEGER, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoConvertIntervalDayTime) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertIntervalDayTime) { Validate(this->conn, SQL_CONVERT_INTERVAL_DAY_TIME, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoConvertIntervalYearMonth) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertIntervalYearMonth) { Validate(this->conn, SQL_CONVERT_INTERVAL_YEAR_MONTH, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoConvertLongvarbinary) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertLongvarbinary) { Validate(this->conn, SQL_CONVERT_LONGVARBINARY, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoConvertLongvarchar) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertLongvarchar) { Validate(this->conn, SQL_CONVERT_LONGVARCHAR, static_cast(0)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetInfoConvertNumeric) { - this->Connect(); - +TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertNumeric) { Validate(this->conn, SQL_CONVERT_NUMERIC, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoConvertReal) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertReal) { Validate(this->conn, SQL_CONVERT_REAL, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoConvertSmallint) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertSmallint) { Validate(this->conn, SQL_CONVERT_SMALLINT, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoConvertTime) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertTime) { Validate(this->conn, SQL_CONVERT_TIME, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoConvertTimestamp) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertTimestamp) { Validate(this->conn, SQL_CONVERT_TIMESTAMP, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoConvertTinyint) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertTinyint) { Validate(this->conn, SQL_CONVERT_TINYINT, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoConvertVarbinary) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertVarbinary) { Validate(this->conn, SQL_CONVERT_VARBINARY, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetInfoConvertVarchar) { - this->Connect(); - +TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertVarchar) { Validate(this->conn, SQL_CONVERT_VARCHAR, static_cast(0)); - - this->Disconnect(); } } // namespace arrow::flight::sql::odbc diff --git a/cpp/src/arrow/flight/sql/odbc/tests/connection_test.cc b/cpp/src/arrow/flight/sql/odbc/tests/connection_test.cc index 3119facfa704..73cbae57ca21 100644 --- a/cpp/src/arrow/flight/sql/odbc/tests/connection_test.cc +++ b/cpp/src/arrow/flight/sql/odbc/tests/connection_test.cc @@ -25,6 +25,17 @@ #include namespace arrow::flight::sql::odbc { + +template +class ConnectionTest : public T { + public: + using List = std::list; +}; + +class ConnectionRemoteTest : public FlightSQLODBCRemoteTestBase {}; +using TestTypes = ::testing::Types; +TYPED_TEST_SUITE(ConnectionTest, TestTypes); + TEST(SQLAllocHandle, TestSQLAllocHandleEnv) { SQLHENV env; @@ -93,16 +104,20 @@ TEST(SQLFreeHandle, TestSQLFreeHandleConnect) { ASSERT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_DBC, conn)); } -TYPED_TEST(FlightSQLODBCTestBase, TestFreeNullHandles) { +TEST(SQLFreeHandle, TestFreeNullHandles) { + SQLHENV env = NULL; + SQLHDBC conn = NULL; + SQLHSTMT stmt = NULL; + // Verifies attempt to free invalid handle does not cause segfault // Attempt to free null statement handle - ASSERT_EQ(SQL_INVALID_HANDLE, SQLFreeHandle(SQL_HANDLE_STMT, this->stmt)); + ASSERT_EQ(SQL_INVALID_HANDLE, SQLFreeHandle(SQL_HANDLE_STMT, stmt)); // Attempt to free null connection handle - ASSERT_EQ(SQL_INVALID_HANDLE, SQLFreeHandle(SQL_HANDLE_DBC, this->conn)); + ASSERT_EQ(SQL_INVALID_HANDLE, SQLFreeHandle(SQL_HANDLE_DBC, conn)); // Attempt to free null environment handle - ASSERT_EQ(SQL_INVALID_HANDLE, SQLFreeHandle(SQL_HANDLE_ENV, this->env)); + ASSERT_EQ(SQL_INVALID_HANDLE, SQLFreeHandle(SQL_HANDLE_ENV, env)); } TEST(SQLFreeConnect, TestSQLFreeConnect) { @@ -154,42 +169,30 @@ TEST(SQLSetEnvAttr, TestSQLSetEnvAttrODBCVersionInvalid) { SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, reinterpret_cast(1), 0)); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetEnvAttrOutputNTS) { - this->Connect(); - +TYPED_TEST(ConnectionTest, TestSQLGetEnvAttrOutputNTS) { SQLINTEGER output_nts; ASSERT_EQ(SQL_SUCCESS, SQLGetEnvAttr(this->env, SQL_ATTR_OUTPUT_NTS, &output_nts, 0, 0)); ASSERT_EQ(SQL_TRUE, output_nts); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, DISABLED_TestSQLGetEnvAttrGetLength) { +TYPED_TEST(ConnectionTest, DISABLED_TestSQLGetEnvAttrGetLength) { // Test is disabled because call to SQLGetEnvAttr is handled by the driver manager on // Windows. This test case can be potentially used on macOS/Linux - this->Connect(); - SQLINTEGER length; ASSERT_EQ(SQL_SUCCESS, SQLGetEnvAttr(this->env, SQL_ATTR_ODBC_VERSION, nullptr, 0, &length)); EXPECT_EQ(sizeof(SQLINTEGER), length); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, DISABLED_TestSQLGetEnvAttrNullValuePointer) { +TYPED_TEST(ConnectionTest, DISABLED_TestSQLGetEnvAttrNullValuePointer) { // Test is disabled because call to SQLGetEnvAttr is handled by the driver manager on // Windows. This test case can be potentially used on macOS/Linux - this->Connect(); - ASSERT_EQ(SQL_ERROR, SQLGetEnvAttr(this->env, SQL_ATTR_ODBC_VERSION, nullptr, 0, nullptr)); - - this->Disconnect(); } TEST(SQLSetEnvAttr, TestSQLSetEnvAttrOutputNTSValid) { @@ -224,7 +227,7 @@ TEST(SQLSetEnvAttr, TestSQLSetEnvAttrNullValuePointer) { ASSERT_EQ(SQL_ERROR, SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, nullptr, 0)); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLDriverConnect) { +TYPED_TEST(ConnectionTest, TestSQLDriverConnect) { SQLHENV env; SQLHDBC conn; @@ -283,7 +286,7 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLDriverConnect) { } #if defined _WIN32 || defined _WIN64 -TYPED_TEST(FlightSQLODBCTestBase, TestSQLDriverConnectDsn) { +TYPED_TEST(ConnectionTest, TestSQLDriverConnectDsn) { SQLHENV env; SQLHDBC conn; @@ -346,7 +349,7 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLDriverConnectDsn) { ASSERT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_ENV, env)); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLConnect) { +TYPED_TEST(ConnectionTest, TestSQLConnect) { SQLHENV env; SQLHDBC conn; @@ -405,7 +408,7 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLConnect) { ASSERT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_ENV, env)); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLConnectInputUidPwd) { +TEST_F(ConnectionRemoteTest, TestSQLConnectInputUidPwd) { SQLHENV env; SQLHDBC conn; @@ -473,7 +476,7 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLConnectInputUidPwd) { ASSERT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_ENV, env)); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLConnectInvalidUid) { +TEST_F(ConnectionRemoteTest, TestSQLConnectInvalidUid) { SQLHENV env; SQLHDBC conn; @@ -530,7 +533,7 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLConnectInvalidUid) { ASSERT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_ENV, env)); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLConnectDSNPrecedence) { +TEST_F(ConnectionRemoteTest, TestSQLConnectDSNPrecedence) { SQLHENV env; SQLHDBC conn; @@ -594,7 +597,7 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLConnectDSNPrecedence) { #endif -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLDriverConnectInvalidUid) { +TEST_F(ConnectionRemoteTest, TestSQLDriverConnectInvalidUid) { SQLHENV env; SQLHDBC conn; @@ -661,14 +664,11 @@ TEST(SQLDisconnect, TestSQLDisconnectWithoutConnection) { ASSERT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_ENV, env)); } -TYPED_TEST(FlightSQLODBCTestBase, TestConnect) { +TYPED_TEST(ConnectionTest, TestConnect) { // Verifies connect and disconnect works on its own - this->Connect(); - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLAllocFreeStmt) { - this->Connect(); +TYPED_TEST(ConnectionTest, TestSQLAllocFreeStmt) { SQLHSTMT statement; // Allocate a statement using alloc statement @@ -682,11 +682,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLAllocFreeStmt) { // Free statement handle ASSERT_EQ(SQL_SUCCESS, SQLFreeStmt(statement, SQL_DROP)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestCloseConnectionWithOpenStatement) { +TYPED_TEST(ConnectionTest, TestCloseConnectionWithOpenStatement) { SQLHENV env; SQLHDBC conn; SQLHSTMT statement; @@ -728,8 +726,7 @@ TYPED_TEST(FlightSQLODBCTestBase, TestCloseConnectionWithOpenStatement) { ASSERT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_ENV, env)); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLAllocFreeDesc) { - this->Connect(); +TYPED_TEST(ConnectionTest, TestSQLAllocFreeDesc) { SQLHDESC descriptor; // Allocate a descriptor using alloc handle @@ -737,13 +734,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLAllocFreeDesc) { // Free descriptor handle ASSERT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_DESC, descriptor)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrDescriptor) { - this->Connect(); - +TYPED_TEST(ConnectionTest, TestSQLSetStmtAttrDescriptor) { SQLHDESC apd_descriptor, ard_descriptor; // Allocate an APD descriptor using alloc handle @@ -798,8 +791,6 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrDescriptor) { SQLGetStmtAttr(this->stmt, SQL_ATTR_APP_ROW_DESC, &value, sizeof(value), 0)); EXPECT_EQ(internal_ard, value); - - this->Disconnect(); } } // namespace arrow::flight::sql::odbc diff --git a/cpp/src/arrow/flight/sql/odbc/tests/errors_test.cc b/cpp/src/arrow/flight/sql/odbc/tests/errors_test.cc index f8777b58a059..2c0d9dd5992e 100644 --- a/cpp/src/arrow/flight/sql/odbc/tests/errors_test.cc +++ b/cpp/src/arrow/flight/sql/odbc/tests/errors_test.cc @@ -26,7 +26,27 @@ namespace arrow::flight::sql::odbc { -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetDiagFieldWForConnectFailure) { +template +class ErrorsTest : public T { + public: + using List = std::list; +}; + +using TestTypes = + ::testing::Types; +TYPED_TEST_SUITE(ErrorsTest, TestTypes); + +template +class ErrorsOdbcV2Test : public T { + public: + using List = std::list; +}; + +using TestTypesOdbcV2 = + ::testing::Types; +TYPED_TEST_SUITE(ErrorsOdbcV2Test, TestTypesOdbcV2); + +TYPED_TEST(ErrorsTest, TestSQLGetDiagFieldWForConnectFailure) { // ODBC Environment SQLHENV env; SQLHDBC conn; @@ -117,7 +137,7 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetDiagFieldWForConnectFailure) { EXPECT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_ENV, env)); } -TYPED_TEST(FlightSQLODBCTestBase, DISABLED_TestSQLGetDiagFieldWForConnectFailureNTS) { +TYPED_TEST(ErrorsTest, DISABLED_TestSQLGetDiagFieldWForConnectFailureNTS) { // Test is disabled because driver manager on Windows does not pass through SQL_NTS // This test case can be potentially used on macOS/Linux SQLHENV env; @@ -170,9 +190,7 @@ TYPED_TEST(FlightSQLODBCTestBase, DISABLED_TestSQLGetDiagFieldWForConnectFailure ASSERT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_ENV, env)); } -TYPED_TEST(FlightSQLODBCTestBase, - TestSQLGetDiagFieldWForDescriptorFailureFromDriverManager) { - this->Connect(); +TYPED_TEST(ErrorsTest, TestSQLGetDiagFieldWForDescriptorFailureFromDriverManager) { SQLHDESC descriptor; // Allocate a descriptor using alloc handle @@ -236,13 +254,9 @@ TYPED_TEST(FlightSQLODBCTestBase, // Free descriptor handle EXPECT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_DESC, descriptor)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, - TestSQLGetDiagRecForDescriptorFailureFromDriverManager) { - this->Connect(); +TYPED_TEST(ErrorsTest, TestSQLGetDiagRecForDescriptorFailureFromDriverManager) { SQLHDESC descriptor; // Allocate a descriptor using alloc handle @@ -271,11 +285,9 @@ TYPED_TEST(FlightSQLODBCTestBase, // Free descriptor handle EXPECT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_DESC, descriptor)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetDiagRecForConnectFailure) { +TYPED_TEST(ErrorsTest, TestSQLGetDiagRecForConnectFailure) { // ODBC Environment SQLHENV env; SQLHDBC conn; @@ -327,9 +339,8 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetDiagRecForConnectFailure) { ASSERT_EQ(SQL_SUCCESS, SQLFreeHandle(SQL_HANDLE_ENV, env)); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetDiagRecInputData) { +TYPED_TEST(ErrorsTest, TestSQLGetDiagRecInputData) { // SQLGetDiagRec does not post diagnostic records for itself. - this->Connect(); SQLWCHAR sql_state[6]; SQLINTEGER native_error; @@ -346,14 +357,11 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetDiagRecInputData) { // Invalid handle EXPECT_EQ(SQL_INVALID_HANDLE, SQLGetDiagRec(0, 0, 0, 0, 0, 0, 0, 0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorInputData) { +TYPED_TEST(ErrorsTest, TestSQLErrorInputData) { // Test ODBC 2.0 API SQLError. Driver manager maps SQLError to SQLGetDiagRec. // SQLError does not post diagnostic records for itself. - this->Connect(); // Pass valid handles with null inputs EXPECT_EQ(SQL_NO_DATA, SQLError(this->env, 0, 0, 0, 0, 0, 0, 0)); @@ -364,16 +372,13 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorInputData) { // Invalid handle EXPECT_EQ(SQL_INVALID_HANDLE, SQLError(0, 0, 0, 0, 0, 0, 0, 0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorEnvErrorFromDriverManager) { +TYPED_TEST(ErrorsTest, TestSQLErrorEnvErrorFromDriverManager) { // Test ODBC 2.0 API SQLError. // Known Windows Driver Manager (DM) behavior: // When application passes buffer length greater than SQL_MAX_MESSAGE_LENGTH (512), // DM passes 512 as buffer length to SQLError. - this->Connect(); // Attempt to set environment attribute after connection handle allocation ASSERT_EQ(SQL_ERROR, SQLSetEnvAttr(this->env, SQL_ATTR_ODBC_VERSION, @@ -394,16 +399,13 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorEnvErrorFromDriverManager) { EXPECT_EQ(std::wstring(L"HY010"), std::wstring(sql_state)); EXPECT_TRUE(!std::wstring(message).empty()); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorConnError) { +TYPED_TEST(ErrorsTest, TestSQLErrorConnError) { // Test ODBC 2.0 API SQLError. // Known Windows Driver Manager (DM) behavior: // When application passes buffer length greater than SQL_MAX_MESSAGE_LENGTH (512), // DM passes 512 as buffer length to SQLError. - this->Connect(); // Attempt to set unsupported attribute SQLRETURN ret = SQLGetConnectAttr(this->conn, SQL_ATTR_TXN_ISOLATION, 0, 0, 0); @@ -425,16 +427,13 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorConnError) { EXPECT_EQ(std::wstring(L"HYC00"), std::wstring(sql_state)); EXPECT_TRUE(!std::wstring(message).empty()); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorStmtError) { +TYPED_TEST(ErrorsTest, TestSQLErrorStmtError) { // Test ODBC 2.0 API SQLError. // Known Windows Driver Manager (DM) behavior: // When application passes buffer length greater than SQL_MAX_MESSAGE_LENGTH (512), // DM passes 512 as buffer length to SQLError. - this->Connect(); std::wstring wsql = L"1"; std::vector sql0(wsql.begin(), wsql.end()); @@ -456,13 +455,10 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorStmtError) { EXPECT_EQ(std::wstring(L"HY000"), std::wstring(sql_state)); EXPECT_TRUE(!std::wstring(message).empty()); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorStmtWarning) { +TYPED_TEST(ErrorsTest, TestSQLErrorStmtWarning) { // Test ODBC 2.0 API SQLError. - this->Connect(); std::wstring wsql = L"SELECT 'VERY LONG STRING here' AS string_col;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -497,12 +493,11 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorStmtWarning) { EXPECT_TRUE(!std::wstring(message).empty()); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorEnvErrorODBCVer2FromDriverManager) { +TYPED_TEST(ErrorsOdbcV2Test, TestSQLErrorEnvErrorODBCVer2FromDriverManager) { // Test ODBC 2.0 API SQLError with ODBC ver 2. // Known Windows Driver Manager (DM) behavior: // When application passes buffer length greater than SQL_MAX_MESSAGE_LENGTH (512), // DM passes 512 as buffer length to SQLError. - this->Connect(SQL_OV_ODBC2); // Attempt to set environment attribute after connection handle allocation ASSERT_EQ(SQL_ERROR, SQLSetEnvAttr(this->env, SQL_ATTR_ODBC_VERSION, @@ -523,16 +518,13 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorEnvErrorODBCVer2FromDriverManager) EXPECT_EQ(std::wstring(L"S1010"), std::wstring(sql_state)); EXPECT_TRUE(!std::wstring(message).empty()); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorConnErrorODBCVer2) { +TYPED_TEST(ErrorsOdbcV2Test, TestSQLErrorConnErrorODBCVer2) { // Test ODBC 2.0 API SQLError with ODBC ver 2. // Known Windows Driver Manager (DM) behavior: // When application passes buffer length greater than SQL_MAX_MESSAGE_LENGTH (512), // DM passes 512 as buffer length to SQLError. - this->Connect(SQL_OV_ODBC2); // Attempt to set unsupported attribute ASSERT_EQ(SQL_ERROR, SQLGetConnectAttr(this->conn, SQL_ATTR_TXN_ISOLATION, 0, 0, 0)); @@ -552,16 +544,13 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorConnErrorODBCVer2) { EXPECT_EQ(std::wstring(L"S1C00"), std::wstring(sql_state)); EXPECT_TRUE(!std::wstring(message).empty()); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorStmtErrorODBCVer2) { +TYPED_TEST(ErrorsOdbcV2Test, TestSQLErrorStmtErrorODBCVer2) { // Test ODBC 2.0 API SQLError with ODBC ver 2. // Known Windows Driver Manager (DM) behavior: // When application passes buffer length greater than SQL_MAX_MESSAGE_LENGTH (512), // DM passes 512 as buffer length to SQLError. - this->Connect(SQL_OV_ODBC2); std::wstring wsql = L"1"; std::vector sql0(wsql.begin(), wsql.end()); @@ -584,13 +573,10 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorStmtErrorODBCVer2) { EXPECT_EQ(std::wstring(L"S1000"), std::wstring(sql_state)); EXPECT_TRUE(!std::wstring(message).empty()); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLErrorStmtWarningODBCVer2) { +TYPED_TEST(ErrorsOdbcV2Test, TestSQLErrorStmtWarningODBCVer2) { // Test ODBC 2.0 API SQLError. - this->Connect(SQL_OV_ODBC2); std::wstring wsql = L"SELECT 'VERY LONG STRING here' AS string_col;"; std::vector sql0(wsql.begin(), wsql.end()); diff --git a/cpp/src/arrow/flight/sql/odbc/tests/get_functions_test.cc b/cpp/src/arrow/flight/sql/odbc/tests/get_functions_test.cc index f13431962197..8bfbef8dad54 100644 --- a/cpp/src/arrow/flight/sql/odbc/tests/get_functions_test.cc +++ b/cpp/src/arrow/flight/sql/odbc/tests/get_functions_test.cc @@ -26,9 +26,28 @@ namespace arrow::flight::sql::odbc { -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetFunctionsAllFunctions) { +template +class GetFunctionsTest : public T { + public: + using List = std::list; +}; + +using TestTypes = + ::testing::Types; +TYPED_TEST_SUITE(GetFunctionsTest, TestTypes); + +template +class GetFunctionsOdbcV2Test : public T { + public: + using List = std::list; +}; + +using TestTypesOdbcV2 = + ::testing::Types; +TYPED_TEST_SUITE(GetFunctionsOdbcV2Test, TestTypesOdbcV2); + +TYPED_TEST(GetFunctionsTest, TestSQLGetFunctionsAllFunctions) { // Verify driver manager return values for SQLGetFunctions - this->Connect(); SQLUSMALLINT api_exists[SQL_API_ODBC3_ALL_FUNCTIONS_SIZE]; const std::vector supported_functions = { @@ -72,13 +91,10 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetFunctionsAllFunctions) { for (int api : unsupported_functions) { EXPECT_EQ(SQL_FALSE, SQL_FUNC_EXISTS(api_exists, api)); } - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetFunctionsAllFunctionsODBCVer2) { +TYPED_TEST(GetFunctionsOdbcV2Test, TestSQLGetFunctionsAllFunctionsODBCVer2) { // Verify driver manager return values for SQLGetFunctions - this->Connect(SQL_OV_ODBC2); // ODBC 2.0 SQLGetFunctions returns 100 elements according to spec SQLUSMALLINT api_exists[100]; @@ -111,13 +127,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetFunctionsAllFunctionsODBCVer2) { for (int api : unsupported_functions) { EXPECT_EQ(SQL_FALSE, api_exists[api]); } - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetFunctionsSupportedSingleAPI) { - this->Connect(); - +TYPED_TEST(GetFunctionsTest, TestSQLGetFunctionsSupportedSingleAPI) { const std::vector supported_functions = { SQL_API_SQLALLOCHANDLE, SQL_API_SQLBINDCOL, SQL_API_SQLGETDIAGFIELD, SQL_API_SQLCANCEL, SQL_API_SQLCLOSECURSOR, SQL_API_SQLGETDIAGREC, @@ -147,13 +159,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetFunctionsSupportedSingleAPI) { api_exists = -1; } - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetFunctionsUnsupportedSingleAPI) { - this->Connect(); - +TYPED_TEST(GetFunctionsTest, TestSQLGetFunctionsUnsupportedSingleAPI) { const std::vector unsupported_functions = { SQL_API_SQLPUTDATA, SQL_API_SQLGETDESCFIELD, SQL_API_SQLGETDESCREC, SQL_API_SQLCOPYDESC, SQL_API_SQLPARAMDATA, SQL_API_SQLENDTRAN, @@ -171,13 +179,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetFunctionsUnsupportedSingleAPI) { api_exists = -1; } - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetFunctionsSupportedSingleAPIODBCVer2) { - this->Connect(SQL_OV_ODBC2); - +TYPED_TEST(GetFunctionsOdbcV2Test, TestSQLGetFunctionsSupportedSingleAPIODBCVer2) { const std::vector supported_functions = { SQL_API_SQLCONNECT, SQL_API_SQLGETINFO, SQL_API_SQLDESCRIBECOL, SQL_API_SQLGETTYPEINFO, SQL_API_SQLDISCONNECT, SQL_API_SQLNUMRESULTCOLS, @@ -199,13 +203,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetFunctionsSupportedSingleAPIODBCVer2) api_exists = -1; } - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetFunctionsUnsupportedSingleAPIODBCVer2) { - this->Connect(SQL_OV_ODBC2); - +TYPED_TEST(GetFunctionsOdbcV2Test, TestSQLGetFunctionsUnsupportedSingleAPIODBCVer2) { const std::vector unsupported_functions = { SQL_API_SQLPUTDATA, SQL_API_SQLPARAMDATA, SQL_API_SQLSETCURSORNAME, SQL_API_SQLGETCURSORNAME, SQL_API_SQLSTATISTICS, SQL_API_SQLSPECIALCOLUMNS, @@ -221,8 +221,6 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetFunctionsUnsupportedSingleAPIODBCVer api_exists = -1; } - - this->Disconnect(); } } // namespace arrow::flight::sql::odbc diff --git a/cpp/src/arrow/flight/sql/odbc/tests/odbc_test_suite.cc b/cpp/src/arrow/flight/sql/odbc/tests/odbc_test_suite.cc index bcd7e944d7d1..e0b212e054b0 100644 --- a/cpp/src/arrow/flight/sql/odbc/tests/odbc_test_suite.cc +++ b/cpp/src/arrow/flight/sql/odbc/tests/odbc_test_suite.cc @@ -154,6 +154,26 @@ void FlightSQLODBCRemoteTestBase::SetUp() { if (arrow::internal::GetEnvVar(TEST_CONNECT_STR).ValueOr("").empty()) { GTEST_SKIP() << "Skipping FlightSQLODBCRemoteTestBase test: TEST_CONNECT_STR not set"; } + + this->Connect(); + connected_ = true; +} + +void FlightSQLODBCRemoteTestBase::TearDown() { + if (connected_) { + this->Disconnect(); + connected_ = false; + } +} + +void FlightSQLOdbcV2RemoteTestBase::SetUp() { + if (arrow::internal::GetEnvVar(TEST_CONNECT_STR).ValueOr("").empty()) { + GTEST_SKIP() + << "Skipping FlightSQLOdbcV2RemoteTestBase test: TEST_CONNECT_STR not set"; + } + + this->Connect(SQL_OV_ODBC2); + connected_ = true; } std::string FindTokenInCallHeaders(const CallHeaders& incoming_headers) { @@ -309,7 +329,7 @@ void FlightSQLODBCMockTestBase::CreateUnicodeTable() { ASSERT_OK(server_->ExecuteSql(unicode_sql)); } -void FlightSQLODBCMockTestBase::SetUp() { +void FlightSQLODBCMockTestBase::Initialize() { ASSERT_OK_AND_ASSIGN(auto location, Location::ForGrpcTcp("0.0.0.0", 0)); arrow::flight::FlightServerOptions options(location); options.auth_handler = std::make_unique(); @@ -324,7 +344,25 @@ void FlightSQLODBCMockTestBase::SetUp() { ASSERT_OK_AND_ASSIGN(auto client, arrow::flight::FlightClient::Connect(location)); } -void FlightSQLODBCMockTestBase::TearDown() { ASSERT_OK(server_->Shutdown()); } +void FlightSQLODBCMockTestBase::SetUp() { + this->Initialize(); + this->Connect(); + connected_ = true; +} + +void FlightSQLODBCMockTestBase::TearDown() { + if (connected_) { + this->Disconnect(); + connected_ = false; + } + ASSERT_OK(server_->Shutdown()); +} + +void FlightSQLOdbcV2MockTestBase::SetUp() { + this->Initialize(); + this->Connect(SQL_OV_ODBC2); + connected_ = true; +} bool CompareConnPropertyMap(Connection::ConnPropertyMap map1, Connection::ConnPropertyMap map2) { diff --git a/cpp/src/arrow/flight/sql/odbc/tests/odbc_test_suite.h b/cpp/src/arrow/flight/sql/odbc/tests/odbc_test_suite.h index 22624fc928af..0c2887e64587 100644 --- a/cpp/src/arrow/flight/sql/odbc/tests/odbc_test_suite.h +++ b/cpp/src/arrow/flight/sql/odbc/tests/odbc_test_suite.h @@ -72,6 +72,15 @@ class FlightSQLODBCRemoteTestBase : public ::testing::Test { /** ODBC Statement. */ SQLHSTMT stmt = 0; + protected: + void SetUp() override; + + void TearDown() override; + + bool connected_ = false; +}; + +class FlightSQLOdbcV2RemoteTestBase : public FlightSQLODBCRemoteTestBase { protected: void SetUp() override; }; @@ -134,6 +143,8 @@ class FlightSQLODBCMockTestBase : public FlightSQLODBCRemoteTestBase { int port; protected: + void Initialize(); + void SetUp() override; void TearDown() override; @@ -142,16 +153,11 @@ class FlightSQLODBCMockTestBase : public FlightSQLODBCRemoteTestBase { std::shared_ptr server_; }; -template -class FlightSQLODBCTestBase : public T { - public: - using List = std::list; +class FlightSQLOdbcV2MockTestBase : public FlightSQLODBCMockTestBase { + protected: + void SetUp() override; }; -using TestTypes = - ::testing::Types; -TYPED_TEST_SUITE(FlightSQLODBCTestBase, TestTypes); - /** ODBC read buffer size. */ enum { ODBC_BUFFER_SIZE = 1024 }; diff --git a/cpp/src/arrow/flight/sql/odbc/tests/statement_attr_test.cc b/cpp/src/arrow/flight/sql/odbc/tests/statement_attr_test.cc index 08cd3210be1f..6f251423cb0a 100644 --- a/cpp/src/arrow/flight/sql/odbc/tests/statement_attr_test.cc +++ b/cpp/src/arrow/flight/sql/odbc/tests/statement_attr_test.cc @@ -29,6 +29,16 @@ namespace arrow::flight::sql::odbc { +template +class StatementAttributeTest : public T { + public: + using List = std::list; +}; + +using TestTypes = + ::testing::Types; +TYPED_TEST_SUITE(StatementAttributeTest, TestTypes); + // Helper Functions // Validate SQLULEN return value @@ -128,277 +138,155 @@ void ValidateSetStmtAttrErrorCode(SQLHSTMT statement, SQLINTEGER attribute, // Test Cases -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrAppParamDesc) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrAppParamDesc) { ValidateGetStmtAttrGreaterThan(this->stmt, SQL_ATTR_APP_PARAM_DESC, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrAppRowDesc) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrAppRowDesc) { ValidateGetStmtAttrGreaterThan(this->stmt, SQL_ATTR_APP_ROW_DESC, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrAsyncEnable) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrAsyncEnable) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_ASYNC_ENABLE, static_cast(SQL_ASYNC_ENABLE_OFF)); - - this->Disconnect(); } #ifdef SQL_ATTR_ASYNC_STMT_EVENT -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrAsyncStmtEventUnsupported) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrAsyncStmtEventUnsupported) { // Optional feature not implemented ValidateGetStmtAttrErrorCode(this->stmt, SQL_ATTR_ASYNC_STMT_EVENT, error_state_HYC00); - - this->Disconnect(); } #endif #ifdef SQL_ATTR_ASYNC_STMT_PCALLBACK -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrAsyncStmtPCCallbackUnsupported) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrAsyncStmtPCCallbackUnsupported) { // Optional feature not implemented ValidateGetStmtAttrErrorCode(this->stmt, SQL_ATTR_ASYNC_STMT_PCALLBACK, error_state_HYC00); - - this->Disconnect(); } #endif #ifdef SQL_ATTR_ASYNC_STMT_PCONTEXT -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrAsyncStmtPCContextUnsupported) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrAsyncStmtPCContextUnsupported) { // Optional feature not implemented ValidateGetStmtAttrErrorCode(this->stmt, SQL_ATTR_ASYNC_STMT_PCONTEXT, error_state_HYC00); - - this->Disconnect(); } #endif -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrConcurrency) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrConcurrency) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_CONCURRENCY, static_cast(SQL_CONCUR_READ_ONLY)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrCursorScrollable) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrCursorScrollable) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_CURSOR_SCROLLABLE, static_cast(SQL_NONSCROLLABLE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrCursorSensitivity) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrCursorSensitivity) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_CURSOR_SENSITIVITY, static_cast(SQL_UNSPECIFIED)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrCursorType) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrCursorType) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_CURSOR_TYPE, static_cast(SQL_CURSOR_FORWARD_ONLY)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrEnableAutoIPD) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrEnableAutoIPD) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_ENABLE_AUTO_IPD, static_cast(SQL_FALSE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrFetchBookmarkPointer) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrFetchBookmarkPointer) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_FETCH_BOOKMARK_PTR, static_cast(NULL)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrIMPParamDesc) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrIMPParamDesc) { ValidateGetStmtAttrGreaterThan(this->stmt, SQL_ATTR_IMP_PARAM_DESC, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrIMPRowDesc) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrIMPRowDesc) { ValidateGetStmtAttrGreaterThan(this->stmt, SQL_ATTR_IMP_ROW_DESC, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrKeysetSize) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrKeysetSize) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_KEYSET_SIZE, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrMaxLength) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrMaxLength) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_MAX_LENGTH, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrMaxRows) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrMaxRows) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_MAX_ROWS, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrMetadataID) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrMetadataID) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_METADATA_ID, static_cast(SQL_FALSE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrNoscan) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrNoscan) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_NOSCAN, static_cast(SQL_NOSCAN_OFF)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrParamBindOffsetPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrParamBindOffsetPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAM_BIND_OFFSET_PTR, static_cast(nullptr)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrParamBindType) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrParamBindType) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAM_BIND_TYPE, static_cast(SQL_PARAM_BIND_BY_COLUMN)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrParamOperationPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrParamOperationPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAM_OPERATION_PTR, static_cast(nullptr)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrParamStatusPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrParamStatusPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAM_STATUS_PTR, static_cast(nullptr)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrParamsProcessedPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrParamsProcessedPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAMS_PROCESSED_PTR, static_cast(nullptr)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrParamsetSize) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrParamsetSize) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAMSET_SIZE, static_cast(1)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrQueryTimeout) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrQueryTimeout) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_QUERY_TIMEOUT, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrRetrieveData) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRetrieveData) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_RETRIEVE_DATA, static_cast(SQL_RD_ON)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrRowArraySize) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowArraySize) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_ARRAY_SIZE, static_cast(1)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrRowBindOffsetPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowBindOffsetPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_BIND_OFFSET_PTR, static_cast(nullptr)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrRowBindType) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowBindType) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_BIND_TYPE, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrRowNumber) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowNumber) { std::wstring wsql = L"SELECT 1;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -408,68 +296,41 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrRowNumber) { ASSERT_EQ(SQL_SUCCESS, SQLFetch(this->stmt)); ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_NUMBER, static_cast(1)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrRowOperationPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowOperationPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_OPERATION_PTR, static_cast(nullptr)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrRowStatusPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowStatusPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_STATUS_PTR, static_cast(nullptr)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrRowsFetchedPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowsFetchedPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROWS_FETCHED_PTR, static_cast(nullptr)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrSimulateCursor) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrSimulateCursor) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_SIMULATE_CURSOR, static_cast(SQL_SC_UNIQUE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrUseBookmarks) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrUseBookmarks) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_USE_BOOKMARKS, static_cast(SQL_UB_OFF)); - - this->Disconnect(); } // This is a pre ODBC 3 attribute -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetStmtAttrRowsetSize) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowsetSize) { ValidateGetStmtAttr(this->stmt, SQL_ROWSET_SIZE, static_cast(1)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrAppParamDesc) { +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrAppParamDesc) { SQLULEN app_param_desc = 0; SQLINTEGER string_length_ptr; - this->Connect(); ASSERT_EQ(SQL_SUCCESS, SQLGetStmtAttr(this->stmt, SQL_ATTR_APP_PARAM_DESC, &app_param_desc, 0, &string_length_ptr)); @@ -478,14 +339,11 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrAppParamDesc) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_APP_PARAM_DESC, static_cast(app_param_desc)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrAppRowDesc) { +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrAppRowDesc) { SQLULEN app_row_desc = 0; SQLINTEGER string_length_ptr; - this->Connect(); ASSERT_EQ(SQL_SUCCESS, SQLGetStmtAttr(this->stmt, SQL_ATTR_APP_ROW_DESC, &app_row_desc, 0, &string_length_ptr)); @@ -494,175 +352,103 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrAppRowDesc) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_APP_ROW_DESC, static_cast(app_row_desc)); - - this->Disconnect(); } #ifdef SQL_ATTR_ASYNC_ENABLE -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrAsyncEnableUnsupported) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrAsyncEnableUnsupported) { // Optional feature not implemented ValidateSetStmtAttrErrorCode(this->stmt, SQL_ATTR_ASYNC_ENABLE, SQL_ASYNC_ENABLE_OFF, error_state_HYC00); - - this->Disconnect(); } #endif #ifdef SQL_ATTR_ASYNC_STMT_EVENT -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrAsyncStmtEventUnsupported) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrAsyncStmtEventUnsupported) { // Driver does not support asynchronous notification ValidateSetStmtAttrErrorCode(this->stmt, SQL_ATTR_ASYNC_STMT_EVENT, 0, error_state_HY118); - - this->Disconnect(); } #endif #ifdef SQL_ATTR_ASYNC_STMT_PCALLBACK -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrAsyncStmtPCCallbackUnsupported) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrAsyncStmtPCCallbackUnsupported) { ValidateSetStmtAttrErrorCode(this->stmt, SQL_ATTR_ASYNC_STMT_PCALLBACK, 0, error_state_HYC00); - - this->Disconnect(); } #endif #ifdef SQL_ATTR_ASYNC_STMT_PCONTEXT -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrAsyncStmtPCContextUnsupported) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrAsyncStmtPCContextUnsupported) { // Optional feature not implemented ValidateSetStmtAttrErrorCode(this->stmt, SQL_ATTR_ASYNC_STMT_PCONTEXT, 0, error_state_HYC00); - - this->Disconnect(); } #endif -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrConcurrency) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrConcurrency) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_CONCURRENCY, static_cast(SQL_CONCUR_READ_ONLY)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrCursorScrollable) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrCursorScrollable) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_CURSOR_SCROLLABLE, static_cast(SQL_NONSCROLLABLE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrCursorSensitivity) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrCursorSensitivity) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_CURSOR_SENSITIVITY, static_cast(SQL_UNSPECIFIED)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrCursorType) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrCursorType) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_CURSOR_TYPE, static_cast(SQL_CURSOR_FORWARD_ONLY)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrEnableAutoIPD) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrEnableAutoIPD) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_ENABLE_AUTO_IPD, static_cast(SQL_FALSE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrFetchBookmarkPointer) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrFetchBookmarkPointer) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_FETCH_BOOKMARK_PTR, static_cast(NULL)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrIMPParamDesc) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrIMPParamDesc) { // Invalid use of an automatically allocated descriptor handle ValidateSetStmtAttrErrorCode(this->stmt, SQL_ATTR_IMP_PARAM_DESC, static_cast(0), error_state_HY017); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrIMPRowDesc) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrIMPRowDesc) { // Invalid use of an automatically allocated descriptor handle ValidateSetStmtAttrErrorCode(this->stmt, SQL_ATTR_IMP_ROW_DESC, static_cast(0), error_state_HY017); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrKeysetSizeUnsupported) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrKeysetSizeUnsupported) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_KEYSET_SIZE, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrMaxLength) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrMaxLength) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_MAX_LENGTH, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrMaxRows) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrMaxRows) { // Cannot set read-only attribute ValidateSetStmtAttrErrorCode(this->stmt, SQL_ATTR_MAX_ROWS, static_cast(0), error_state_HY092); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrMetadataID) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrMetadataID) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_METADATA_ID, static_cast(SQL_FALSE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrNoscan) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrNoscan) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_NOSCAN, static_cast(SQL_NOSCAN_OFF)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrParamBindOffsetPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrParamBindOffsetPtr) { SQLULEN offset = 1000; ValidateSetStmtAttr(this->stmt, SQL_ATTR_PARAM_BIND_OFFSET_PTR, @@ -670,22 +456,14 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrParamBindOffsetPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAM_BIND_OFFSET_PTR, static_cast(&offset)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrParamBindType) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrParamBindType) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_PARAM_BIND_TYPE, static_cast(SQL_PARAM_BIND_BY_COLUMN)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrParamOperationPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrParamOperationPtr) { constexpr SQLULEN param_set_size = 4; SQLUSMALLINT param_operations[param_set_size] = {SQL_PARAM_PROCEED, SQL_PARAM_IGNORE, SQL_PARAM_PROCEED, SQL_PARAM_IGNORE}; @@ -695,13 +473,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrParamOperationPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAM_OPERATION_PTR, static_cast(param_operations)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrParamStatusPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrParamStatusPtr) { // Driver does not support parameters, so just check array can be saved/retrieved constexpr SQLULEN param_status_size = 4; SQLUSMALLINT param_status[param_status_size] = {SQL_PARAM_PROCEED, SQL_PARAM_IGNORE, @@ -712,13 +486,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrParamStatusPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAM_STATUS_PTR, static_cast(param_status)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrParamsProcessedPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrParamsProcessedPtr) { SQLULEN processed_count = 0; ValidateSetStmtAttr(this->stmt, SQL_ATTR_PARAMS_PROCESSED_PTR, @@ -726,46 +496,26 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrParamsProcessedPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAMS_PROCESSED_PTR, static_cast(&processed_count)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrParamsetSize) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrParamsetSize) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_PARAMSET_SIZE, static_cast(1)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrQueryTimeout) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrQueryTimeout) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_QUERY_TIMEOUT, static_cast(1)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrRetrieveData) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRetrieveData) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_RETRIEVE_DATA, static_cast(SQL_RD_ON)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrRowArraySize) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowArraySize) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_ROW_ARRAY_SIZE, static_cast(1)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrRowBindOffsetPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowBindOffsetPtr) { SQLULEN offset = 1000; ValidateSetStmtAttr(this->stmt, SQL_ATTR_ROW_BIND_OFFSET_PTR, @@ -773,31 +523,19 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrRowBindOffsetPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_BIND_OFFSET_PTR, static_cast(&offset)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrRowBindType) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowBindType) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_ROW_BIND_TYPE, static_cast(0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrRowNumber) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowNumber) { // Cannot set read-only attribute ValidateSetStmtAttrErrorCode(this->stmt, SQL_ATTR_ROW_NUMBER, static_cast(0), error_state_HY092); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrRowOperationPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowOperationPtr) { constexpr SQLULEN param_set_size = 4; SQLUSMALLINT row_operations[param_set_size] = {SQL_ROW_PROCEED, SQL_ROW_IGNORE, SQL_ROW_PROCEED, SQL_ROW_IGNORE}; @@ -807,13 +545,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrRowOperationPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_OPERATION_PTR, static_cast(row_operations)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrRowStatusPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowStatusPtr) { constexpr SQLULEN row_status_size = 4; SQLUSMALLINT values[4] = {0, 0, 0, 0}; @@ -822,13 +556,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrRowStatusPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_STATUS_PTR, static_cast(values)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrRowsFetchedPtr) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowsFetchedPtr) { SQLULEN rows_fetched = 1; ValidateSetStmtAttr(this->stmt, SQL_ATTR_ROWS_FETCHED_PTR, @@ -836,35 +566,21 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrRowsFetchedPtr) { ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROWS_FETCHED_PTR, static_cast(&rows_fetched)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrSimulateCursor) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrSimulateCursor) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_SIMULATE_CURSOR, static_cast(SQL_SC_UNIQUE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrUseBookmarks) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrUseBookmarks) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_USE_BOOKMARKS, static_cast(SQL_UB_OFF)); - - this->Disconnect(); } // This is a pre ODBC 3 attribute -TYPED_TEST(FlightSQLODBCTestBase, TestSQLSetStmtAttrRowsetSize) { - this->Connect(); - +TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowsetSize) { ValidateSetStmtAttr(this->stmt, SQL_ROWSET_SIZE, static_cast(1)); - - this->Disconnect(); } } // namespace arrow::flight::sql::odbc diff --git a/cpp/src/arrow/flight/sql/odbc/tests/statement_test.cc b/cpp/src/arrow/flight/sql/odbc/tests/statement_test.cc index 59456fe1e9b0..057b7f5f0562 100644 --- a/cpp/src/arrow/flight/sql/odbc/tests/statement_test.cc +++ b/cpp/src/arrow/flight/sql/odbc/tests/statement_test.cc @@ -28,9 +28,19 @@ #include namespace arrow::flight::sql::odbc { -TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectSimpleQuery) { - this->Connect(); +template +class StatementTest : public T { + public: + using List = std::list; +}; + +class StatementMockTest : public FlightSQLODBCMockTestBase {}; +class StatementRemoteTest : public FlightSQLODBCRemoteTestBase {}; +using TestTypes = ::testing::Types; +TYPED_TEST_SUITE(StatementTest, TestTypes); + +TYPED_TEST(StatementTest, TestSQLExecDirectSimpleQuery) { std::wstring wsql = L"SELECT 1;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -50,13 +60,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectSimpleQuery) { ASSERT_EQ(SQL_ERROR, SQLGetData(this->stmt, 1, SQL_C_LONG, &val, 0, 0)); // Invalid cursor state VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_24000); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectInvalidQuery) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLExecDirectInvalidQuery) { std::wstring wsql = L"SELECT;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -64,13 +70,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectInvalidQuery) { SQLExecDirect(this->stmt, &sql0[0], static_cast(sql0.size()))); // ODBC provides generic error code HY000 to all statement errors VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_HY000); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecuteSimpleQuery) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLExecuteSimpleQuery) { std::wstring wsql = L"SELECT 1;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -93,13 +95,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecuteSimpleQuery) { ASSERT_EQ(SQL_ERROR, SQLGetData(this->stmt, 1, SQL_C_LONG, &val, 0, 0)); // Invalid cursor state VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_24000); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLPrepareInvalidQuery) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLPrepareInvalidQuery) { std::wstring wsql = L"SELECT;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -111,13 +109,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLPrepareInvalidQuery) { ASSERT_EQ(SQL_ERROR, SQLExecute(this->stmt)); // Verify function sequence error state is returned VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_HY010); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectDataQuery) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLExecDirectDataQuery) { std::wstring wsql = this->GetQueryAllDataTypes(); std::vector sql0(wsql.begin(), wsql.end()); @@ -351,14 +345,11 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectDataQuery) { EXPECT_EQ(59, timestamp_var.minute); EXPECT_EQ(59, timestamp_var.second); EXPECT_EQ(0, timestamp_var.fraction); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLExecDirectTimeQuery) { +TEST_F(StatementRemoteTest, TestSQLExecDirectTimeQuery) { // Mock server test is skipped due to limitation on the mock server. // Time type from mock server does not include the fraction - this->Connect(); std::wstring wsql = LR"( @@ -389,14 +380,11 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLExecDirectTimeQuery) { EXPECT_EQ(23, time_var.hour); EXPECT_EQ(59, time_var.minute); EXPECT_EQ(59, time_var.second); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLExecDirectVarbinaryQuery) { +TEST_F(StatementMockTest, TestSQLExecDirectVarbinaryQuery) { // Have binary test on mock test base as remote test servers tend to have different // formats for binary data - this->Connect(); std::wstring wsql = L"SELECT X'ABCDEF' AS c_varbinary;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -415,15 +403,12 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLExecDirectVarbinaryQuery) { EXPECT_EQ('\xAB', varbinary_val[0]); EXPECT_EQ('\xCD', varbinary_val[1]); EXPECT_EQ('\xEF', varbinary_val[2]); - - this->Disconnect(); } // Tests with SQL_C_DEFAULT as the target type -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLExecDirectDataQueryDefaultType) { +TEST_F(StatementRemoteTest, TestSQLExecDirectDataQueryDefaultType) { // Test with default types. Only testing target types supported by server. - this->Connect(); std::wstring wsql = this->GetQueryAllDataTypes(); std::vector sql0(wsql.begin(), wsql.end()); @@ -603,14 +588,11 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLExecDirectDataQueryDefaultType) { EXPECT_EQ(59, timestamp_var.minute); EXPECT_EQ(59, timestamp_var.second); EXPECT_EQ(0, timestamp_var.fraction); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLExecDirectTimeQueryDefaultType) { +TEST_F(StatementRemoteTest, TestSQLExecDirectTimeQueryDefaultType) { // Mock server test is skipped due to limitation on the mock server. // Time type from mock server does not include the fraction - this->Connect(); std::wstring wsql = LR"( @@ -641,15 +623,12 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLExecDirectTimeQueryDefaultType) { EXPECT_EQ(23, time_var.hour); EXPECT_EQ(59, time_var.minute); EXPECT_EQ(59, time_var.second); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLExecDirectVarbinaryQueryDefaultType) { +TEST_F(StatementRemoteTest, TestSQLExecDirectVarbinaryQueryDefaultType) { // Limitation on mock test server prevents SQL_C_DEFAULT from working properly. // Mock server has type `DENSE_UNION` for varbinary. // Note that not all remote servers support "from_hex" function - this->Connect(); std::wstring wsql = L"SELECT from_hex('ABCDEF') AS c_varbinary;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -668,13 +647,9 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLExecDirectVarbinaryQueryDefaultType) EXPECT_EQ('\xAB', varbinary_val[0]); EXPECT_EQ('\xCD', varbinary_val[1]); EXPECT_EQ('\xEF', varbinary_val[2]); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectGuidQueryUnsupported) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLExecDirectGuidQueryUnsupported) { // Query GUID as string as SQLite does not support GUID std::wstring wsql = L"SELECT 'C77313CF-4E08-47CE-B6DF-94DD2FCF3541' AS guid;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -690,13 +665,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectGuidQueryUnsupported) { ASSERT_EQ(SQL_ERROR, SQLGetData(this->stmt, 1, SQL_C_GUID, &guid_var, buf_len, &ind)); // GUID is not supported by ODBC VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_HY000); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectRowFetching) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLExecDirectRowFetching) { std::wstring wsql = LR"( SELECT 1 AS small_table @@ -745,13 +716,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectRowFetching) { // Invalid cursor state VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_24000); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLFetchScrollRowFetching) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLFetchScrollRowFetching) { SQLLEN rows_fetched; SQLSetStmtAttr(this->stmt, SQL_ATTR_ROWS_FETCHED_PTR, &rows_fetched, 0); @@ -807,13 +774,10 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLFetchScrollRowFetching) { ASSERT_EQ(SQL_ERROR, SQLGetData(this->stmt, 1, SQL_C_LONG, &val, 0, &ind)); // Invalid cursor state VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_24000); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLFetchScrollUnsupportedOrientation) { +TYPED_TEST(StatementTest, TestSQLFetchScrollUnsupportedOrientation) { // SQL_FETCH_PRIOR is the only supported fetch orientation. - this->Connect(); std::wstring wsql = L"SELECT 1;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -846,13 +810,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLFetchScrollUnsupportedOrientation) { // DM returns state HY106 for SQL_FETCH_BOOKMARK VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_HY106); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectVarcharTruncation) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLExecDirectVarcharTruncation) { std::wstring wsql = L"SELECT 'VERY LONG STRING here' AS string_col;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -901,13 +861,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectVarcharTruncation) { SQLCHAR char_val4[len]; // Verify SQL_NO_DATA is returned ASSERT_EQ(SQL_NO_DATA, SQLGetData(this->stmt, 1, SQL_C_CHAR, &char_val4, 0, &ind)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectWVarcharTruncation) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLExecDirectWVarcharTruncation) { std::wstring wsql = L"SELECT 'VERY LONG Unicode STRING 句子 here' AS wstring_col;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -957,14 +913,11 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectWVarcharTruncation) { SQLWCHAR wchar_val4[len]; // Verify SQL_NO_DATA is returned ASSERT_EQ(SQL_NO_DATA, SQLGetData(this->stmt, 1, SQL_C_WCHAR, &wchar_val4, 0, &ind)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLExecDirectVarbinaryTruncation) { +TEST_F(StatementMockTest, TestSQLExecDirectVarbinaryTruncation) { // Have binary test on mock test base as remote test servers tend to have different // formats for binary data - this->Connect(); std::wstring wsql = L"SELECT X'ABCDEFAB' AS c_varbinary;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -1004,19 +957,15 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLExecDirectVarbinaryTruncation) { // Verify SQL_NO_DATA is returned ASSERT_EQ(SQL_NO_DATA, SQLGetData(this->stmt, 1, SQL_C_BINARY, &varbinary_val3[0], buf_len, &ind)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, DISABLED_TestSQLExecDirectFloatTruncation) { +TYPED_TEST(StatementTest, DISABLED_TestSQLExecDirectFloatTruncation) { // Test is disabled until float truncation is supported. // GH-46985: return warning message instead of error on float truncation case - this->Connect(); - std::wstring wsql; - if constexpr (std::is_same_v) { + if constexpr (std::is_same_v) { wsql = std::wstring(L"SELECT CAST(1.234 AS REAL) AS float_val"); - } else if constexpr (std::is_same_v) { + } else if constexpr (std::is_same_v) { wsql = std::wstring(L"SELECT CAST(1.234 AS FLOAT) AS float_val"); } std::vector sql0(wsql.begin(), wsql.end()); @@ -1034,14 +983,11 @@ TYPED_TEST(FlightSQLODBCTestBase, DISABLED_TestSQLExecDirectFloatTruncation) { VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_01S07); EXPECT_EQ(1, ssmall_int_val); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLExecDirectNullQuery) { +TEST_F(StatementRemoteTest, TestSQLExecDirectNullQuery) { // Limitation on mock test server prevents null from working properly, so use remote // server instead. Mock server has type `DENSE_UNION` for null column data. - this->Connect(); std::wstring wsql = L"SELECT null as null_col;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -1058,15 +1004,12 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLExecDirectNullQuery) { // Verify SQL_NULL_DATA is returned for indicator EXPECT_EQ(SQL_NULL_DATA, ind); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLExecDirectTruncationQueryNullIndicator) { +TEST_F(StatementMockTest, TestSQLExecDirectTruncationQueryNullIndicator) { // Driver should not error out when indicator is null if the cell is non-null // Have binary test on mock test base as remote test servers tend to have different // formats for binary data - this->Connect(); std::wstring wsql = LR"( @@ -1113,14 +1056,11 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLExecDirectTruncationQueryNullIndicator) SQLGetData(this->stmt, 4, SQL_C_BINARY, &varbinary_val[0], buf_len, 0)); // Verify binary truncation is reported VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_01004); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLExecDirectNullQueryNullIndicator) { +TEST_F(StatementRemoteTest, TestSQLExecDirectNullQueryNullIndicator) { // Limitation on mock test server prevents null from working properly, so use remote // server instead. Mock server has type `DENSE_UNION` for null column data. - this->Connect(); std::wstring wsql = L"SELECT null as null_col;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -1135,13 +1075,10 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLExecDirectNullQueryNullIndicator) { ASSERT_EQ(SQL_ERROR, SQLGetData(this->stmt, 1, SQL_C_LONG, &val, 0, 0)); // Verify invalid null indicator is reported, as it is required VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_22002); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectIgnoreInvalidBufLen) { +TYPED_TEST(StatementTest, TestSQLExecDirectIgnoreInvalidBufLen) { // Verify the driver ignores invalid buffer length for fixed data types - this->Connect(); std::wstring wsql = this->GetQueryAllDataTypes(); std::vector sql0(wsql.begin(), wsql.end()); @@ -1336,13 +1273,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLExecDirectIgnoreInvalidBufLen) { EXPECT_EQ(59, timestamp_var.minute); EXPECT_EQ(59, timestamp_var.second); EXPECT_EQ(0, timestamp_var.fraction); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLBindColDataQuery) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLBindColDataQuery) { // Numeric Types // Signed Tiny Int @@ -1616,14 +1549,11 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLBindColDataQuery) { EXPECT_EQ(59, timestamp_val_max.minute); EXPECT_EQ(59, timestamp_val_max.second); EXPECT_EQ(0, timestamp_val_max.fraction); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLBindColTimeQuery) { +TEST_F(StatementRemoteTest, TestSQLBindColTimeQuery) { // Mock server test is skipped due to limitation on the mock server. // Time type from mock server does not include the fraction - this->Connect(); SQL_TIME_STRUCT time_var_min{}; SQL_TIME_STRUCT time_var_max{}; @@ -1657,14 +1587,11 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLBindColTimeQuery) { EXPECT_EQ(23, time_var_max.hour); EXPECT_EQ(59, time_var_max.minute); EXPECT_EQ(59, time_var_max.second); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLBindColVarbinaryQuery) { +TEST_F(StatementMockTest, TestSQLBindColVarbinaryQuery) { // Have binary test on mock test base as remote test servers tend to have different // formats for binary data - this->Connect(); // varbinary std::vector varbinary_val(3); @@ -1685,14 +1612,11 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLBindColVarbinaryQuery) { EXPECT_EQ('\xAB', varbinary_val[0]); EXPECT_EQ('\xCD', varbinary_val[1]); EXPECT_EQ('\xEF', varbinary_val[2]); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLBindColNullQuery) { +TEST_F(StatementRemoteTest, TestSQLBindColNullQuery) { // Limitation on mock test server prevents null from working properly, so use remote // server instead. Mock server has type `DENSE_UNION` for null column data. - this->Connect(); SQLINTEGER val; SQLLEN ind; @@ -1709,14 +1633,11 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLBindColNullQuery) { // Verify SQL_NULL_DATA is returned for indicator EXPECT_EQ(SQL_NULL_DATA, ind); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, TestSQLBindColNullQueryNullIndicator) { +TEST_F(StatementRemoteTest, TestSQLBindColNullQueryNullIndicator) { // Limitation on mock test server prevents null from working properly, so use remote // server instead. Mock server has type `DENSE_UNION` for null column data. - this->Connect(); SQLINTEGER val; @@ -1731,13 +1652,9 @@ TEST_F(FlightSQLODBCRemoteTestBase, TestSQLBindColNullQueryNullIndicator) { ASSERT_EQ(SQL_ERROR, SQLFetch(this->stmt)); // Verify invalid null indicator is reported, as it is required VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_22002); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLBindColRowFetching) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLBindColRowFetching) { SQLINTEGER val; SQLLEN buf_len = sizeof(val); SQLLEN ind; @@ -1779,13 +1696,10 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLBindColRowFetching) { // Verify result set has no more data beyond row 3 ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLBindColRowArraySize) { +TYPED_TEST(StatementTest, TestSQLBindColRowArraySize) { // Set SQL_ATTR_ROW_ARRAY_SIZE to fetch 3 rows at once - this->Connect(); constexpr SQLULEN rows = 3; SQLINTEGER val[rows]; @@ -1831,15 +1745,12 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLBindColRowArraySize) { // Verify result set has no more data beyond row 3 ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, DISABLED_TestSQLBindColIndicatorOnly) { +TYPED_TEST(StatementTest, DISABLED_TestSQLBindColIndicatorOnly) { // GH-47021: implement driver to return indicator value when data pointer is null // Verify driver supports null data pointer with valid indicator pointer - this->Connect(); // Numeric Types @@ -1868,12 +1779,10 @@ TYPED_TEST(FlightSQLODBCTestBase, DISABLED_TestSQLBindColIndicatorOnly) { // Char array EXPECT_EQ(1, char_val_ind); - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLBindColIndicatorOnlySQLUnbind) { +TYPED_TEST(StatementTest, TestSQLBindColIndicatorOnlySQLUnbind) { // Verify driver supports valid indicator pointer after unbinding all columns - this->Connect(); // Numeric Types @@ -1908,13 +1817,10 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLBindColIndicatorOnlySQLUnbind) { // Char array // EXPECT_EQ(1, char_val_ind); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLExtendedFetchRowFetching) { +TYPED_TEST(StatementTest, TestSQLExtendedFetchRowFetching) { // Set SQL_ROWSET_SIZE to fetch 3 rows at once - this->Connect(); constexpr SQLULEN rows = 3; SQLINTEGER val[rows]; @@ -1965,16 +1871,12 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLExtendedFetchRowFetching) { SQLUSMALLINT row_status2[rows]; EXPECT_EQ(SQL_NO_DATA, SQLExtendedFetch(this->stmt, SQL_FETCH_NEXT, 0, &row_count2, row_status2)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, DISABLED_TestSQLExtendedFetchQueryNullIndicator) { +TEST_F(StatementRemoteTest, DISABLED_TestSQLExtendedFetchQueryNullIndicator) { // GH-47110: SQLExtendedFetch should return SQL_SUCCESS_WITH_INFO for 22002 // Limitation on mock test server prevents null from working properly, so use remote // server instead. Mock server has type `DENSE_UNION` for null column data. - this->Connect(); - SQLINTEGER val; ASSERT_EQ(SQL_SUCCESS, SQLBindCol(this->stmt, 1, SQL_C_LONG, &val, 0, 0)); @@ -1992,13 +1894,10 @@ TEST_F(FlightSQLODBCRemoteTestBase, DISABLED_TestSQLExtendedFetchQueryNullIndica ASSERT_EQ(SQL_SUCCESS_WITH_INFO, SQLExtendedFetch(this->stmt, SQL_FETCH_NEXT, 0, &row_count1, row_status1)); VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_22002); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLMoreResultsNoData) { +TYPED_TEST(StatementTest, TestSQLMoreResultsNoData) { // Verify SQLMoreResults is stubbed to return SQL_NO_DATA - this->Connect(); std::wstring wsql = L"SELECT 1;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -2007,24 +1906,16 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLMoreResultsNoData) { SQLExecDirect(this->stmt, &sql0[0], static_cast(sql0.size()))); ASSERT_EQ(SQL_NO_DATA, SQLMoreResults(this->stmt)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLMoreResultsInvalidFunctionSequence) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLMoreResultsInvalidFunctionSequence) { // Verify function sequence error state is reported when SQLMoreResults is called // without executing any queries ASSERT_EQ(SQL_ERROR, SQLMoreResults(this->stmt)); VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_HY010); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLNativeSqlReturnsInputString) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLNativeSqlReturnsInputString) { SQLWCHAR buf[1024]; SQLINTEGER buf_char_len = sizeof(buf) / ODBC::GetSqlWCharSize(); SQLWCHAR input_str[] = L"SELECT * FROM mytable WHERE id == 1"; @@ -2041,13 +1932,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLNativeSqlReturnsInputString) { std::wstring returned_string(buf, buf + output_char_len); EXPECT_EQ(expected_string, returned_string); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLNativeSqlReturnsNTSInputString) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLNativeSqlReturnsNTSInputString) { SQLWCHAR buf[1024]; SQLINTEGER buf_char_len = sizeof(buf) / ODBC::GetSqlWCharSize(); SQLWCHAR input_str[] = L"SELECT * FROM mytable WHERE id == 1"; @@ -2064,13 +1951,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLNativeSqlReturnsNTSInputString) { std::wstring returned_string(buf, buf + output_char_len); EXPECT_EQ(expected_string, returned_string); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLNativeSqlReturnsInputStringLength) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLNativeSqlReturnsInputStringLength) { SQLWCHAR input_str[] = L"SELECT * FROM mytable WHERE id == 1"; SQLINTEGER input_char_len = static_cast(wcslen(input_str)); SQLINTEGER output_char_len = 0; @@ -2085,13 +1968,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLNativeSqlReturnsInputStringLength) { SQLNativeSql(this->conn, input_str, SQL_NTS, nullptr, 0, &output_char_len)); EXPECT_EQ(input_char_len, output_char_len); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLNativeSqlReturnsTruncatedString) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLNativeSqlReturnsTruncatedString) { const SQLINTEGER small_buf_size_in_char = 11; SQLWCHAR small_buf[small_buf_size_in_char]; SQLINTEGER small_buf_char_len = sizeof(small_buf) / ODBC::GetSqlWCharSize(); @@ -2117,13 +1996,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLNativeSqlReturnsTruncatedString) { std::wstring returned_string(small_buf, small_buf + small_buf_char_len); EXPECT_EQ(expected_string, returned_string); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLNativeSqlReturnsErrorOnBadInputs) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLNativeSqlReturnsErrorOnBadInputs) { SQLWCHAR buf[1024]; SQLINTEGER buf_char_len = sizeof(buf) / ODBC::GetSqlWCharSize(); SQLWCHAR input_str[] = L"SELECT * FROM mytable WHERE id == 1"; @@ -2141,13 +2016,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLNativeSqlReturnsErrorOnBadInputs) { ASSERT_EQ(SQL_ERROR, SQLNativeSql(this->conn, input_str, -100, buf, buf_char_len, &output_char_len)); VerifyOdbcErrorState(SQL_HANDLE_DBC, this->conn, error_state_HY090); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, SQLNumResultColsReturnsColumnsOnSelect) { - this->Connect(); - +TYPED_TEST(StatementTest, SQLNumResultColsReturnsColumnsOnSelect) { SQLSMALLINT column_count = 0; SQLSMALLINT expected_value = 3; SQLWCHAR sql_query[] = L"SELECT 1 AS col1, 'One' AS col2, 3 AS col3"; @@ -2164,13 +2035,9 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLNumResultColsReturnsColumnsOnSelect) { ASSERT_EQ(SQL_SUCCESS, SQLNumResultCols(this->stmt, &column_count)); EXPECT_EQ(expected_value, column_count); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, SQLNumResultColsReturnsSuccessOnNullptr) { - this->Connect(); - +TYPED_TEST(StatementTest, SQLNumResultColsReturnsSuccessOnNullptr) { SQLWCHAR sql_query[] = L"SELECT 1 AS col1, 'One' AS col2, 3 AS col3"; SQLINTEGER query_length = static_cast(wcslen(sql_query)); @@ -2183,13 +2050,9 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLNumResultColsReturnsSuccessOnNullptr) { CheckIntColumn(this->stmt, 3, 3); ASSERT_EQ(SQL_SUCCESS, SQLNumResultCols(this->stmt, nullptr)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, SQLNumResultColsFunctionSequenceErrorOnNoQuery) { - this->Connect(); - +TYPED_TEST(StatementTest, SQLNumResultColsFunctionSequenceErrorOnNoQuery) { SQLSMALLINT column_count = 0; SQLSMALLINT expected_value = 0; @@ -2197,13 +2060,9 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLNumResultColsFunctionSequenceErrorOnNoQuery VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_HY010); EXPECT_EQ(expected_value, column_count); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, SQLRowCountReturnsNegativeOneOnSelect) { - this->Connect(); - +TYPED_TEST(StatementTest, SQLRowCountReturnsNegativeOneOnSelect) { SQLLEN row_count = 0; SQLLEN expected_value = -1; SQLWCHAR sql_query[] = L"SELECT 1 AS col1, 'One' AS col2, 3 AS col3"; @@ -2220,13 +2079,9 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLRowCountReturnsNegativeOneOnSelect) { ASSERT_EQ(SQL_SUCCESS, SQLRowCount(this->stmt, &row_count)); EXPECT_EQ(expected_value, row_count); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, SQLRowCountReturnsSuccessOnNullptr) { - this->Connect(); - +TYPED_TEST(StatementTest, SQLRowCountReturnsSuccessOnNullptr) { SQLWCHAR sql_query[] = L"SELECT 1 AS col1, 'One' AS col2, 3 AS col3"; SQLINTEGER query_length = static_cast(wcslen(sql_query)); @@ -2239,13 +2094,9 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLRowCountReturnsSuccessOnNullptr) { CheckIntColumn(this->stmt, 3, 3); ASSERT_EQ(SQL_SUCCESS, SQLRowCount(this->stmt, 0)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, SQLRowCountFunctionSequenceErrorOnNoQuery) { - this->Connect(); - +TYPED_TEST(StatementTest, SQLRowCountFunctionSequenceErrorOnNoQuery) { SQLLEN row_count = 0; SQLLEN expected_value = 0; @@ -2253,13 +2104,9 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLRowCountFunctionSequenceErrorOnNoQuery) { VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_HY010); EXPECT_EQ(expected_value, row_count); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLFreeStmtSQLClose) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLFreeStmtSQLClose) { std::wstring wsql = L"SELECT 1;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -2267,13 +2114,9 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLFreeStmtSQLClose) { SQLExecDirect(this->stmt, &sql0[0], static_cast(sql0.size()))); ASSERT_EQ(SQL_SUCCESS, SQLFreeStmt(this->stmt, SQL_CLOSE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLCloseCursor) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLCloseCursor) { std::wstring wsql = L"SELECT 1;"; std::vector sql0(wsql.begin(), wsql.end()); @@ -2281,28 +2124,19 @@ TYPED_TEST(FlightSQLODBCTestBase, TestSQLCloseCursor) { SQLExecDirect(this->stmt, &sql0[0], static_cast(sql0.size()))); ASSERT_EQ(SQL_SUCCESS, SQLCloseCursor(this->stmt)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLFreeStmtSQLCloseWithoutCursor) { +TYPED_TEST(StatementTest, TestSQLFreeStmtSQLCloseWithoutCursor) { // SQLFreeStmt(SQL_CLOSE) does not throw error with invalid cursor - this->Connect(); ASSERT_EQ(SQL_SUCCESS, SQLFreeStmt(this->stmt, SQL_CLOSE)); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLCloseCursorWithoutCursor) { - this->Connect(); - +TYPED_TEST(StatementTest, TestSQLCloseCursorWithoutCursor) { ASSERT_EQ(SQL_ERROR, SQLCloseCursor(this->stmt)); // Verify invalid cursor error state is returned VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_24000); - - this->Disconnect(); } } // namespace arrow::flight::sql::odbc diff --git a/cpp/src/arrow/flight/sql/odbc/tests/tables_test.cc b/cpp/src/arrow/flight/sql/odbc/tests/tables_test.cc index 154e79c2308e..762c6a05bcaf 100644 --- a/cpp/src/arrow/flight/sql/odbc/tests/tables_test.cc +++ b/cpp/src/arrow/flight/sql/odbc/tests/tables_test.cc @@ -26,6 +26,27 @@ namespace arrow::flight::sql::odbc { +template +class TablesTest : public T { + public: + using List = std::list; +}; + +class TablesMockTest : public FlightSQLODBCMockTestBase {}; +class TablesRemoteTest : public FlightSQLODBCRemoteTestBase {}; +using TestTypes = ::testing::Types; +TYPED_TEST_SUITE(TablesTest, TestTypes); + +template +class TablesOdbcV2Test : public T { + public: + using List = std::list; +}; + +using TestTypesOdbcV2 = + ::testing::Types; +TYPED_TEST_SUITE(TablesOdbcV2Test, TestTypesOdbcV2); + // Helper Functions std::wstring GetStringColumnW(SQLHSTMT stmt, int colId) { @@ -46,9 +67,7 @@ std::wstring GetStringColumnW(SQLHSTMT stmt, int colId) { // Test Cases -TYPED_TEST(FlightSQLODBCTestBase, SQLTablesTestInputData) { - this->Connect(); - +TYPED_TEST(TablesTest, SQLTablesTestInputData) { SQLWCHAR catalog_name[] = L""; SQLWCHAR schema_name[] = L""; SQLWCHAR table_name[] = L""; @@ -80,13 +99,9 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLTablesTestInputData) { EXPECT_EQ(SQL_SUCCESS, SQLTables(this->stmt, 0, 0, 0, 0, 0, 0, 0, 0)); ValidateFetch(this->stmt, SQL_SUCCESS); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, SQLTablesTestGetMetadataForAllCatalogs) { - this->Connect(); - +TEST_F(TablesMockTest, SQLTablesTestGetMetadataForAllCatalogs) { SQLWCHAR empty[] = L""; SQLWCHAR SQL_ALL_CATALOGS_W[] = L"%"; std::wstring expected_catalog_name = std::wstring(L"main"); @@ -104,12 +119,9 @@ TEST_F(FlightSQLODBCMockTestBase, SQLTablesTestGetMetadataForAllCatalogs) { CheckNullColumnW(this->stmt, 5); ValidateFetch(this->stmt, SQL_NO_DATA); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, SQLTablesTestGetMetadataForNamedCatalog) { - this->Connect(); +TEST_F(TablesMockTest, SQLTablesTestGetMetadataForNamedCatalog) { this->CreateTestTables(); SQLWCHAR catalog_name[] = L"main"; @@ -135,13 +147,9 @@ TEST_F(FlightSQLODBCMockTestBase, SQLTablesTestGetMetadataForNamedCatalog) { } ValidateFetch(this->stmt, SQL_NO_DATA); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, SQLTablesTestGetSchemaHasNoData) { - this->Connect(); - +TEST_F(TablesMockTest, SQLTablesTestGetSchemaHasNoData) { SQLWCHAR SQL_ALL_SCHEMAS_W[] = L"%"; // Validate that no schema data is available for Mock server @@ -149,13 +157,9 @@ TEST_F(FlightSQLODBCMockTestBase, SQLTablesTestGetSchemaHasNoData) { SQL_NTS, nullptr, SQL_NTS, nullptr, SQL_NTS)); ValidateFetch(this->stmt, SQL_NO_DATA); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, SQLTablesTestGetMetadataForAllSchemas) { - this->Connect(); - +TEST_F(TablesRemoteTest, SQLTablesTestGetMetadataForAllSchemas) { SQLWCHAR empty[] = L""; SQLWCHAR SQL_ALL_SCHEMAS_W[] = L"%"; std::set actual_schemas; @@ -185,14 +189,10 @@ TEST_F(FlightSQLODBCRemoteTestBase, SQLTablesTestGetMetadataForAllSchemas) { } EXPECT_EQ(actual_schemas, expected_schemas); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, SQLTablesTestFilterByAllSchema) { +TEST_F(TablesRemoteTest, SQLTablesTestFilterByAllSchema) { // Requires creation of user table named ODBCTest using schema $scratch in remote server - this->Connect(); - SQLWCHAR SQL_ALL_SCHEMAS_W[] = L"%"; SQLWCHAR* schema_names[] = {(SQLWCHAR*)L"INFORMATION_SCHEMA", (SQLWCHAR*)L"INFORMATION_SCHEMA", @@ -249,14 +249,10 @@ TEST_F(FlightSQLODBCRemoteTestBase, SQLTablesTestFilterByAllSchema) { } ValidateFetch(this->stmt, SQL_NO_DATA); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, SQLTablesGetMetadataForNamedSchema) { +TEST_F(TablesRemoteTest, SQLTablesGetMetadataForNamedSchema) { // Requires creation of user table named ODBCTest using schema $scratch in remote server - this->Connect(); - SQLWCHAR schema_name[] = L"$scratch"; std::wstring expected_schema_name = std::wstring(schema_name); std::wstring expected_table_name = std::wstring(L"ODBCTest"); @@ -274,12 +270,9 @@ TEST_F(FlightSQLODBCRemoteTestBase, SQLTablesGetMetadataForNamedSchema) { CheckNullColumnW(this->stmt, 5); ValidateFetch(this->stmt, SQL_NO_DATA); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, SQLTablesTestGetMetadataForAllTables) { - this->Connect(); +TEST_F(TablesMockTest, SQLTablesTestGetMetadataForAllTables) { this->CreateTestTables(); SQLWCHAR SQL_ALL_TABLES_W[] = L"%"; @@ -305,12 +298,9 @@ TEST_F(FlightSQLODBCMockTestBase, SQLTablesTestGetMetadataForAllTables) { } ValidateFetch(this->stmt, SQL_NO_DATA); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, SQLTablesTestGetMetadataForTableName) { - this->Connect(); +TEST_F(TablesMockTest, SQLTablesTestGetMetadataForTableName) { this->CreateTestTables(); SQLWCHAR* table_names[] = {(SQLWCHAR*)L"TestTable", (SQLWCHAR*)L"foreignTable", @@ -334,12 +324,9 @@ TEST_F(FlightSQLODBCMockTestBase, SQLTablesTestGetMetadataForTableName) { ValidateFetch(this->stmt, SQL_NO_DATA); } - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, SQLTablesTestGetMetadataForUnicodeTableByTableName) { - this->Connect(); +TEST_F(TablesMockTest, SQLTablesTestGetMetadataForUnicodeTableByTableName) { this->CreateUnicodeTable(); SQLWCHAR unicodetable_name[] = L"数据"; @@ -361,12 +348,9 @@ TEST_F(FlightSQLODBCMockTestBase, SQLTablesTestGetMetadataForUnicodeTableByTable CheckNullColumnW(this->stmt, 5); ValidateFetch(this->stmt, SQL_NO_DATA); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, SQLTablesTestGetMetadataForInvalidTableNameNoData) { - this->Connect(); +TEST_F(TablesMockTest, SQLTablesTestGetMetadataForInvalidTableNameNoData) { this->CreateTestTables(); SQLWCHAR invalid_table_name[] = L"NonExistanttable_name"; @@ -376,13 +360,10 @@ TEST_F(FlightSQLODBCMockTestBase, SQLTablesTestGetMetadataForInvalidTableNameNoD invalid_table_name, SQL_NTS, nullptr, SQL_NTS)); ValidateFetch(this->stmt, SQL_NO_DATA); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, SQLTablesGetMetadataForTableType) { +TEST_F(TablesMockTest, SQLTablesGetMetadataForTableType) { // Mock server only supports table type "table" in lowercase - this->Connect(); this->CreateTestTables(); SQLWCHAR table_type_table_lowercase[] = L"table"; @@ -428,14 +409,10 @@ TEST_F(FlightSQLODBCMockTestBase, SQLTablesGetMetadataForTableType) { } ValidateFetch(this->stmt, SQL_NO_DATA); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, SQLTablesGetMetadataForTableTypeTable) { +TEST_F(TablesRemoteTest, SQLTablesGetMetadataForTableTypeTable) { // Requires creation of user table named ODBCTest using schema $scratch in remote server - this->Connect(); - SQLWCHAR* type_list[] = {(SQLWCHAR*)L"TABLE", (SQLWCHAR*)L"TABLE,VIEW"}; std::wstring expected_schema_name = std::wstring(L"$scratch"); std::wstring expected_table_name = std::wstring(L"ODBCTest"); @@ -455,13 +432,9 @@ TEST_F(FlightSQLODBCRemoteTestBase, SQLTablesGetMetadataForTableTypeTable) { ValidateFetch(this->stmt, SQL_NO_DATA); } - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, SQLTablesGetMetadataForTableTypeViewHasNoData) { - this->Connect(); - +TEST_F(TablesRemoteTest, SQLTablesGetMetadataForTableTypeViewHasNoData) { SQLWCHAR empty[] = L""; SQLWCHAR type_view[] = L"VIEW"; @@ -474,13 +447,9 @@ TEST_F(FlightSQLODBCRemoteTestBase, SQLTablesGetMetadataForTableTypeViewHasNoDat nullptr, SQL_NTS, type_view, SQL_NTS)); ValidateFetch(this->stmt, SQL_NO_DATA); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, SQLTablesGetSupportedTableTypes) { - this->Connect(); - +TEST_F(TablesMockTest, SQLTablesGetSupportedTableTypes) { SQLWCHAR empty[] = L""; SQLWCHAR SQL_ALL_TABLE_TYPES_W[] = L"%"; std::wstring expected_table_type = std::wstring(L"table"); @@ -498,13 +467,9 @@ TEST_F(FlightSQLODBCMockTestBase, SQLTablesGetSupportedTableTypes) { CheckNullColumnW(this->stmt, 5); ValidateFetch(this->stmt, SQL_NO_DATA); - - this->Disconnect(); } -TEST_F(FlightSQLODBCRemoteTestBase, SQLTablesGetSupportedTableTypes) { - this->Connect(); - +TEST_F(TablesRemoteTest, SQLTablesGetSupportedTableTypes) { SQLWCHAR empty[] = L""; SQLWCHAR SQL_ALL_TABLE_TYPES_W[] = L"%"; SQLWCHAR* type_lists[] = {(SQLWCHAR*)L"TABLE", (SQLWCHAR*)L"SYSTEM_TABLE", @@ -524,13 +489,9 @@ TEST_F(FlightSQLODBCRemoteTestBase, SQLTablesGetSupportedTableTypes) { } ValidateFetch(this->stmt, SQL_NO_DATA); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, SQLTablesGetMetadataBySQLDescribeCol) { - this->Connect(); - +TYPED_TEST(TablesTest, SQLTablesGetMetadataBySQLDescribeCol) { SQLWCHAR column_name[1024]; SQLSMALLINT buf_char_len = static_cast(sizeof(column_name) / ODBC::GetSqlWCharSize()); @@ -573,13 +534,9 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLTablesGetMetadataBySQLDescribeCol) { decimal_digits = 0; nullable = 0; } - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, SQLTablesGetMetadataBySQLDescribeColODBC2) { - this->Connect(SQL_OV_ODBC2); - +TYPED_TEST(TablesOdbcV2Test, SQLTablesGetMetadataBySQLDescribeColODBC2) { SQLWCHAR column_name[1024]; SQLSMALLINT buf_char_len = static_cast(sizeof(column_name) / ODBC::GetSqlWCharSize()); @@ -622,7 +579,5 @@ TYPED_TEST(FlightSQLODBCTestBase, SQLTablesGetMetadataBySQLDescribeColODBC2) { decimal_digits = 0; nullable = 0; } - - this->Disconnect(); } } // namespace arrow::flight::sql::odbc diff --git a/cpp/src/arrow/flight/sql/odbc/tests/type_info_test.cc b/cpp/src/arrow/flight/sql/odbc/tests/type_info_test.cc index da9d92ef1fa4..1824bc19b21b 100644 --- a/cpp/src/arrow/flight/sql/odbc/tests/type_info_test.cc +++ b/cpp/src/arrow/flight/sql/odbc/tests/type_info_test.cc @@ -28,6 +28,18 @@ namespace arrow::flight::sql::odbc { using std::optional; +template +class TypeInfoTest : public T { + public: + using List = std::list; +}; + +class TypeInfoMockTest : public FlightSQLODBCMockTestBase {}; +using TestTypes = ::testing::Types; +TYPED_TEST_SUITE(TypeInfoTest, TestTypes); + +class TypeInfoOdbcV2MockTest : public FlightSQLOdbcV2MockTestBase {}; + void CheckSQLDescribeCol(SQLHSTMT stmt, const SQLUSMALLINT column_index, const std::wstring& expected_name, const SQLSMALLINT& expected_data_type, @@ -184,9 +196,7 @@ void CheckSQLGetTypeInfo( CheckIntColumn(stmt, 19, expected_interval_prec); // interval prec } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoAllTypes) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoAllTypes) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_ALL_TYPES)); // Check bit data type @@ -634,13 +644,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoAllTypes) { NULL); // expected_interval_prec CheckSQLDescribeColODBC3(this->stmt); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoAllTypesODBCVer2) { - this->Connect(SQL_OV_ODBC2); - +TEST_F(TypeInfoOdbcV2MockTest, TestSQLGetTypeInfoAllTypesODBCVer2) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_ALL_TYPES)); // Check bit data type @@ -1088,13 +1094,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoAllTypesODBCVer2) { NULL); // expected_interval_prec CheckSQLDescribeColODBC2(this->stmt); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoBit) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoBit) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_BIT)); // Check bit data type @@ -1125,13 +1127,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoBit) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoTinyInt) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoTinyInt) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_TINYINT)); // Check tinyint data type @@ -1162,13 +1160,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoTinyInt) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoBigInt) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoBigInt) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_BIGINT)); // Check bigint data type @@ -1199,13 +1193,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoBigInt) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoLongVarbinary) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoLongVarbinary) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_LONGVARBINARY)); // Check longvarbinary data type @@ -1236,13 +1226,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoLongVarbinary) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoVarbinary) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoVarbinary) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_VARBINARY)); // Check varbinary data type @@ -1271,13 +1257,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoVarbinary) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoLongVarchar) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoLongVarchar) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_WLONGVARCHAR)); // Check text data type @@ -1335,13 +1317,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoLongVarchar) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoChar) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoChar) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_WCHAR)); // Check char data type @@ -1373,13 +1351,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoChar) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoInteger) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoInteger) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_INTEGER)); // Check integer data type @@ -1410,13 +1384,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoInteger) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSmallInt) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoSmallInt) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_SMALLINT)); // Check smallint data type @@ -1447,13 +1417,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSmallInt) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoFloat) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoFloat) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_FLOAT)); // Check float data type @@ -1484,13 +1450,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoFloat) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoDouble) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoDouble) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_DOUBLE)); // Check double data type @@ -1548,13 +1510,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoDouble) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoVarchar) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoVarchar) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_WVARCHAR)); // Check varchar data type @@ -1586,13 +1544,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoVarchar) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTypeDate) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoSQLTypeDate) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_TYPE_DATE)); // Check date data type @@ -1623,13 +1577,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTypeDate) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLDate) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoSQLDate) { // Pass ODBC Ver 2 data type ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_DATE)); @@ -1661,13 +1611,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLDate) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoDateODBCVer2) { - this->Connect(SQL_OV_ODBC2); - +TEST_F(TypeInfoOdbcV2MockTest, TestSQLGetTypeInfoDateODBCVer2) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_DATE)); // Check date data type @@ -1698,25 +1644,17 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoDateODBCVer2) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTypeDateODBCVer2) { - this->Connect(SQL_OV_ODBC2); - +TEST_F(TypeInfoOdbcV2MockTest, TestSQLGetTypeInfoSQLTypeDateODBCVer2) { // Pass ODBC Ver 3 data type ASSERT_EQ(SQL_ERROR, SQLGetTypeInfo(this->stmt, SQL_TYPE_DATE)); // Driver manager returns SQL data type out of range error state VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_S1004); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTypeTime) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoSQLTypeTime) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_TYPE_TIME)); // Check time data type @@ -1747,13 +1685,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTypeTime) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTime) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoSQLTime) { // Pass ODBC Ver 2 data type ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_TIME)); @@ -1785,13 +1719,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTime) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoTimeODBCVer2) { - this->Connect(SQL_OV_ODBC2); - +TEST_F(TypeInfoOdbcV2MockTest, TestSQLGetTypeInfoTimeODBCVer2) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_TIME)); // Check time data type @@ -1822,25 +1752,17 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoTimeODBCVer2) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTypeTimeODBCVer2) { - this->Connect(SQL_OV_ODBC2); - +TEST_F(TypeInfoOdbcV2MockTest, TestSQLGetTypeInfoSQLTypeTimeODBCVer2) { // Pass ODBC Ver 3 data type ASSERT_EQ(SQL_ERROR, SQLGetTypeInfo(this->stmt, SQL_TYPE_TIME)); // Driver manager returns SQL data type out of range error state VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_S1004); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTypeTimestamp) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoSQLTypeTimestamp) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_TYPE_TIMESTAMP)); // Check timestamp data type @@ -1871,13 +1793,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTypeTimestamp) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTimestamp) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoSQLTimestamp) { // Pass ODBC Ver 2 data type ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_TIMESTAMP)); @@ -1909,13 +1827,9 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTimestamp) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTimestampODBCVer2) { - this->Connect(SQL_OV_ODBC2); - +TEST_F(TypeInfoOdbcV2MockTest, TestSQLGetTypeInfoSQLTimestampODBCVer2) { ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_TIMESTAMP)); // Check timestamp data type @@ -1946,42 +1860,29 @@ TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTimestampODBCVer2) { // No more data ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoSQLTypeTimestampODBCVer2) { - this->Connect(SQL_OV_ODBC2); - +TEST_F(TypeInfoOdbcV2MockTest, TestSQLGetTypeInfoSQLTypeTimestampODBCVer2) { // Pass ODBC Ver 3 data type ASSERT_EQ(SQL_ERROR, SQLGetTypeInfo(this->stmt, SQL_TYPE_TIMESTAMP)); // Driver manager returns SQL data type out of range error state VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_S1004); - - this->Disconnect(); } -TEST_F(FlightSQLODBCMockTestBase, TestSQLGetTypeInfoInvalidDataType) { - this->Connect(); - +TEST_F(TypeInfoMockTest, TestSQLGetTypeInfoInvalidDataType) { SQLSMALLINT invalid_data_type = -114; ASSERT_EQ(SQL_ERROR, SQLGetTypeInfo(this->stmt, invalid_data_type)); VerifyOdbcErrorState(SQL_HANDLE_STMT, this->stmt, error_state_HY004); - - this->Disconnect(); } -TYPED_TEST(FlightSQLODBCTestBase, TestSQLGetTypeInfoUnsupportedDataType) { +TYPED_TEST(TypeInfoTest, TestSQLGetTypeInfoUnsupportedDataType) { // Assumes mock and remote server don't support GUID data type - this->Connect(); ASSERT_EQ(SQL_SUCCESS, SQLGetTypeInfo(this->stmt, SQL_GUID)); // Result set is empty with valid data type that is unsupported by the server ASSERT_EQ(SQL_NO_DATA, SQLFetch(this->stmt)); - - this->Disconnect(); } } // namespace arrow::flight::sql::odbc