diff --git a/cpp/src/arrow/flight/sql/odbc/odbc_impl/odbc_statement.cc b/cpp/src/arrow/flight/sql/odbc/odbc_impl/odbc_statement.cc index 83125058f039..6ae9cde051ff 100644 --- a/cpp/src/arrow/flight/sql/odbc/odbc_impl/odbc_statement.cc +++ b/cpp/src/arrow/flight/sql/odbc/odbc_impl/odbc_statement.cc @@ -399,6 +399,14 @@ void ODBCStatement::GetStmtAttr(SQLINTEGER statement_attribute, SQLPOINTER outpu return; case SQL_ATTR_PARAM_BIND_TYPE: current_apd_->GetHeaderField(SQL_DESC_BIND_TYPE, output, buffer_size, str_len_ptr); + if (output) { + // Convert SQLINTEGER output to SQLULEN, since SQL_DESC_BIND_TYPE is SQLINTEGER + // and SQL_ATTR_PARAM_BIND_TYPE is SQLULEN + SQLINTEGER* output_int_ptr = reinterpret_cast(output); + SQLINTEGER output_int = *output_int_ptr; + SQLULEN* typed_output = reinterpret_cast(output); + *typed_output = static_cast(output_int); + } return; case SQL_ATTR_PARAM_OPERATION_PTR: current_apd_->GetHeaderField(SQL_DESC_ARRAY_STATUS_PTR, output, buffer_size, @@ -422,6 +430,14 @@ void ODBCStatement::GetStmtAttr(SQLINTEGER statement_attribute, SQLPOINTER outpu return; case SQL_ATTR_ROW_BIND_TYPE: current_ard_->GetHeaderField(SQL_DESC_BIND_TYPE, output, buffer_size, str_len_ptr); + if (output) { + // Convert SQLINTEGER output to SQLULEN, since SQL_DESC_BIND_TYPE is SQLINTEGER + // and SQL_ATTR_ROW_BIND_TYPE is SQLULEN + SQLINTEGER* output_int_ptr = reinterpret_cast(output); + SQLINTEGER output_int = *output_int_ptr; + SQLULEN* typed_output = reinterpret_cast(output); + *typed_output = static_cast(output_int); + } return; case SQL_ATTR_ROW_OPERATION_PTR: current_ard_->GetHeaderField(SQL_DESC_ARRAY_STATUS_PTR, output, buffer_size, 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 519bbbfe1ac7..cec7ee3ddbf7 100644 --- a/cpp/src/arrow/flight/sql/odbc/tests/columns_test.cc +++ b/cpp/src/arrow/flight/sql/odbc/tests/columns_test.cc @@ -298,9 +298,8 @@ void CheckSQLColAttributes(SQLHSTMT stmt, SQLUSMALLINT idx, EXPECT_EQ(expected_unsigned_column, unsigned_col); } -void CheckSQLColAttributeString(SQLHSTMT stmt, const std::wstring& wsql, SQLUSMALLINT idx, - SQLUSMALLINT field_identifier, - const std::wstring& expected_attr_string) { +void GetSQLColAttributeString(SQLHSTMT stmt, const std::wstring& wsql, SQLUSMALLINT idx, + SQLUSMALLINT field_identifier, std::wstring& value) { if (!wsql.empty()) { // Execute query std::vector sql0(wsql.begin(), wsql.end()); @@ -317,28 +316,11 @@ void CheckSQLColAttributeString(SQLHSTMT stmt, const std::wstring& wsql, SQLUSMA ASSERT_EQ(SQL_SUCCESS, SQLColAttribute(stmt, idx, field_identifier, &str_val[0], (SQLSMALLINT)str_val.size(), &str_len, 0)); - std::wstring attr_str = ConvertToWString(str_val, str_len); - ASSERT_EQ(expected_attr_string, attr_str); + value = ConvertToWString(str_val, str_len); } -void CheckSQLColAttributeNumeric(SQLHSTMT stmt, const std::wstring& wsql, - SQLUSMALLINT idx, SQLUSMALLINT field_identifier, - SQLLEN expected_attr_numeric) { - // Execute query and check SQLColAttribute numeric attribute - std::vector sql0(wsql.begin(), wsql.end()); - ASSERT_EQ(SQL_SUCCESS, - SQLExecDirect(stmt, &sql0[0], static_cast(sql0.size()))); - - ASSERT_EQ(SQL_SUCCESS, SQLFetch(stmt)); - - SQLLEN num_val = 0; - ASSERT_EQ(SQL_SUCCESS, SQLColAttribute(stmt, idx, field_identifier, 0, 0, 0, &num_val)); - ASSERT_EQ(expected_attr_numeric, num_val); -} - -void CheckSQLColAttributesString(SQLHSTMT stmt, const std::wstring& wsql, - SQLUSMALLINT idx, SQLUSMALLINT field_identifier, - const std::wstring& expected_attr_string) { +void GetSQLColAttributesString(SQLHSTMT stmt, const std::wstring& wsql, SQLUSMALLINT idx, + SQLUSMALLINT field_identifier, std::wstring& value) { if (!wsql.empty()) { // Execute query std::vector sql0(wsql.begin(), wsql.end()); @@ -348,21 +330,19 @@ void CheckSQLColAttributesString(SQLHSTMT stmt, const std::wstring& wsql, ASSERT_EQ(SQL_SUCCESS, SQLFetch(stmt)); } - // check ODBC 2.0 API SQLColAttributes string attribute + // check SQLColAttribute string attribute std::vector str_val(kOdbcBufferSize); SQLSMALLINT str_len = 0; ASSERT_EQ(SQL_SUCCESS, SQLColAttributes(stmt, idx, field_identifier, &str_val[0], (SQLSMALLINT)str_val.size(), &str_len, 0)); - std::wstring attr_str = ConvertToWString(str_val, str_len); - ASSERT_EQ(expected_attr_string, attr_str); + value = ConvertToWString(str_val, str_len); } -void CheckSQLColAttributesNumeric(SQLHSTMT stmt, const std::wstring& wsql, - SQLUSMALLINT idx, SQLUSMALLINT field_identifier, - SQLLEN expected_attr_numeric) { - // Execute query and check ODBC 2.0 API SQLColAttributes numeric attribute +void GetSQLColAttributeNumeric(SQLHSTMT stmt, const std::wstring& wsql, SQLUSMALLINT idx, + SQLUSMALLINT field_identifier, SQLLEN* value) { + // Execute query and check SQLColAttribute numeric attribute std::vector sql0(wsql.begin(), wsql.end()); ASSERT_EQ(SQL_SUCCESS, SQLExecDirect(stmt, &sql0[0], static_cast(sql0.size()))); @@ -370,9 +350,20 @@ void CheckSQLColAttributesNumeric(SQLHSTMT stmt, const std::wstring& wsql, ASSERT_EQ(SQL_SUCCESS, SQLFetch(stmt)); SQLLEN num_val = 0; + ASSERT_EQ(SQL_SUCCESS, SQLColAttribute(stmt, idx, field_identifier, 0, 0, 0, value)); +} + +void GetSQLColAttributesNumeric(SQLHSTMT stmt, const std::wstring& wsql, SQLUSMALLINT idx, + SQLUSMALLINT field_identifier, SQLLEN* value) { + // Execute query and check SQLColAttribute numeric attribute + std::vector sql0(wsql.begin(), wsql.end()); ASSERT_EQ(SQL_SUCCESS, - SQLColAttributes(stmt, idx, field_identifier, 0, 0, 0, &num_val)); - ASSERT_EQ(expected_attr_numeric, num_val); + SQLExecDirect(stmt, &sql0[0], static_cast(sql0.size()))); + + ASSERT_EQ(SQL_SUCCESS, SQLFetch(stmt)); + + SQLLEN num_val = 0; + ASSERT_EQ(SQL_SUCCESS, SQLColAttributes(stmt, idx, field_identifier, 0, 0, 0, value)); } } // namespace @@ -1893,10 +1884,13 @@ TYPED_TEST(ColumnsTest, TestSQLColAttributeCaseSensitive) { std::wstring wsql = this->GetQueryAllDataTypes(); // Int column - CheckSQLColAttributeNumeric(this->stmt, wsql, 1, SQL_DESC_CASE_SENSITIVE, SQL_FALSE); + SQLLEN value; + GetSQLColAttributeNumeric(this->stmt, wsql, 1, SQL_DESC_CASE_SENSITIVE, &value); + ASSERT_EQ(SQL_FALSE, value); SQLFreeStmt(this->stmt, SQL_CLOSE); // Varchar column - CheckSQLColAttributeNumeric(this->stmt, wsql, 28, SQL_DESC_CASE_SENSITIVE, SQL_FALSE); + GetSQLColAttributeNumeric(this->stmt, wsql, 28, SQL_DESC_CASE_SENSITIVE, &value); + ASSERT_EQ(SQL_FALSE, value); } TYPED_TEST(ColumnsOdbcV2Test, TestSQLColAttributesCaseSensitive) { @@ -1905,11 +1899,13 @@ TYPED_TEST(ColumnsOdbcV2Test, TestSQLColAttributesCaseSensitive) { std::wstring wsql = this->GetQueryAllDataTypes(); // Int column - CheckSQLColAttributesNumeric(this->stmt, wsql, 1, SQL_COLUMN_CASE_SENSITIVE, SQL_FALSE); + SQLLEN value; + GetSQLColAttributesNumeric(this->stmt, wsql, 1, SQL_COLUMN_CASE_SENSITIVE, &value); + ASSERT_EQ(SQL_FALSE, value); SQLFreeStmt(this->stmt, SQL_CLOSE); // Varchar column - CheckSQLColAttributesNumeric(this->stmt, wsql, 28, SQL_COLUMN_CASE_SENSITIVE, - SQL_FALSE); + GetSQLColAttributesNumeric(this->stmt, wsql, 28, SQL_COLUMN_CASE_SENSITIVE, &value); + ASSERT_EQ(SQL_FALSE, value); } TEST_F(ColumnsMockTest, TestSQLColAttributeUniqueValue) { @@ -1917,7 +1913,9 @@ TEST_F(ColumnsMockTest, TestSQLColAttributeUniqueValue) { this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; - CheckSQLColAttributeNumeric(this->stmt, wsql, 1, SQL_DESC_AUTO_UNIQUE_VALUE, SQL_FALSE); + SQLLEN value; + GetSQLColAttributeNumeric(this->stmt, wsql, 1, SQL_DESC_AUTO_UNIQUE_VALUE, &value); + ASSERT_EQ(SQL_FALSE, value); } TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributesAutoIncrement) { @@ -1926,42 +1924,48 @@ TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributesAutoIncrement) { this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; - CheckSQLColAttributeNumeric(this->stmt, wsql, 1, SQL_COLUMN_AUTO_INCREMENT, SQL_FALSE); + SQLLEN value; + GetSQLColAttributeNumeric(this->stmt, wsql, 1, SQL_COLUMN_AUTO_INCREMENT, &value); + ASSERT_EQ(SQL_FALSE, value); } -TEST_F(ColumnsMockTest, TestSQLColAttributeBasetable_name) { +TEST_F(ColumnsMockTest, TestSQLColAttributeBaseTableName) { this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; - CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_BASE_TABLE_NAME, - std::wstring(L"AllTypesTable")); + std::wstring value; + GetSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_BASE_TABLE_NAME, value); + ASSERT_EQ(std::wstring(L"AllTypesTable"), value); } -TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributestable_name) { +TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributesTableName) { // Tests ODBC 2.0 API SQLColAttributes this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; - CheckSQLColAttributesString(this->stmt, wsql, 1, SQL_COLUMN_TABLE_NAME, - std::wstring(L"AllTypesTable")); + std::wstring value; + GetSQLColAttributesString(this->stmt, wsql, 1, SQL_COLUMN_TABLE_NAME, value); + ASSERT_EQ(std::wstring(L"AllTypesTable"), value); } -TEST_F(ColumnsMockTest, TestSQLColAttributecatalog_name) { +TEST_F(ColumnsMockTest, TestSQLColAttributeCatalogName) { // Mock server limitattion: mock doesn't return catalog for result metadata, // and the defautl catalog should be 'main' this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; - CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_CATALOG_NAME, - std::wstring(L"")); + std::wstring value; + GetSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_CATALOG_NAME, value); + ASSERT_EQ(std::wstring(L""), value); } -TEST_F(ColumnsRemoteTest, TestSQLColAttributecatalog_name) { +TEST_F(ColumnsRemoteTest, TestSQLColAttributeCatalogName) { // Remote server does not have catalogs std::wstring wsql = L"SELECT * from $scratch.ODBCTest;"; - CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_CATALOG_NAME, - std::wstring(L"")); + std::wstring value; + GetSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_CATALOG_NAME, value); + ASSERT_EQ(std::wstring(L""), value); } TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributesQualifierName) { @@ -1971,54 +1975,62 @@ TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributesQualifierName) { this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; - CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_COLUMN_QUALIFIER_NAME, - std::wstring(L"")); + std::wstring value; + GetSQLColAttributeString(this->stmt, wsql, 1, SQL_COLUMN_QUALIFIER_NAME, value); + ASSERT_EQ(std::wstring(L""), value); } TEST_F(ColumnsOdbcV2RemoteTest, TestSQLColAttributesQualifierName) { // Remote server does not have catalogs // Tests ODBC 2.0 API SQLColAttributes std::wstring wsql = L"SELECT * from $scratch.ODBCTest;"; - CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_COLUMN_QUALIFIER_NAME, - std::wstring(L"")); + std::wstring value; + GetSQLColAttributeString(this->stmt, wsql, 1, SQL_COLUMN_QUALIFIER_NAME, value); + ASSERT_EQ(std::wstring(L""), value); } 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); + SQLLEN value; + GetSQLColAttributeNumeric(this->stmt, wsql, 0, SQL_DESC_COUNT, &value); + ASSERT_EQ(32, value); } 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"")); + std::wstring value; + GetSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_LOCAL_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L""), value); } TEST_F(ColumnsRemoteTest, TestSQLColAttributeLocalTypeName) { std::wstring wsql = this->GetQueryAllDataTypes(); - CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_LOCAL_TYPE_NAME, - std::wstring(L"INTEGER")); + std::wstring value; + GetSQLColAttributesString(this->stmt, wsql, 1, SQL_DESC_LOCAL_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"INTEGER"), value); } -TEST_F(ColumnsMockTest, TestSQLColAttributeschema_name) { +TEST_F(ColumnsMockTest, TestSQLColAttributeSchemaName) { 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"")); + std::wstring value; + GetSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_SCHEMA_NAME, value); + ASSERT_EQ(std::wstring(L""), value); } -TEST_F(ColumnsRemoteTest, TestSQLColAttributeschema_name) { +TEST_F(ColumnsRemoteTest, TestSQLColAttributeSchemaName) { // Test assumes there is a table $scratch.ODBCTest in remote server 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"")); + std::wstring value; + GetSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_SCHEMA_NAME, value); + ASSERT_EQ(std::wstring(L""), value); } TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributesOwnerName) { @@ -2027,8 +2039,9 @@ TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributesOwnerName) { 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"")); + std::wstring value; + GetSQLColAttributesString(this->stmt, wsql, 1, SQL_COLUMN_OWNER_NAME, value); + ASSERT_EQ(std::wstring(L""), value); } TEST_F(ColumnsOdbcV2RemoteTest, TestSQLColAttributesOwnerName) { @@ -2037,52 +2050,56 @@ TEST_F(ColumnsOdbcV2RemoteTest, TestSQLColAttributesOwnerName) { 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"")); + std::wstring value; + GetSQLColAttributesString(this->stmt, wsql, 1, SQL_COLUMN_OWNER_NAME, value); + ASSERT_EQ(std::wstring(L""), value); } -TEST_F(ColumnsMockTest, TestSQLColAttributetable_name) { +TEST_F(ColumnsMockTest, TestSQLColAttributeTableName) { this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; - CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_TABLE_NAME, - std::wstring(L"AllTypesTable")); + std::wstring value; + GetSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_TABLE_NAME, value); + ASSERT_EQ(std::wstring(L"AllTypesTable"), value); } TEST_F(ColumnsMockTest, TestSQLColAttributeTypeName) { this->CreateTableAllDataType(); std::wstring wsql = L"SELECT * from AllTypesTable;"; - CheckSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_TYPE_NAME, - std::wstring(L"BIGINT")); - CheckSQLColAttributeString(this->stmt, L"", 2, SQL_DESC_TYPE_NAME, - std::wstring(L"WVARCHAR")); - CheckSQLColAttributeString(this->stmt, L"", 3, SQL_DESC_TYPE_NAME, - std::wstring(L"BINARY")); - CheckSQLColAttributeString(this->stmt, L"", 4, SQL_DESC_TYPE_NAME, - std::wstring(L"DOUBLE")); + std::wstring value; + GetSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"BIGINT"), value); + GetSQLColAttributeString(this->stmt, L"", 2, SQL_DESC_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"WVARCHAR"), value); + GetSQLColAttributeString(this->stmt, L"", 3, SQL_DESC_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"BINARY"), value); + GetSQLColAttributeString(this->stmt, L"", 4, SQL_DESC_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"DOUBLE"), value); } 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")); - CheckSQLColAttributeString(this->stmt, L"", 2, SQL_DESC_TYPE_NAME, - std::wstring(L"BIGINT")); - CheckSQLColAttributeString(this->stmt, L"", 3, SQL_DESC_TYPE_NAME, - std::wstring(L"DECIMAL")); - CheckSQLColAttributeString(this->stmt, L"", 4, SQL_DESC_TYPE_NAME, - std::wstring(L"FLOAT")); - CheckSQLColAttributeString(this->stmt, L"", 5, SQL_DESC_TYPE_NAME, - std::wstring(L"DOUBLE")); - CheckSQLColAttributeString(this->stmt, L"", 6, SQL_DESC_TYPE_NAME, - std::wstring(L"BOOLEAN")); - CheckSQLColAttributeString(this->stmt, L"", 7, SQL_DESC_TYPE_NAME, - std::wstring(L"DATE")); - CheckSQLColAttributeString(this->stmt, L"", 8, SQL_DESC_TYPE_NAME, - std::wstring(L"TIME")); - CheckSQLColAttributeString(this->stmt, L"", 9, SQL_DESC_TYPE_NAME, - std::wstring(L"TIMESTAMP")); + std::wstring value; + GetSQLColAttributeString(this->stmt, wsql, 1, SQL_DESC_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"INTEGER"), value); + GetSQLColAttributeString(this->stmt, L"", 2, SQL_DESC_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"BIGINT"), value); + GetSQLColAttributeString(this->stmt, L"", 3, SQL_DESC_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"DECIMAL"), value); + GetSQLColAttributeString(this->stmt, L"", 4, SQL_DESC_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"FLOAT"), value); + GetSQLColAttributeString(this->stmt, L"", 5, SQL_DESC_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"DOUBLE"), value); + GetSQLColAttributeString(this->stmt, L"", 6, SQL_DESC_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"BOOLEAN"), value); + GetSQLColAttributeString(this->stmt, L"", 7, SQL_DESC_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"DATE"), value); + GetSQLColAttributeString(this->stmt, L"", 8, SQL_DESC_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"TIME"), value); + GetSQLColAttributeString(this->stmt, L"", 9, SQL_DESC_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"TIMESTAMP"), value); } TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributesTypeName) { @@ -2091,57 +2108,63 @@ TEST_F(ColumnsOdbcV2MockTest, TestSQLColAttributesTypeName) { std::wstring wsql = L"SELECT * from AllTypesTable;"; // Mock server doesn't return data source-dependent data type name - CheckSQLColAttributesString(this->stmt, wsql, 1, SQL_COLUMN_TYPE_NAME, - std::wstring(L"BIGINT")); - CheckSQLColAttributesString(this->stmt, L"", 2, SQL_COLUMN_TYPE_NAME, - std::wstring(L"WVARCHAR")); - CheckSQLColAttributesString(this->stmt, L"", 3, SQL_COLUMN_TYPE_NAME, - std::wstring(L"BINARY")); - CheckSQLColAttributesString(this->stmt, L"", 4, SQL_COLUMN_TYPE_NAME, - std::wstring(L"DOUBLE")); + std::wstring value; + GetSQLColAttributesString(this->stmt, wsql, 1, SQL_COLUMN_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"BIGINT"), value); + GetSQLColAttributesString(this->stmt, L"", 2, SQL_COLUMN_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"WVARCHAR"), value); + GetSQLColAttributesString(this->stmt, L"", 3, SQL_COLUMN_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"BINARY"), value); + GetSQLColAttributesString(this->stmt, L"", 4, SQL_COLUMN_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"DOUBLE"), value); } TEST_F(ColumnsOdbcV2RemoteTest, TestSQLColAttributesTypeName) { // Tests ODBC 2.0 API SQLColAttributes std::wstring wsql = L"SELECT * from $scratch.ODBCTest;"; - CheckSQLColAttributesString(this->stmt, wsql, 1, SQL_COLUMN_TYPE_NAME, - std::wstring(L"INTEGER")); - CheckSQLColAttributesString(this->stmt, L"", 2, SQL_COLUMN_TYPE_NAME, - std::wstring(L"BIGINT")); - CheckSQLColAttributesString(this->stmt, L"", 3, SQL_COLUMN_TYPE_NAME, - std::wstring(L"DECIMAL")); - CheckSQLColAttributesString(this->stmt, L"", 4, SQL_COLUMN_TYPE_NAME, - std::wstring(L"FLOAT")); - CheckSQLColAttributesString(this->stmt, L"", 5, SQL_COLUMN_TYPE_NAME, - std::wstring(L"DOUBLE")); - CheckSQLColAttributesString(this->stmt, L"", 6, SQL_COLUMN_TYPE_NAME, - std::wstring(L"BOOLEAN")); - CheckSQLColAttributesString(this->stmt, L"", 7, SQL_COLUMN_TYPE_NAME, - std::wstring(L"DATE")); - CheckSQLColAttributesString(this->stmt, L"", 8, SQL_COLUMN_TYPE_NAME, - std::wstring(L"TIME")); - CheckSQLColAttributesString(this->stmt, L"", 9, SQL_COLUMN_TYPE_NAME, - std::wstring(L"TIMESTAMP")); + std::wstring value; + GetSQLColAttributesString(this->stmt, wsql, 1, SQL_COLUMN_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"INTEGER"), value); + GetSQLColAttributesString(this->stmt, L"", 2, SQL_COLUMN_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"BIGINT"), value); + GetSQLColAttributesString(this->stmt, L"", 3, SQL_COLUMN_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"DECIMAL"), value); + GetSQLColAttributesString(this->stmt, L"", 4, SQL_COLUMN_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"FLOAT"), value); + GetSQLColAttributesString(this->stmt, L"", 5, SQL_COLUMN_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"DOUBLE"), value); + GetSQLColAttributesString(this->stmt, L"", 6, SQL_COLUMN_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"BOOLEAN"), value); + GetSQLColAttributesString(this->stmt, L"", 7, SQL_COLUMN_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"DATE"), value); + GetSQLColAttributesString(this->stmt, L"", 8, SQL_COLUMN_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"TIME"), value); + GetSQLColAttributesString(this->stmt, L"", 9, SQL_COLUMN_TYPE_NAME, value); + ASSERT_EQ(std::wstring(L"TIMESTAMP"), value); } TYPED_TEST(ColumnsTest, TestSQLColAttributeUnnamed) { std::wstring wsql = this->GetQueryAllDataTypes(); - CheckSQLColAttributeNumeric(this->stmt, wsql, 1, SQL_DESC_UNNAMED, SQL_NAMED); + SQLLEN value; + GetSQLColAttributeNumeric(this->stmt, wsql, 1, SQL_DESC_UNNAMED, &value); + ASSERT_EQ(SQL_NAMED, value); } 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); + SQLLEN value; + GetSQLColAttributeNumeric(this->stmt, wsql, 1, SQL_DESC_UPDATABLE, &value); + ASSERT_EQ(SQL_ATTR_READWRITE_UNKNOWN, value); } TYPED_TEST(ColumnsOdbcV2Test, TestSQLColAttributesUpdatable) { // Tests ODBC 2.0 API SQLColAttributes 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); + SQLLEN value; + GetSQLColAttributesNumeric(this->stmt, wsql, 1, SQL_COLUMN_UPDATABLE, &value); + ASSERT_EQ(SQL_ATTR_READWRITE_UNKNOWN, value); } TEST_F(ColumnsMockTest, SQLDescribeColValidateInput) { 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 d241510cea39..878d8d3d5084 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 @@ -36,127 +36,90 @@ TYPED_TEST_SUITE(ConnectionInfoTest, TestTypes); namespace { // Helper Functions -// Validate unsigned short SQLUSMALLINT return value -void Validate(SQLHDBC connection, SQLUSMALLINT info_type, SQLUSMALLINT expected_value) { - SQLUSMALLINT info_value; +// Get SQLUSMALLINT return value +void GetInfo(SQLHDBC connection, SQLUSMALLINT info_type, SQLUSMALLINT* value) { SQLSMALLINT message_length; - ASSERT_EQ(SQL_SUCCESS, - SQLGetInfo(connection, info_type, &info_value, 0, &message_length)); - - EXPECT_EQ(expected_value, info_value); -} - -// Validate unsigned long SQLUINTEGER return value -void Validate(SQLHDBC connection, SQLUSMALLINT info_type, SQLUINTEGER expected_value) { - SQLUINTEGER info_value; - SQLSMALLINT message_length; - - ASSERT_EQ(SQL_SUCCESS, - SQLGetInfo(connection, info_type, &info_value, 0, &message_length)); - - EXPECT_EQ(expected_value, info_value); -} - -// Validate unsigned length SQLULEN return value -void Validate(SQLHDBC connection, SQLUSMALLINT info_type, SQLULEN expected_value) { - SQLULEN info_value; - SQLSMALLINT message_length; - - ASSERT_EQ(SQL_SUCCESS, - SQLGetInfo(connection, info_type, &info_value, 0, &message_length)); - - EXPECT_EQ(expected_value, info_value); + ASSERT_EQ(SQL_SUCCESS, SQLGetInfo(connection, info_type, value, 0, &message_length)); } -// Validate wchar string SQLWCHAR return value -void Validate(SQLHDBC connection, SQLUSMALLINT info_type, - const SQLWCHAR* expected_value) { - SQLWCHAR info_value[kOdbcBufferSize] = L""; +// Get SQLUINTEGER return value +void GetInfo(SQLHDBC connection, SQLUSMALLINT info_type, SQLUINTEGER* value) { SQLSMALLINT message_length; - ASSERT_EQ(SQL_SUCCESS, SQLGetInfo(connection, info_type, info_value, kOdbcBufferSize, - &message_length)); - - EXPECT_EQ(*expected_value, *info_value); + ASSERT_EQ(SQL_SUCCESS, SQLGetInfo(connection, info_type, value, 0, &message_length)); } -// Validate unsigned long SQLUINTEGER return value is greater than -void ValidateGreaterThan(SQLHDBC connection, SQLUSMALLINT info_type, - SQLUINTEGER compared_value) { - SQLUINTEGER info_value; +// Get SQLULEN return value +void GetInfo(SQLHDBC connection, SQLUSMALLINT info_type, SQLULEN* value) { SQLSMALLINT message_length; - ASSERT_EQ(SQL_SUCCESS, - SQLGetInfo(connection, info_type, &info_value, 0, &message_length)); - - EXPECT_GT(info_value, compared_value); + ASSERT_EQ(SQL_SUCCESS, SQLGetInfo(connection, info_type, value, 0, &message_length)); } -// Validate unsigned length SQLULEN return value is greater than -void ValidateGreaterThan(SQLHDBC connection, SQLUSMALLINT info_type, - SQLULEN compared_value) { - SQLULEN info_value; +// Get SQLWCHAR return value +void GetInfo(SQLHDBC connection, SQLUSMALLINT info_type, SQLWCHAR* value, + SQLSMALLINT buf_len = kOdbcBufferSize) { SQLSMALLINT message_length; ASSERT_EQ(SQL_SUCCESS, - SQLGetInfo(connection, info_type, &info_value, 0, &message_length)); - - EXPECT_GT(info_value, compared_value); -} - -// Validate wchar string SQLWCHAR return value is not empty -void ValidateNotEmptySQLWCHAR(SQLHDBC connection, SQLUSMALLINT info_type, - bool allow_truncation) { - SQLWCHAR info_value[kOdbcBufferSize] = L""; - SQLSMALLINT message_length; - - SQLRETURN ret = - SQLGetInfo(connection, info_type, info_value, kOdbcBufferSize, &message_length); - if (allow_truncation && ret == SQL_SUCCESS_WITH_INFO) { - ASSERT_EQ(SQL_SUCCESS_WITH_INFO, ret); - } else { - ASSERT_EQ(SQL_SUCCESS, ret); - } - - EXPECT_GT(wcslen(info_value), 0); + SQLGetInfo(connection, info_type, value, buf_len, &message_length)); } } // namespace // Driver Information TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoActiveEnvironments) { - Validate(this->conn, SQL_ACTIVE_ENVIRONMENTS, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_ACTIVE_ENVIRONMENTS, &value); + + EXPECT_EQ(static_cast(0), value); } #ifdef SQL_ASYNC_DBC_FUNCTIONS TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAsyncDbcFunctions) { - Validate(this->conn, SQL_ASYNC_DBC_FUNCTIONS, - static_cast(SQL_ASYNC_DBC_NOT_CAPABLE)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_ASYNC_DBC_FUNCTIONS, &value); + + EXPECT_EQ(static_cast(SQL_ASYNC_DBC_NOT_CAPABLE), value); } #endif TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAsyncMode) { - Validate(this->conn, SQL_ASYNC_MODE, static_cast(SQL_AM_NONE)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_ASYNC_MODE, &value); + + EXPECT_EQ(static_cast(SQL_AM_NONE), value); } #ifdef SQL_ASYNC_NOTIFICATION TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAsyncNotification) { - Validate(this->conn, SQL_ASYNC_NOTIFICATION, - static_cast(SQL_ASYNC_NOTIFICATION_NOT_CAPABLE)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_ASYNC_NOTIFICATION, &value); + + EXPECT_EQ(static_cast(SQL_ASYNC_NOTIFICATION_NOT_CAPABLE), value); } #endif TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoBatchRowCount) { - Validate(this->conn, SQL_BATCH_ROW_COUNT, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_BATCH_ROW_COUNT, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoBatchSupport) { - Validate(this->conn, SQL_BATCH_SUPPORT, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_BATCH_SUPPORT, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDataSourceName) { - Validate(this->conn, SQL_DATA_SOURCE_NAME, static_cast(L"")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_DATA_SOURCE_NAME, value); + + EXPECT_STREQ(static_cast(L""), value); } #ifdef SQL_DRIVER_AWARE_POOLING_SUPPORTED @@ -165,15 +128,20 @@ TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverAwarePoolingSupported) { // SQL_DRIVER_AWARE_POOLING_SUPPORTED and the Driver Manager will ignore the // driver's return value for it. - Validate(this->conn, SQL_DRIVER_AWARE_POOLING_SUPPORTED, - static_cast(SQL_DRIVER_AWARE_POOLING_NOT_CAPABLE)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_DRIVER_AWARE_POOLING_SUPPORTED, &value); + + EXPECT_EQ(static_cast(SQL_DRIVER_AWARE_POOLING_NOT_CAPABLE), value); } #endif // These information types are implemented by the Driver Manager alone. TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverHdbc) { // Value returned from driver manager is the connection address - ValidateGreaterThan(this->conn, SQL_DRIVER_HDBC, static_cast(0)); + SQLULEN value; + GetInfo(this->conn, SQL_DRIVER_HDBC, &value); + + EXPECT_GT(value, static_cast(0)); } // These information types are implemented by the Driver Manager alone. @@ -195,12 +163,18 @@ TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverHdesc) { // These information types are implemented by the Driver Manager alone. TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverHenv) { // Value returned from driver manager is the env address - ValidateGreaterThan(this->conn, SQL_DRIVER_HENV, static_cast(0)); + SQLULEN value; + GetInfo(this->conn, SQL_DRIVER_HENV, &value); + + EXPECT_GT(value, static_cast(0)); } // These information types are implemented by the Driver Manager alone. TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverHlib) { - ValidateGreaterThan(this->conn, SQL_DRIVER_HLIB, static_cast(0)); + SQLULEN value; + GetInfo(this->conn, SQL_DRIVER_HLIB, &value); + + EXPECT_GT(value, static_cast(0)); } // These information types are implemented by the Driver Manager alone. @@ -212,653 +186,1040 @@ TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverHstmt) { } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverName) { - Validate(this->conn, SQL_DRIVER_NAME, - static_cast(L"Arrow Flight ODBC Driver")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_DRIVER_NAME, value); + + EXPECT_STREQ(static_cast(L"Arrow Flight ODBC Driver"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverOdbcVer) { - Validate(this->conn, SQL_DRIVER_ODBC_VER, static_cast(L"03.80")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_DRIVER_ODBC_VER, value); + + EXPECT_STREQ(static_cast(L"03.80"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDriverVer) { - Validate(this->conn, SQL_DRIVER_VER, static_cast(L"00.09.0000.0")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_DRIVER_VER, value); + + EXPECT_STREQ(static_cast(L"00.09.0000.0"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDynamicCursorAttributes1) { - Validate(this->conn, SQL_DYNAMIC_CURSOR_ATTRIBUTES1, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_DYNAMIC_CURSOR_ATTRIBUTES1, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDynamicCursorAttributes2) { - Validate(this->conn, SQL_DYNAMIC_CURSOR_ATTRIBUTES2, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_DYNAMIC_CURSOR_ATTRIBUTES2, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoForwardOnlyCursorAttributes1) { - Validate(this->conn, SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1, - static_cast(SQL_CA1_NEXT)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1, &value); + + EXPECT_EQ(static_cast(SQL_CA1_NEXT), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoForwardOnlyCursorAttributes2) { - Validate(this->conn, SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2, - static_cast(SQL_CA2_READ_ONLY_CONCURRENCY)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2, &value); + + EXPECT_EQ(static_cast(SQL_CA2_READ_ONLY_CONCURRENCY), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoFileUsage) { - Validate(this->conn, SQL_FILE_USAGE, static_cast(SQL_FILE_NOT_SUPPORTED)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_FILE_USAGE, &value); + + EXPECT_EQ(static_cast(SQL_FILE_NOT_SUPPORTED), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoGetDataExtensions) { - Validate(this->conn, SQL_GETDATA_EXTENSIONS, - static_cast(SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_GETDATA_EXTENSIONS, &value); + + EXPECT_EQ(static_cast(SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoSchemaViews) { - Validate(this->conn, SQL_INFO_SCHEMA_VIEWS, - static_cast(SQL_ISV_TABLES | SQL_ISV_COLUMNS | SQL_ISV_VIEWS)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_INFO_SCHEMA_VIEWS, &value); + + EXPECT_EQ(static_cast(SQL_ISV_TABLES | SQL_ISV_COLUMNS | SQL_ISV_VIEWS), + value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoKeysetCursorAttributes1) { - Validate(this->conn, SQL_KEYSET_CURSOR_ATTRIBUTES1, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_KEYSET_CURSOR_ATTRIBUTES1, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoKeysetCursorAttributes2) { - Validate(this->conn, SQL_KEYSET_CURSOR_ATTRIBUTES2, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_KEYSET_CURSOR_ATTRIBUTES2, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxAsyncConcurrentStatements) { - Validate(this->conn, SQL_MAX_ASYNC_CONCURRENT_STATEMENTS, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_MAX_ASYNC_CONCURRENT_STATEMENTS, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxConcurrentActivities) { - Validate(this->conn, SQL_MAX_CONCURRENT_ACTIVITIES, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_CONCURRENT_ACTIVITIES, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxDriverConnections) { - Validate(this->conn, SQL_MAX_DRIVER_CONNECTIONS, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_DRIVER_CONNECTIONS, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoOdbcInterfaceConformance) { - Validate(this->conn, SQL_ODBC_INTERFACE_CONFORMANCE, - static_cast(SQL_OIC_CORE)); -} + SQLUINTEGER value; + GetInfo(this->conn, SQL_ODBC_INTERFACE_CONFORMANCE, &value); -// case SQL_ODBC_STANDARD_CLI_CONFORMANCE: - mentioned in SQLGetInfo spec with no -// description and there is no constant for this. -TYPED_TEST(ConnectionInfoTest, DISABLED_TestSQLGetInfoOdbcStandardCliConformance) { - // Type commented out in odbc_connection.cc - // Type does not exist in sql.h - // Validate(this->conn, SQL_ODBC_STANDARD_CLI_CONFORMANCE, - // static_cast(0)); + EXPECT_EQ(static_cast(SQL_OIC_CORE), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoOdbcVer) { // This is implemented only in the Driver Manager. - Validate(this->conn, SQL_ODBC_VER, static_cast(L"03.80.0000")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_ODBC_VER, value); + + EXPECT_STREQ(static_cast(L"03.80.0000"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoParamArrayRowCounts) { - Validate(this->conn, SQL_PARAM_ARRAY_ROW_COUNTS, - static_cast(SQL_PARC_NO_BATCH)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_PARAM_ARRAY_ROW_COUNTS, &value); + + EXPECT_EQ(static_cast(SQL_PARC_NO_BATCH), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoParamArraySelects) { - Validate(this->conn, SQL_PARAM_ARRAY_SELECTS, - static_cast(SQL_PAS_NO_SELECT)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_PARAM_ARRAY_SELECTS, &value); + + EXPECT_EQ(static_cast(SQL_PAS_NO_SELECT), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoRowUpdates) { - Validate(this->conn, SQL_ROW_UPDATES, static_cast(L"N")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_ROW_UPDATES, value); + + EXPECT_STREQ(static_cast(L"N"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoSearchPatternEscape) { - Validate(this->conn, SQL_SEARCH_PATTERN_ESCAPE, static_cast(L"\\")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_SEARCH_PATTERN_ESCAPE, value); + + EXPECT_STREQ(static_cast(L"\\"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoServerName) { - ValidateNotEmptySQLWCHAR(this->conn, SQL_SERVER_NAME, false); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_SERVER_NAME, value); + + EXPECT_GT(wcslen(value), 0); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoStaticCursorAttributes1) { - Validate(this->conn, SQL_STATIC_CURSOR_ATTRIBUTES1, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_STATIC_CURSOR_ATTRIBUTES1, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoStaticCursorAttributes2) { - Validate(this->conn, SQL_STATIC_CURSOR_ATTRIBUTES2, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_STATIC_CURSOR_ATTRIBUTES2, &value); + + EXPECT_EQ(static_cast(0), value); } // DBMS Product Information TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDatabaseName) { - Validate(this->conn, SQL_DATABASE_NAME, static_cast(L"")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_DATABASE_NAME, value); + + EXPECT_STREQ(static_cast(L""), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDbmsName) { - ValidateNotEmptySQLWCHAR(this->conn, SQL_DBMS_NAME, false); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_DBMS_NAME, value); + + EXPECT_GT(wcslen(value), 0); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDbmsVer) { - ValidateNotEmptySQLWCHAR(this->conn, SQL_DBMS_VER, false); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_DBMS_VER, value); + + EXPECT_GT(wcslen(value), 0); } // Data Source Information TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAccessibleProcedures) { - Validate(this->conn, SQL_ACCESSIBLE_PROCEDURES, static_cast(L"N")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_ACCESSIBLE_PROCEDURES, value); + + EXPECT_STREQ(static_cast(L"N"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAccessibleTables) { - Validate(this->conn, SQL_ACCESSIBLE_TABLES, static_cast(L"Y")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_ACCESSIBLE_TABLES, value); + + EXPECT_STREQ(static_cast(L"Y"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoBookmarkPersistence) { - Validate(this->conn, SQL_BOOKMARK_PERSISTENCE, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_BOOKMARK_PERSISTENCE, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCatalogTerm) { - Validate(this->conn, SQL_CATALOG_TERM, static_cast(L"")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_CATALOG_TERM, value); + + EXPECT_STREQ(static_cast(L""), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCollationSeq) { - Validate(this->conn, SQL_COLLATION_SEQ, static_cast(L"")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_COLLATION_SEQ, value); + + EXPECT_STREQ(static_cast(L""), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConcatNullBehavior) { - Validate(this->conn, SQL_CONCAT_NULL_BEHAVIOR, static_cast(SQL_CB_NULL)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_CONCAT_NULL_BEHAVIOR, &value); + + EXPECT_EQ(static_cast(SQL_CB_NULL), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCursorCommitBehavior) { - Validate(this->conn, SQL_CURSOR_COMMIT_BEHAVIOR, - static_cast(SQL_CB_CLOSE)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_CURSOR_COMMIT_BEHAVIOR, &value); + + EXPECT_EQ(static_cast(SQL_CB_CLOSE), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCursorRollbackBehavior) { - Validate(this->conn, SQL_CURSOR_ROLLBACK_BEHAVIOR, - static_cast(SQL_CB_CLOSE)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_CURSOR_ROLLBACK_BEHAVIOR, &value); + + EXPECT_EQ(static_cast(SQL_CB_CLOSE), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCursorSensitivity) { - Validate(this->conn, SQL_CURSOR_SENSITIVITY, static_cast(SQL_UNSPECIFIED)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CURSOR_SENSITIVITY, &value); + + EXPECT_EQ(static_cast(SQL_UNSPECIFIED), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDataSourceReadOnly) { - Validate(this->conn, SQL_DATA_SOURCE_READ_ONLY, static_cast(L"N")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_DATA_SOURCE_READ_ONLY, value); + + EXPECT_STREQ(static_cast(L"N"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDefaultTxnIsolation) { - Validate(this->conn, SQL_DEFAULT_TXN_ISOLATION, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_DEFAULT_TXN_ISOLATION, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDescribeParameter) { - Validate(this->conn, SQL_DESCRIBE_PARAMETER, static_cast(L"N")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_DESCRIBE_PARAMETER, value); + + EXPECT_STREQ(static_cast(L"N"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMultResultSets) { - Validate(this->conn, SQL_MULT_RESULT_SETS, static_cast(L"N")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_MULT_RESULT_SETS, value); + + EXPECT_STREQ(static_cast(L"N"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMultipleActiveTxn) { - Validate(this->conn, SQL_MULTIPLE_ACTIVE_TXN, static_cast(L"N")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_MULTIPLE_ACTIVE_TXN, value); + + EXPECT_STREQ(static_cast(L"N"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoNeedLongDataLen) { - Validate(this->conn, SQL_NEED_LONG_DATA_LEN, static_cast(L"N")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_NEED_LONG_DATA_LEN, value); + + EXPECT_STREQ(static_cast(L"N"), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoNullCollation) { - Validate(this->conn, SQL_NULL_COLLATION, static_cast(SQL_NC_START)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_NULL_COLLATION, &value); + EXPECT_EQ(static_cast(SQL_NC_START), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoProcedureTerm) { - Validate(this->conn, SQL_PROCEDURE_TERM, static_cast(L"")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_PROCEDURE_TERM, value); + + EXPECT_STREQ(static_cast(L""), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoSchemaTerm) { - Validate(this->conn, SQL_SCHEMA_TERM, static_cast(L"schema")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_SCHEMA_TERM, value); + + EXPECT_STREQ(static_cast(L"schema"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoScrollOptions) { - Validate(this->conn, SQL_SCROLL_OPTIONS, static_cast(SQL_SO_FORWARD_ONLY)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_SCROLL_OPTIONS, &value); + + EXPECT_EQ(static_cast(SQL_SO_FORWARD_ONLY), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoTableTerm) { - Validate(this->conn, SQL_TABLE_TERM, static_cast(L"table")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_TABLE_TERM, value); + + EXPECT_STREQ(static_cast(L"table"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoTxnCapable) { - Validate(this->conn, SQL_TXN_CAPABLE, static_cast(SQL_TC_NONE)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_TXN_CAPABLE, &value); + + EXPECT_EQ(static_cast(SQL_TC_NONE), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoTxnIsolationOption) { - Validate(this->conn, SQL_TXN_ISOLATION_OPTION, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_TXN_ISOLATION_OPTION, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoUserName) { - Validate(this->conn, SQL_USER_NAME, static_cast(L"")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_USER_NAME, value); + + EXPECT_STREQ(static_cast(L""), value); } // Supported SQL 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)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_AGGREGATE_FUNCTIONS, &value); + + EXPECT_EQ(value, static_cast(SQL_AF_ALL | SQL_AF_AVG | SQL_AF_COUNT | + SQL_AF_DISTINCT | SQL_AF_MAX | SQL_AF_MIN | + SQL_AF_SUM)); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAlterDomain) { - Validate(this->conn, SQL_ALTER_DOMAIN, static_cast(0)); -} + SQLUINTEGER value; + GetInfo(this->conn, SQL_ALTER_DOMAIN, &value); -TYPED_TEST(ConnectionInfoTest, DISABLED_TestSQLGetInfoAlterSchema) { - // Type commented out in odbc_connection.cc - // Type does not exist in sql.h - // Validate(this->conn, SQL_ALTER_SCHEMA, static_cast(0)); + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoAlterTable) { - Validate(this->conn, SQL_ALTER_TABLE, static_cast(0)); -} + SQLUINTEGER value; + GetInfo(this->conn, SQL_ALTER_TABLE, &value); -TYPED_TEST(ConnectionInfoTest, DISABLED_TestSQLGetInfoAnsiSqlDatetimeLiterals) { - // Type commented out in odbc_connection.cc - // Type does not exist in sql.h - // Validate(this->conn, SQL_ANSI_SQL_DATETIME_LITERALS, static_cast(L"")); + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCatalogLocation) { - Validate(this->conn, SQL_CATALOG_LOCATION, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_CATALOG_LOCATION, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCatalogName) { - Validate(this->conn, SQL_CATALOG_NAME, static_cast(L"N")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_CATALOG_NAME, value); + + EXPECT_STREQ(static_cast(L"N"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCatalogNameSeparator) { - Validate(this->conn, SQL_CATALOG_NAME_SEPARATOR, static_cast(L"")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_CATALOG_NAME_SEPARATOR, value); + + EXPECT_STREQ(static_cast(L""), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoCatalogUsage) { - Validate(this->conn, SQL_CATALOG_USAGE, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CATALOG_USAGE, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoColumnAlias) { - Validate(this->conn, SQL_COLUMN_ALIAS, static_cast(L"Y")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_COLUMN_ALIAS, value); + + EXPECT_STREQ(static_cast(L"Y"), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoCorrelationName) { - Validate(this->conn, SQL_CORRELATION_NAME, static_cast(SQL_CN_NONE)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_CORRELATION_NAME, &value); + + EXPECT_EQ(static_cast(SQL_CN_NONE), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCreateAssertion) { - Validate(this->conn, SQL_CREATE_ASSERTION, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CREATE_ASSERTION, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCreateCharacterSet) { - Validate(this->conn, SQL_CREATE_CHARACTER_SET, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CREATE_CHARACTER_SET, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCreateCollation) { - Validate(this->conn, SQL_CREATE_COLLATION, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CREATE_COLLATION, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCreateDomain) { - Validate(this->conn, SQL_CREATE_DOMAIN, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CREATE_DOMAIN, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoCreateSchema) { - Validate(this->conn, SQL_CREATE_SCHEMA, static_cast(1)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CREATE_SCHEMA, &value); + + EXPECT_EQ(static_cast(1), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoCreateTable) { - Validate(this->conn, SQL_CREATE_TABLE, static_cast(1)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CREATE_TABLE, &value); + + EXPECT_EQ(static_cast(1), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoCreateTranslation) { - Validate(this->conn, SQL_CREATE_TRANSLATION, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CREATE_TRANSLATION, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDdlIndex) { - Validate(this->conn, SQL_DDL_INDEX, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_DDL_INDEX, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropAssertion) { - Validate(this->conn, SQL_DROP_ASSERTION, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_DROP_ASSERTION, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropCharacterSet) { - Validate(this->conn, SQL_DROP_CHARACTER_SET, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_DROP_CHARACTER_SET, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropCollation) { - Validate(this->conn, SQL_DROP_COLLATION, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_DROP_COLLATION, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropDomain) { - Validate(this->conn, SQL_DROP_DOMAIN, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_DROP_DOMAIN, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropSchema) { - Validate(this->conn, SQL_DROP_SCHEMA, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_DROP_SCHEMA, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropTable) { - Validate(this->conn, SQL_DROP_TABLE, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_DROP_TABLE, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropTranslation) { - Validate(this->conn, SQL_DROP_TRANSLATION, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_DROP_TRANSLATION, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoDropView) { - Validate(this->conn, SQL_DROP_VIEW, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_DROP_VIEW, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoExpressionsInOrderby) { - Validate(this->conn, SQL_EXPRESSIONS_IN_ORDERBY, static_cast(L"N")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_EXPRESSIONS_IN_ORDERBY, value); + + EXPECT_STREQ(static_cast(L"N"), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoGroupBy) { - Validate(this->conn, SQL_GROUP_BY, - static_cast(SQL_GB_GROUP_BY_CONTAINS_SELECT)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_GROUP_BY, &value); + + EXPECT_EQ(static_cast(SQL_GB_GROUP_BY_CONTAINS_SELECT), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoIdentifierCase) { - Validate(this->conn, SQL_IDENTIFIER_CASE, static_cast(SQL_IC_MIXED)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_IDENTIFIER_CASE, &value); + + EXPECT_EQ(static_cast(SQL_IC_MIXED), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoIdentifierQuoteChar) { - Validate(this->conn, SQL_IDENTIFIER_QUOTE_CHAR, static_cast(L"\")")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_IDENTIFIER_QUOTE_CHAR, value); + + EXPECT_STREQ(static_cast(L"\""), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoIndexKeywords) { - Validate(this->conn, SQL_INDEX_KEYWORDS, static_cast(SQL_IK_NONE)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_INDEX_KEYWORDS, &value); + + EXPECT_EQ(static_cast(SQL_IK_NONE), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoInsertStatement) { - Validate(this->conn, SQL_INSERT_STATEMENT, - static_cast(SQL_IS_INSERT_LITERALS | SQL_IS_INSERT_SEARCHED | - SQL_IS_SELECT_INTO)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_INSERT_STATEMENT, &value); + + EXPECT_EQ(value, static_cast(SQL_IS_INSERT_LITERALS | + SQL_IS_INSERT_SEARCHED | SQL_IS_SELECT_INTO)); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoIntegrity) { - Validate(this->conn, SQL_INTEGRITY, static_cast(L"N")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_INTEGRITY, value); + + EXPECT_STREQ(static_cast(L"N"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoKeywords) { - ValidateNotEmptySQLWCHAR(this->conn, SQL_KEYWORDS, true); + // Keyword strings can require 5000 buffer length + static constexpr int info_len = kOdbcBufferSize * 5; + SQLWCHAR value[info_len] = L""; + GetInfo(this->conn, SQL_KEYWORDS, value, info_len); + + EXPECT_GT(wcslen(value), 0); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoLikeEscapeClause) { - Validate(this->conn, SQL_LIKE_ESCAPE_CLAUSE, static_cast(L"Y")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_LIKE_ESCAPE_CLAUSE, value); + + EXPECT_STREQ(static_cast(L"Y"), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoNonNullableColumns) { - Validate(this->conn, SQL_NON_NULLABLE_COLUMNS, static_cast(SQL_NNC_NULL)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_NON_NULLABLE_COLUMNS, &value); + + EXPECT_EQ(static_cast(SQL_NNC_NULL), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoOjCapabilities) { - Validate(this->conn, SQL_OJ_CAPABILITIES, - static_cast(SQL_OJ_LEFT | SQL_OJ_RIGHT | SQL_OJ_FULL)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_OJ_CAPABILITIES, &value); + + EXPECT_EQ(static_cast(SQL_OJ_LEFT | SQL_OJ_RIGHT | SQL_OJ_FULL), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoOrderByColumnsInSelect) { - Validate(this->conn, SQL_ORDER_BY_COLUMNS_IN_SELECT, - static_cast(L"Y")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_ORDER_BY_COLUMNS_IN_SELECT, value); + + EXPECT_STREQ(static_cast(L"Y"), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoOuterJoins) { - Validate(this->conn, SQL_OUTER_JOINS, static_cast(L"N")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_OUTER_JOINS, value); + + EXPECT_STREQ(static_cast(L"N"), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoProcedures) { - Validate(this->conn, SQL_PROCEDURES, static_cast(L"N")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_PROCEDURES, value); + + EXPECT_STREQ(static_cast(L"N"), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoQuotedIdentifierCase) { - Validate(this->conn, SQL_QUOTED_IDENTIFIER_CASE, - static_cast(SQL_IC_MIXED)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_QUOTED_IDENTIFIER_CASE, &value); + + EXPECT_EQ(static_cast(SQL_IC_MIXED), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoSchemaUsage) { - Validate(this->conn, SQL_SCHEMA_USAGE, static_cast(SQL_SU_DML_STATEMENTS)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_SCHEMA_USAGE, &value); + + EXPECT_EQ(static_cast(SQL_SU_DML_STATEMENTS), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoSpecialCharacters) { - Validate(this->conn, SQL_SPECIAL_CHARACTERS, static_cast(L"")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_SPECIAL_CHARACTERS, value); + + EXPECT_STREQ(static_cast(L""), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoSqlConformance) { - Validate(this->conn, SQL_SQL_CONFORMANCE, static_cast(SQL_SC_SQL92_ENTRY)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_SQL_CONFORMANCE, &value); + + EXPECT_EQ(static_cast(SQL_SC_SQL92_ENTRY), value); } 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)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_SUBQUERIES, &value); + + EXPECT_EQ(value, + static_cast(SQL_SQ_CORRELATED_SUBQUERIES | SQL_SQ_COMPARISON | + SQL_SQ_EXISTS | SQL_SQ_IN | SQL_SQ_QUANTIFIED)); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoUnion) { - Validate(this->conn, SQL_UNION, - static_cast(SQL_U_UNION | SQL_U_UNION_ALL)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_UNION, &value); + + EXPECT_EQ(static_cast(SQL_U_UNION | SQL_U_UNION_ALL), value); } // SQL Limits TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxBinaryLiteralLen) { - Validate(this->conn, SQL_MAX_BINARY_LITERAL_LEN, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_MAX_BINARY_LITERAL_LEN, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoMaxCatalogNameLen) { - Validate(this->conn, SQL_MAX_CATALOG_NAME_LEN, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_CATALOG_NAME_LEN, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxCharLiteralLen) { - Validate(this->conn, SQL_MAX_CHAR_LITERAL_LEN, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_MAX_CHAR_LITERAL_LEN, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoMaxColumnNameLen) { - Validate(this->conn, SQL_MAX_COLUMN_NAME_LEN, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_COLUMN_NAME_LEN, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxColumnsInGroupBy) { - Validate(this->conn, SQL_MAX_COLUMNS_IN_GROUP_BY, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_COLUMNS_IN_GROUP_BY, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxColumnsInIndex) { - Validate(this->conn, SQL_MAX_COLUMNS_IN_INDEX, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_COLUMNS_IN_INDEX, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxColumnsInOrderBy) { - Validate(this->conn, SQL_MAX_COLUMNS_IN_ORDER_BY, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_COLUMNS_IN_ORDER_BY, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxColumnsInSelect) { - Validate(this->conn, SQL_MAX_COLUMNS_IN_SELECT, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_COLUMNS_IN_SELECT, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxColumnsInTable) { - Validate(this->conn, SQL_MAX_COLUMNS_IN_TABLE, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_COLUMNS_IN_TABLE, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoMaxCursorNameLen) { - Validate(this->conn, SQL_MAX_CURSOR_NAME_LEN, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_CURSOR_NAME_LEN, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxIdentifierLen) { - Validate(this->conn, SQL_MAX_IDENTIFIER_LEN, static_cast(65535)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_IDENTIFIER_LEN, &value); + + EXPECT_EQ(static_cast(65535), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxIndexSize) { - Validate(this->conn, SQL_MAX_INDEX_SIZE, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_MAX_INDEX_SIZE, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxProcedureNameLen) { - Validate(this->conn, SQL_MAX_PROCEDURE_NAME_LEN, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_PROCEDURE_NAME_LEN, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxRowSize) { - Validate(this->conn, SQL_MAX_ROW_SIZE, static_cast(L"")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_MAX_ROW_SIZE, value); + + EXPECT_STREQ(static_cast(L""), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoMaxRowSizeIncludesLong) { - Validate(this->conn, SQL_MAX_ROW_SIZE_INCLUDES_LONG, - static_cast(L"N")); + SQLWCHAR value[kOdbcBufferSize] = L""; + GetInfo(this->conn, SQL_MAX_ROW_SIZE_INCLUDES_LONG, value); + + EXPECT_STREQ(static_cast(L"N"), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoMaxSchemaNameLen) { - Validate(this->conn, SQL_MAX_SCHEMA_NAME_LEN, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_SCHEMA_NAME_LEN, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxStatementLen) { - Validate(this->conn, SQL_MAX_STATEMENT_LEN, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_MAX_STATEMENT_LEN, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoMaxTableNameLen) { - Validate(this->conn, SQL_MAX_TABLE_NAME_LEN, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_TABLE_NAME_LEN, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoMaxTablesInSelect) { - Validate(this->conn, SQL_MAX_TABLES_IN_SELECT, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_TABLES_IN_SELECT, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoMaxUserNameLen) { - Validate(this->conn, SQL_MAX_USER_NAME_LEN, static_cast(0)); + SQLUSMALLINT value; + GetInfo(this->conn, SQL_MAX_USER_NAME_LEN, &value); + + EXPECT_EQ(static_cast(0), value); } // Scalar Function Information TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertFunctions) { - Validate(this->conn, SQL_CONVERT_FUNCTIONS, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_FUNCTIONS, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoNumericFunctions) { - Validate(this->conn, SQL_NUMERIC_FUNCTIONS, static_cast(4058942)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_NUMERIC_FUNCTIONS, &value); + + EXPECT_EQ(static_cast(4058942), value); } 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)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_STRING_FUNCTIONS, &value); + + EXPECT_EQ(value, static_cast(SQL_FN_STR_LTRIM | SQL_FN_STR_LENGTH | + SQL_FN_STR_REPLACE | SQL_FN_STR_RTRIM)); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoSystemFunctions) { - Validate(this->conn, SQL_SYSTEM_FUNCTIONS, - static_cast(SQL_FN_SYS_IFNULL | SQL_FN_SYS_USERNAME)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_SYSTEM_FUNCTIONS, &value); + + EXPECT_EQ(static_cast(SQL_FN_SYS_IFNULL | SQL_FN_SYS_USERNAME), value); } 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)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_TIMEDATE_ADD_INTERVALS, &value); + + EXPECT_EQ(value, 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)); } 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)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_TIMEDATE_DIFF_INTERVALS, &value); + + EXPECT_EQ(value, 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)); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoTimedateFunctions) { - Validate(this->conn, SQL_TIMEDATE_FUNCTIONS, - static_cast( - SQL_FN_TD_CURRENT_DATE | SQL_FN_TD_CURRENT_TIME | - SQL_FN_TD_CURRENT_TIMESTAMP | SQL_FN_TD_CURDATE | SQL_FN_TD_CURTIME | - SQL_FN_TD_DAYNAME | SQL_FN_TD_DAYOFMONTH | SQL_FN_TD_DAYOFWEEK | - SQL_FN_TD_DAYOFYEAR | SQL_FN_TD_EXTRACT | SQL_FN_TD_HOUR | - 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)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_TIMEDATE_FUNCTIONS, &value); + + EXPECT_EQ(value, + static_cast( + SQL_FN_TD_CURRENT_DATE | SQL_FN_TD_CURRENT_TIME | + SQL_FN_TD_CURRENT_TIMESTAMP | SQL_FN_TD_CURDATE | SQL_FN_TD_CURTIME | + SQL_FN_TD_DAYNAME | SQL_FN_TD_DAYOFMONTH | SQL_FN_TD_DAYOFWEEK | + SQL_FN_TD_DAYOFYEAR | SQL_FN_TD_EXTRACT | SQL_FN_TD_HOUR | + 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)); } // Conversion Information TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertBigint) { - Validate(this->conn, SQL_CONVERT_BIGINT, static_cast(8)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_BIGINT, &value); + + EXPECT_EQ(static_cast(8), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertBinary) { - Validate(this->conn, SQL_CONVERT_BINARY, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_BINARY, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertBit) { - Validate(this->conn, SQL_CONVERT_BIT, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_BIT, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertChar) { - Validate(this->conn, SQL_CONVERT_CHAR, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_CHAR, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertDate) { - Validate(this->conn, SQL_CONVERT_DATE, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_DATE, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertDecimal) { - Validate(this->conn, SQL_CONVERT_DECIMAL, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_DECIMAL, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertDouble) { - Validate(this->conn, SQL_CONVERT_DOUBLE, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_DOUBLE, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertFloat) { - Validate(this->conn, SQL_CONVERT_FLOAT, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_FLOAT, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertInteger) { - Validate(this->conn, SQL_CONVERT_INTEGER, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_INTEGER, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertIntervalDayTime) { - Validate(this->conn, SQL_CONVERT_INTERVAL_DAY_TIME, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_INTERVAL_DAY_TIME, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertIntervalYearMonth) { - Validate(this->conn, SQL_CONVERT_INTERVAL_YEAR_MONTH, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_INTERVAL_YEAR_MONTH, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertLongvarbinary) { - Validate(this->conn, SQL_CONVERT_LONGVARBINARY, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_LONGVARBINARY, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertLongvarchar) { - Validate(this->conn, SQL_CONVERT_LONGVARCHAR, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_LONGVARCHAR, &value); + + EXPECT_EQ(static_cast(0), value); } TEST_F(ConnectionInfoMockTest, TestSQLGetInfoConvertNumeric) { - Validate(this->conn, SQL_CONVERT_NUMERIC, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_NUMERIC, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertReal) { - Validate(this->conn, SQL_CONVERT_REAL, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_REAL, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertSmallint) { - Validate(this->conn, SQL_CONVERT_SMALLINT, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_SMALLINT, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertTime) { - Validate(this->conn, SQL_CONVERT_TIME, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_TIME, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertTimestamp) { - Validate(this->conn, SQL_CONVERT_TIMESTAMP, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_TIMESTAMP, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertTinyint) { - Validate(this->conn, SQL_CONVERT_TINYINT, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_TINYINT, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertVarbinary) { - Validate(this->conn, SQL_CONVERT_VARBINARY, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_VARBINARY, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(ConnectionInfoTest, TestSQLGetInfoConvertVarchar) { - Validate(this->conn, SQL_CONVERT_VARCHAR, static_cast(0)); + SQLUINTEGER value; + GetInfo(this->conn, SQL_CONVERT_VARCHAR, &value); + + EXPECT_EQ(static_cast(0), value); } } // namespace arrow::flight::sql::odbc 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 85cb2e96b596..680349ac1400 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 @@ -39,52 +39,28 @@ TYPED_TEST_SUITE(StatementAttributeTest, TestTypes); namespace { // Helper Functions -// Validate SQLULEN return value -void ValidateGetStmtAttr(SQLHSTMT statement, SQLINTEGER attribute, - SQLULEN expected_value) { - SQLULEN value = 0; +// Get SQLULEN return value +void GetStmtAttr(SQLHSTMT statement, SQLINTEGER attribute, SQLULEN* value) { SQLINTEGER string_length = 0; ASSERT_EQ(SQL_SUCCESS, - SQLGetStmtAttr(statement, attribute, &value, sizeof(value), &string_length)); - - EXPECT_EQ(expected_value, value); + SQLGetStmtAttr(statement, attribute, value, sizeof(*value), &string_length)); } -// Validate SQLLEN return value -void ValidateGetStmtAttr(SQLHSTMT statement, SQLINTEGER attribute, - SQLLEN expected_value) { - SQLLEN value = 0; +// Get SQLLEN return value +void GetStmtAttr(SQLHSTMT statement, SQLINTEGER attribute, SQLLEN* value) { SQLINTEGER string_length = 0; ASSERT_EQ(SQL_SUCCESS, - SQLGetStmtAttr(statement, attribute, &value, sizeof(value), &string_length)); - - EXPECT_EQ(expected_value, value); + SQLGetStmtAttr(statement, attribute, value, sizeof(*value), &string_length)); } -// Validate SQLPOINTER return value -void ValidateGetStmtAttr(SQLHSTMT statement, SQLINTEGER attribute, - SQLPOINTER expected_value) { - SQLPOINTER value = nullptr; +// Get SQLPOINTER return value +void GetStmtAttr(SQLHSTMT statement, SQLINTEGER attribute, SQLPOINTER* value) { SQLINTEGER string_length = 0; ASSERT_EQ(SQL_SUCCESS, - SQLGetStmtAttr(statement, attribute, &value, sizeof(value), &string_length)); - - EXPECT_EQ(expected_value, value); -} - -// Validate unsigned length SQLULEN return value is greater than -void ValidateGetStmtAttrGreaterThan(SQLHSTMT statement, SQLINTEGER attribute, - SQLULEN compared_value) { - SQLULEN value = 0; - SQLINTEGER string_length_ptr; - - ASSERT_EQ(SQL_SUCCESS, - SQLGetStmtAttr(statement, attribute, &value, 0, &string_length_ptr)); - - EXPECT_GT(value, compared_value); + SQLGetStmtAttr(statement, attribute, value, SQL_IS_POINTER, &string_length)); } // Validate error return value and code @@ -138,18 +114,24 @@ void ValidateSetStmtAttrErrorCode(SQLHSTMT statement, SQLINTEGER attribute, // Test Cases TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrAppParamDesc) { - ValidateGetStmtAttrGreaterThan(this->stmt, SQL_ATTR_APP_PARAM_DESC, - static_cast(0)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_APP_PARAM_DESC, &value); + + EXPECT_GT(value, static_cast(0)); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrAppRowDesc) { - ValidateGetStmtAttrGreaterThan(this->stmt, SQL_ATTR_APP_ROW_DESC, - static_cast(0)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_APP_ROW_DESC, &value); + + EXPECT_GT(value, static_cast(0)); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrAsyncEnable) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_ASYNC_ENABLE, - static_cast(SQL_ASYNC_ENABLE_OFF)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_ASYNC_ENABLE, &value); + + EXPECT_EQ(static_cast(SQL_ASYNC_ENABLE_OFF), value); } #ifdef SQL_ATTR_ASYNC_STMT_EVENT @@ -176,113 +158,171 @@ TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrAsyncStmtPCContextUnsupport #endif TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrConcurrency) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_CONCURRENCY, - static_cast(SQL_CONCUR_READ_ONLY)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_CONCURRENCY, &value); + + EXPECT_EQ(static_cast(SQL_CONCUR_READ_ONLY), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrCursorScrollable) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_CURSOR_SCROLLABLE, - static_cast(SQL_NONSCROLLABLE)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_CURSOR_SCROLLABLE, &value); + + EXPECT_EQ(static_cast(SQL_NONSCROLLABLE), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrCursorSensitivity) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_CURSOR_SENSITIVITY, - static_cast(SQL_UNSPECIFIED)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_CURSOR_SENSITIVITY, &value); + + EXPECT_EQ(static_cast(SQL_UNSPECIFIED), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrCursorType) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_CURSOR_TYPE, - static_cast(SQL_CURSOR_FORWARD_ONLY)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_CURSOR_TYPE, &value); + + EXPECT_EQ(static_cast(SQL_CURSOR_FORWARD_ONLY), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrEnableAutoIPD) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_ENABLE_AUTO_IPD, - static_cast(SQL_FALSE)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_ENABLE_AUTO_IPD, &value); + + EXPECT_EQ(static_cast(SQL_FALSE), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrFetchBookmarkPointer) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_FETCH_BOOKMARK_PTR, static_cast(NULL)); + SQLLEN value; + GetStmtAttr(this->stmt, SQL_ATTR_FETCH_BOOKMARK_PTR, &value); + + EXPECT_EQ(static_cast(NULL), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrIMPParamDesc) { - ValidateGetStmtAttrGreaterThan(this->stmt, SQL_ATTR_IMP_PARAM_DESC, - static_cast(0)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_IMP_PARAM_DESC, &value); + + EXPECT_GT(value, static_cast(0)); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrIMPRowDesc) { - ValidateGetStmtAttrGreaterThan(this->stmt, SQL_ATTR_IMP_ROW_DESC, - static_cast(0)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_IMP_ROW_DESC, &value); + + EXPECT_GT(value, static_cast(0)); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrKeysetSize) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_KEYSET_SIZE, static_cast(0)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_KEYSET_SIZE, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrMaxLength) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_MAX_LENGTH, static_cast(0)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_MAX_LENGTH, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrMaxRows) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_MAX_ROWS, static_cast(0)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_MAX_ROWS, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrMetadataID) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_METADATA_ID, static_cast(SQL_FALSE)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_METADATA_ID, &value); + + EXPECT_EQ(static_cast(SQL_FALSE), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrNoscan) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_NOSCAN, static_cast(SQL_NOSCAN_OFF)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_NOSCAN, &value); + + EXPECT_EQ(static_cast(SQL_NOSCAN_OFF), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrParamBindOffsetPtr) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAM_BIND_OFFSET_PTR, - static_cast(nullptr)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_PARAM_BIND_OFFSET_PTR, &value); + + EXPECT_EQ(static_cast(nullptr), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrParamBindType) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAM_BIND_TYPE, - static_cast(SQL_PARAM_BIND_BY_COLUMN)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_PARAM_BIND_TYPE, &value); + + EXPECT_EQ(static_cast(SQL_PARAM_BIND_BY_COLUMN), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrParamOperationPtr) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAM_OPERATION_PTR, - static_cast(nullptr)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_PARAM_OPERATION_PTR, &value); + + EXPECT_EQ(static_cast(nullptr), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrParamStatusPtr) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAM_STATUS_PTR, - static_cast(nullptr)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_PARAM_STATUS_PTR, &value); + + EXPECT_EQ(static_cast(nullptr), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrParamsProcessedPtr) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAMS_PROCESSED_PTR, - static_cast(nullptr)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_PARAMS_PROCESSED_PTR, &value); + + EXPECT_EQ(static_cast(nullptr), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrParamsetSize) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAMSET_SIZE, static_cast(1)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_PARAMSET_SIZE, &value); + + EXPECT_EQ(static_cast(1), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrQueryTimeout) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_QUERY_TIMEOUT, static_cast(0)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_QUERY_TIMEOUT, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRetrieveData) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_RETRIEVE_DATA, - static_cast(SQL_RD_ON)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_RETRIEVE_DATA, &value); + + EXPECT_EQ(static_cast(SQL_RD_ON), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowArraySize) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_ARRAY_SIZE, static_cast(1)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_ROW_ARRAY_SIZE, &value); + + EXPECT_EQ(static_cast(1), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowBindOffsetPtr) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_BIND_OFFSET_PTR, - static_cast(nullptr)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_ROW_BIND_OFFSET_PTR, &value); + + EXPECT_EQ(static_cast(nullptr), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowBindType) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_BIND_TYPE, static_cast(0)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_ROW_BIND_TYPE, &value); + + EXPECT_EQ(static_cast(0), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowNumber) { @@ -294,37 +334,53 @@ TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowNumber) { ASSERT_EQ(SQL_SUCCESS, SQLFetch(this->stmt)); - ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_NUMBER, static_cast(1)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_ROW_NUMBER, &value); + + EXPECT_EQ(static_cast(1), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowOperationPtr) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_OPERATION_PTR, - static_cast(nullptr)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_ROW_OPERATION_PTR, &value); + + EXPECT_EQ(static_cast(nullptr), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowStatusPtr) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_STATUS_PTR, - static_cast(nullptr)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_ROW_STATUS_PTR, &value); + + EXPECT_EQ(static_cast(nullptr), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowsFetchedPtr) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROWS_FETCHED_PTR, - static_cast(nullptr)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_ROWS_FETCHED_PTR, &value); + + EXPECT_EQ(static_cast(nullptr), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrSimulateCursor) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_SIMULATE_CURSOR, - static_cast(SQL_SC_UNIQUE)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_SIMULATE_CURSOR, &value); + + EXPECT_EQ(static_cast(SQL_SC_UNIQUE), value); } TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrUseBookmarks) { - ValidateGetStmtAttr(this->stmt, SQL_ATTR_USE_BOOKMARKS, - static_cast(SQL_UB_OFF)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ATTR_USE_BOOKMARKS, &value); + + EXPECT_EQ(static_cast(SQL_UB_OFF), value); } // This is a pre ODBC 3 attribute TYPED_TEST(StatementAttributeTest, TestSQLGetStmtAttrRowsetSize) { - ValidateGetStmtAttr(this->stmt, SQL_ROWSET_SIZE, static_cast(1)); + SQLULEN value; + GetStmtAttr(this->stmt, SQL_ROWSET_SIZE, &value); + + EXPECT_EQ(static_cast(1), value); } TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrAppParamDesc) { @@ -453,8 +509,10 @@ TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrParamBindOffsetPtr) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_PARAM_BIND_OFFSET_PTR, static_cast(&offset)); - ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAM_BIND_OFFSET_PTR, - static_cast(&offset)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_PARAM_BIND_OFFSET_PTR, &value); + + EXPECT_EQ(static_cast(&offset), value); } TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrParamBindType) { @@ -470,8 +528,10 @@ TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrParamOperationPtr) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_PARAM_OPERATION_PTR, static_cast(param_operations)); - ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAM_OPERATION_PTR, - static_cast(param_operations)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_PARAM_OPERATION_PTR, &value); + + EXPECT_EQ(static_cast(param_operations), value); } TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrParamStatusPtr) { @@ -483,8 +543,10 @@ TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrParamStatusPtr) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_PARAM_STATUS_PTR, static_cast(param_status)); - ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAM_STATUS_PTR, - static_cast(param_status)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_PARAM_STATUS_PTR, &value); + + EXPECT_EQ(static_cast(param_status), value); } TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrParamsProcessedPtr) { @@ -493,8 +555,10 @@ TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrParamsProcessedPtr) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_PARAMS_PROCESSED_PTR, static_cast(&processed_count)); - ValidateGetStmtAttr(this->stmt, SQL_ATTR_PARAMS_PROCESSED_PTR, - static_cast(&processed_count)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_PARAMS_PROCESSED_PTR, &value); + + EXPECT_EQ(static_cast(&processed_count), value); } TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrParamsetSize) { @@ -520,8 +584,10 @@ TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowBindOffsetPtr) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_ROW_BIND_OFFSET_PTR, static_cast(&offset)); - ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_BIND_OFFSET_PTR, - static_cast(&offset)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_ROW_BIND_OFFSET_PTR, &value); + + EXPECT_EQ(static_cast(&offset), value); } TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowBindType) { @@ -542,8 +608,10 @@ TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowOperationPtr) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_ROW_OPERATION_PTR, static_cast(row_operations)); - ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_OPERATION_PTR, - static_cast(row_operations)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_ROW_OPERATION_PTR, &value); + + EXPECT_EQ(static_cast(row_operations), value); } TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowStatusPtr) { @@ -553,8 +621,10 @@ TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowStatusPtr) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_ROW_STATUS_PTR, static_cast(values)); - ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROW_STATUS_PTR, - static_cast(values)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_ROW_STATUS_PTR, &value); + + EXPECT_EQ(static_cast(values), value); } TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowsFetchedPtr) { @@ -563,8 +633,10 @@ TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrRowsFetchedPtr) { ValidateSetStmtAttr(this->stmt, SQL_ATTR_ROWS_FETCHED_PTR, static_cast(&rows_fetched)); - ValidateGetStmtAttr(this->stmt, SQL_ATTR_ROWS_FETCHED_PTR, - static_cast(&rows_fetched)); + SQLPOINTER value = nullptr; + GetStmtAttr(this->stmt, SQL_ATTR_ROWS_FETCHED_PTR, &value); + + EXPECT_EQ(static_cast(&rows_fetched), value); } TYPED_TEST(StatementAttributeTest, TestSQLSetStmtAttrSimulateCursor) {