boost/mysql
2
0
Fork 0
mirror of https://github.com/boostorg/mysql.git synced 2026-02-14 00:42:53 +00:00
Code Issues Projects Releases Wiki Activity

Added error_info

Browse Source
This commit is contained in:
ruben
2020-01-18 20:05:21 +00:00
parent 034ab38f05
commit a65e86af1d
21 changed files with 469 additions and 203 deletions
Download Patch File Download Diff File Expand all files Collapse all files

188
test/integration/query.cpp
View File

@@ -21,6 +21,7 @@ using mysql::test::validate_meta;
using mysql::field_metadata;
using mysql::field_type;
using mysql::error_code;
using mysql::error_info;
namespace
{
@@ -68,14 +69,22 @@ struct QueryTest : public mysql::test::IntegTest
{
validate_2fields_meta(result.fields(), table);
}
auto make_query_initiator(const char* sql)
{
return [this, sql](auto&& cb) {
conn.async_query(sql, cb);
};
}
};
// Query, sync errc
TEST_F(QueryTest, QuerySyncErrc_InsertQueryOk)
{
auto result = conn.query(
"INSERT INTO inserts_table (field_varchar, field_date) VALUES ('v0', '2010-10-11')", errc);
ASSERT_EQ(errc, mysql::error_code());
const char* sql = "INSERT INTO inserts_table (field_varchar, field_date) VALUES ('v0', '2010-10-11')";
auto result = conn.query(sql, errc, info);
ASSERT_EQ(errc, error_code());
EXPECT_EQ(info, error_info());
EXPECT_TRUE(result.fields().empty());
EXPECT_TRUE(result.valid());
EXPECT_TRUE(result.complete());
@@ -87,17 +96,19 @@ TEST_F(QueryTest, QuerySyncErrc_InsertQueryOk)
TEST_F(QueryTest, QuerySyncErrc_InsertQueryFailed)
{
auto result = conn.query(
"INSERT INTO bad_table (field_varchar, field_date) VALUES ('v0', '2010-10-11')", errc);
const char* sql = "INSERT INTO bad_table (field_varchar, field_date) VALUES ('v0', '2010-10-11')";
auto result = conn.query(sql, errc, info);
ASSERT_EQ(errc, make_error_code(mysql::Error::no_such_table));
validate_error_info(info, {"table", "doesn't exist", "bad_table"});
EXPECT_FALSE(result.valid());
}
TEST_F(QueryTest, QuerySyncErrc_UpdateQueryOk)
{
auto result = conn.query(
"UPDATE updates_table SET field_int = field_int+1", errc);
const char* sql = "UPDATE updates_table SET field_int = field_int+1";
auto result = conn.query(sql, errc, info);
ASSERT_EQ(errc, mysql::error_code());
EXPECT_EQ(info, error_info());
EXPECT_TRUE(result.fields().empty());
EXPECT_TRUE(result.valid());
EXPECT_TRUE(result.complete());
@@ -109,8 +120,9 @@ TEST_F(QueryTest, QuerySyncErrc_UpdateQueryOk)
TEST_F(QueryTest, QuerySyncErrc_SelectOk)
{
auto result = conn.query("SELECT * FROM empty_table", errc);
auto result = conn.query("SELECT * FROM empty_table", errc, info);
ASSERT_EQ(errc, mysql::error_code());
EXPECT_EQ(info, error_info());
EXPECT_TRUE(result.valid());
EXPECT_FALSE(result.complete());
validate_2fields_meta(result, "empty_table");
@@ -118,8 +130,9 @@ TEST_F(QueryTest, QuerySyncErrc_SelectOk)
TEST_F(QueryTest, QuerySyncErrc_SelectQueryFailed)
{
auto result = conn.query("SELECT field_varchar, field_bad FROM one_row_table", errc);
auto result = conn.query("SELECT field_varchar, field_bad FROM one_row_table", errc, info);
ASSERT_EQ(errc, make_error_code(mysql::Error::bad_field_error));
validate_error_info(info, {"unknown column", "field_bad"});
EXPECT_FALSE(result.valid());
}
@@ -148,10 +161,11 @@ TEST_F(QueryTest, QuerySyncExc_Error)
// Query, async
TEST_F(QueryTest, QueryAsync_InsertQueryOk)
{
auto result = conn.async_query(
auto [info, result] = conn.async_query(
"INSERT INTO inserts_table (field_varchar, field_date) VALUES ('v0', '2010-10-11')",
net::use_future
).get();
EXPECT_EQ(info, error_info());
EXPECT_TRUE(result.fields().empty());
EXPECT_TRUE(result.valid());
EXPECT_TRUE(result.complete());
@@ -163,19 +177,20 @@ TEST_F(QueryTest, QueryAsync_InsertQueryOk)
TEST_F(QueryTest, QueryAsync_InsertQueryFailed)
{
auto fut = conn.async_query(
"INSERT INTO bad_table (field_varchar, field_date) VALUES ('v0', '2010-10-11')",
net::use_future
validate_async_fail(
make_query_initiator("INSERT INTO bad_table (field_varchar, field_date) VALUES ('v0', '2010-10-11')"),
mysql::Error::no_such_table,
{"table", "doesn't exist", "bad_table"}
);
validate_future_exception(fut, make_error_code(mysql::Error::no_such_table));
}
TEST_F(QueryTest, QueryAsync_UpdateQueryOk)
{
auto result = conn.async_query(
auto [info, result] = conn.async_query(
"UPDATE updates_table SET field_int = field_int+1",
net::use_future
).get();
EXPECT_EQ(info, error_info());
EXPECT_TRUE(result.fields().empty());
EXPECT_TRUE(result.valid());
EXPECT_TRUE(result.complete());
@@ -187,7 +202,8 @@ TEST_F(QueryTest, QueryAsync_UpdateQueryOk)
TEST_F(QueryTest, QueryAsync_SelectOk)
{
auto result = conn.async_query("SELECT * FROM empty_table", net::use_future).get();
auto [info, result] = conn.async_query("SELECT * FROM empty_table", net::use_future).get();
EXPECT_EQ(info, error_info());
EXPECT_TRUE(result.valid());
EXPECT_FALSE(result.complete());
validate_2fields_meta(result, "empty_table");
@@ -195,8 +211,11 @@ TEST_F(QueryTest, QueryAsync_SelectOk)
TEST_F(QueryTest, QueryAsync_SelectQueryFailed)
{
auto fut = conn.async_query("SELECT field_varchar, field_bad FROM one_row_table", net::use_future);
validate_future_exception(fut, make_error_code(mysql::Error::bad_field_error));
validate_async_fail(
make_query_initiator("SELECT field_varchar, field_bad FROM one_row_table"),
mysql::Error::bad_field_error,
{"unknown column", "field_bad"}
);
}
@@ -209,14 +228,17 @@ TEST_F(QueryTest, FetchOneSyncErrc_NoResults)
EXPECT_EQ(result.fields().size(), 2);
// Already in the end of the resultset, we receive the EOF
const mysql::row* row = result.fetch_one(errc);
const mysql::row* row = result.fetch_one(errc, info);
EXPECT_EQ(errc, mysql::error_code());
EXPECT_EQ(info, error_info());
EXPECT_EQ(row, nullptr);
validate_eof(result);
// Fetching again just returns null
row = result.fetch_one(errc);
reset_errors();
row = result.fetch_one(errc, info);
EXPECT_EQ(errc, mysql::error_code());
EXPECT_EQ(info, error_info());
EXPECT_EQ(row, nullptr);
validate_eof(result);
}
@@ -229,16 +251,19 @@ TEST_F(QueryTest, FetchOneSyncErrc_OneRow)
EXPECT_EQ(result.fields().size(), 2);
// Fetch only row
const mysql::row* row = result.fetch_one(errc);
const mysql::row* row = result.fetch_one(errc, info);
ASSERT_EQ(errc, mysql::error_code());
EXPECT_EQ(info, error_info());
ASSERT_NE(row, nullptr);
validate_2fields_meta(result, "one_row_table");
EXPECT_EQ(row->values(), makevalues(1, "f0"));
EXPECT_FALSE(result.complete());
// Fetch next: end of resultset
row = result.fetch_one(errc);
reset_errors();
row = result.fetch_one(errc, info);
ASSERT_EQ(errc, mysql::error_code());
EXPECT_EQ(info, error_info());
ASSERT_EQ(row, nullptr);
validate_eof(result);
}
@@ -251,24 +276,29 @@ TEST_F(QueryTest, FetchOneSyncErrc_TwoRows)
EXPECT_EQ(result.fields().size(), 2);
// Fetch first row
const mysql::row* row = result.fetch_one(errc);
const mysql::row* row = result.fetch_one(errc, info);
ASSERT_EQ(errc, mysql::error_code());
EXPECT_EQ(info, error_info());
ASSERT_NE(row, nullptr);
validate_2fields_meta(result, "two_rows_table");
EXPECT_EQ(row->values(), makevalues(1, "f0"));
EXPECT_FALSE(result.complete());
// Fetch next row
row = result.fetch_one(errc);
reset_errors();
row = result.fetch_one(errc, info);
ASSERT_EQ(errc, mysql::error_code());
EXPECT_EQ(info, error_info());
ASSERT_NE(row, nullptr);
validate_2fields_meta(result, "two_rows_table");
EXPECT_EQ(row->values(), makevalues(2, "f1"));
EXPECT_FALSE(result.complete());
// Fetch next: end of resultset
row = result.fetch_one(errc);
reset_errors();
row = result.fetch_one(errc, info);
ASSERT_EQ(errc, mysql::error_code());
EXPECT_EQ(info, error_info());
ASSERT_EQ(row, nullptr);
validate_eof(result);
}
@@ -309,12 +339,14 @@ TEST_F(QueryTest, FetchOneAsync_NoResults)
auto result = conn.query("SELECT * FROM empty_table");
// Already in the end of the resultset, we receive the EOF
const auto* row = result.async_fetch_one(net::use_future).get();
auto [info, row] = result.async_fetch_one(net::use_future).get();
EXPECT_EQ(info, error_info());
EXPECT_EQ(row, nullptr);
validate_eof(result);
// Fetching again just returns null
row = result.async_fetch_one(net::use_future).get();
std::tie(info, row) = result.async_fetch_one(net::use_future).get();
EXPECT_EQ(info, error_info());
EXPECT_EQ(row, nullptr);
validate_eof(result);
}
@@ -324,13 +356,16 @@ TEST_F(QueryTest, FetchOneAsync_OneRow)
auto result = conn.query("SELECT * FROM one_row_table");
// Fetch only row
const auto* row = result.async_fetch_one(net::use_future).get();
auto [info, row] = result.async_fetch_one(net::use_future).get();
EXPECT_EQ(info, error_info());
ASSERT_NE(row, nullptr);
EXPECT_EQ(row->values(), makevalues(1, "f0"));
EXPECT_FALSE(result.complete());
// Fetch next: end of resultset
row = result.async_fetch_one(net::use_future).get();
reset_errors();
std::tie(info, row) = result.async_fetch_one(net::use_future).get();
EXPECT_EQ(info, error_info());
ASSERT_EQ(row, nullptr);
validate_eof(result);
}
@@ -340,19 +375,24 @@ TEST_F(QueryTest, FetchOneAsync_TwoRows)
auto result = conn.query("SELECT * FROM two_rows_table");
// Fetch first row
const auto* row = result.async_fetch_one(net::use_future).get();
auto [info, row] = result.async_fetch_one(net::use_future).get();
EXPECT_EQ(info, error_info());
ASSERT_NE(row, nullptr);
EXPECT_EQ(row->values(), makevalues(1, "f0"));
EXPECT_FALSE(result.complete());
// Fetch next row
row = result.async_fetch_one(net::use_future).get();
reset_errors();
std::tie(info, row) = result.async_fetch_one(net::use_future).get();
EXPECT_EQ(info, error_info());
ASSERT_NE(row, nullptr);
EXPECT_EQ(row->values(), makevalues(2, "f1"));
EXPECT_FALSE(result.complete());
// Fetch next: end of resultset
row = result.async_fetch_one(net::use_future).get();
reset_errors();
std::tie(info, row) = result.async_fetch_one(net::use_future).get();
EXPECT_EQ(info, error_info());
ASSERT_EQ(row, nullptr);
validate_eof(result);
}
@@ -363,15 +403,18 @@ TEST_F(QueryTest, FetchManySyncErrc_NoResults)
auto result = conn.query("SELECT * FROM empty_table");
// Fetch many, but there are no results
auto rows = result.fetch_many(10, errc);
auto rows = result.fetch_many(10, errc, info);
ASSERT_EQ(errc, error_code());
EXPECT_EQ(info, error_info());
EXPECT_TRUE(rows.empty());
EXPECT_TRUE(result.complete());
validate_eof(result);
// Fetch again, should return OK and empty
rows = result.fetch_many(10, errc);
reset_errors();
rows = result.fetch_many(10, errc, info);
ASSERT_EQ(errc, error_code());
EXPECT_EQ(info, error_info());
EXPECT_TRUE(rows.empty());
EXPECT_TRUE(result.complete());
validate_eof(result);
@@ -382,14 +425,17 @@ TEST_F(QueryTest, FetchManySyncErrc_MoreRowsThanCount)
auto result = conn.query("SELECT * FROM three_rows_table");
// Fetch 2, one remaining
auto rows = result.fetch_many(2, errc);
auto rows = result.fetch_many(2, errc, info);
ASSERT_EQ(errc, error_code());
EXPECT_EQ(info, error_info());
EXPECT_FALSE(result.complete());
EXPECT_EQ(rows, (makerows(2, 1, "f0", 2, "f1")));
// Fetch another two (completes the resultset)
rows = result.fetch_many(2, errc);
reset_errors();
rows = result.fetch_many(2, errc, info);
ASSERT_EQ(errc, error_code());
EXPECT_EQ(info, error_info());
EXPECT_TRUE(result.complete());
validate_eof(result);
EXPECT_EQ(rows, (makerows(2, 3, "f2")));
@@ -400,8 +446,9 @@ TEST_F(QueryTest, FetchManySyncErrc_LessRowsThanCount)
auto result = conn.query("SELECT * FROM two_rows_table");
// Fetch 3, resultset exhausted
auto rows = result.fetch_many(3, errc);
auto rows = result.fetch_many(3, errc, info);
ASSERT_EQ(errc, error_code());
EXPECT_EQ(info, error_info());
EXPECT_EQ(rows, (makerows(2, 1, "f0", 2, "f1")));
validate_eof(result);
}
@@ -411,14 +458,17 @@ TEST_F(QueryTest, FetchManySyncErrc_SameRowsAsCount)
auto result = conn.query("SELECT * FROM two_rows_table");
// Fetch 2, 0 remaining but resultset not exhausted
auto rows = result.fetch_many(2, errc);
auto rows = result.fetch_many(2, errc, info);
ASSERT_EQ(errc, error_code());
EXPECT_EQ(info, error_info());
EXPECT_FALSE(result.complete());
EXPECT_EQ(rows, (makerows(2, 1, "f0", 2, "f1")));
// Fetch again, exhausts the resultset
rows = result.fetch_many(2, errc);
reset_errors();
rows = result.fetch_many(2, errc, info);
ASSERT_EQ(errc, error_code());
EXPECT_EQ(info, error_info());
EXPECT_EQ(rows.size(), 0);
validate_eof(result);
}
@@ -428,8 +478,9 @@ TEST_F(QueryTest, FetchManySyncErrc_CountEqualsOne)
auto result = conn.query("SELECT * FROM one_row_table");
// Fetch 1, 1 remaining
auto rows = result.fetch_many(1, errc);
auto rows = result.fetch_many(1, errc, info);
ASSERT_EQ(errc, error_code());
EXPECT_EQ(info, error_info());
EXPECT_FALSE(result.complete());
EXPECT_EQ(rows, (makerows(2, 1, "f0")));
}
@@ -460,13 +511,16 @@ TEST_F(QueryTest, FetchManyAsync_NoResults)
auto result = conn.query("SELECT * FROM empty_table");
// Fetch many, but there are no results
auto rows = result.async_fetch_many(10, net::use_future).get();
auto [info, rows] = result.async_fetch_many(10, net::use_future).get();
EXPECT_EQ(info, error_info());
EXPECT_TRUE(rows.empty());
EXPECT_TRUE(result.complete());
validate_eof(result);
// Fetch again, should return OK and empty
rows = result.async_fetch_many(10, net::use_future).get();
reset_errors();
std::tie(info, rows) = result.async_fetch_many(10, net::use_future).get();
EXPECT_EQ(info, error_info());
EXPECT_TRUE(rows.empty());
EXPECT_TRUE(result.complete());
validate_eof(result);
@@ -477,12 +531,14 @@ TEST_F(QueryTest, FetchManyAsync_MoreRowsThanCount)
auto result = conn.query("SELECT * FROM three_rows_table");
// Fetch 2, one remaining
auto rows = result.async_fetch_many(2, net::use_future).get();
auto [info, rows] = result.async_fetch_many(2, net::use_future).get();
EXPECT_EQ(info, error_info());
EXPECT_FALSE(result.complete());
EXPECT_EQ(rows, (makerows(2, 1, "f0", 2, "f1")));
// Fetch another two (completes the resultset)
rows = result.async_fetch_many(2, net::use_future).get();
std::tie(info, rows) = result.async_fetch_many(2, net::use_future).get();
EXPECT_EQ(info, error_info());
EXPECT_TRUE(result.complete());
validate_eof(result);
EXPECT_EQ(rows, (makerows(2, 3, "f2")));
@@ -493,7 +549,8 @@ TEST_F(QueryTest, FetchManyAsync_LessRowsThanCount)
auto result = conn.query("SELECT * FROM two_rows_table");
// Fetch 3, resultset exhausted
auto rows = result.async_fetch_many(3, net::use_future).get();
auto [info, rows] = result.async_fetch_many(3, net::use_future).get();
EXPECT_EQ(info, error_info());
EXPECT_EQ(rows, (makerows(2, 1, "f0", 2, "f1")));
validate_eof(result);
}
@@ -503,12 +560,15 @@ TEST_F(QueryTest, FetchManyAsync_SameRowsAsCount)
auto result = conn.query("SELECT * FROM two_rows_table");
// Fetch 2, 0 remaining but resultset not exhausted
auto rows = result.async_fetch_many(2, net::use_future).get();
auto [info, rows] = result.async_fetch_many(2, net::use_future).get();
EXPECT_EQ(info, error_info());
EXPECT_FALSE(result.complete());
EXPECT_EQ(rows, (makerows(2, 1, "f0", 2, "f1")));
// Fetch again, exhausts the resultset
rows = result.async_fetch_many(2, net::use_future).get();
reset_errors();
std::tie(info, rows) = result.async_fetch_many(2, net::use_future).get();
EXPECT_EQ(info, error_info());
EXPECT_EQ(rows.size(), 0);
validate_eof(result);
}
@@ -518,7 +578,8 @@ TEST_F(QueryTest, FetchManyAsync_CountEqualsOne)
auto result = conn.query("SELECT * FROM one_row_table");
// Fetch 1, 1 remaining
auto rows = result.async_fetch_many(1, net::use_future).get();
auto [info, rows] = result.async_fetch_many(1, net::use_future).get();
EXPECT_EQ(info, error_info());
EXPECT_FALSE(result.complete());
EXPECT_EQ(rows, (makerows(2, 1, "f0")));
}
@@ -529,14 +590,17 @@ TEST_F(QueryTest, FetchAllSyncErrc_NoResults)
auto result = conn.query("SELECT * FROM empty_table");
// Fetch many, but there are no results
auto rows = result.fetch_all(errc);
auto rows = result.fetch_all(errc, info);
ASSERT_EQ(errc, error_code());
EXPECT_EQ(info, error_info());
EXPECT_TRUE(rows.empty());
EXPECT_TRUE(result.complete());
// Fetch again, should return OK and empty
rows = result.fetch_all(errc);
reset_errors();
rows = result.fetch_all(errc, info);
ASSERT_EQ(errc, error_code());
EXPECT_EQ(info, error_info());
EXPECT_TRUE(rows.empty());
validate_eof(result);
}
@@ -545,8 +609,9 @@ TEST_F(QueryTest, FetchAllSyncErrc_OneRow)
{
auto result = conn.query("SELECT * FROM one_row_table");
auto rows = result.fetch_all(errc);
auto rows = result.fetch_all(errc, info);
ASSERT_EQ(errc, error_code());
EXPECT_EQ(info, error_info());
EXPECT_TRUE(result.complete());
EXPECT_EQ(rows, (makerows(2, 1, "f0")));
}
@@ -555,8 +620,9 @@ TEST_F(QueryTest, FetchAllSyncErrc_SeveralRows)
{
auto result = conn.query("SELECT * FROM two_rows_table");
auto rows = result.fetch_all(errc);
auto rows = result.fetch_all(errc, info);
ASSERT_EQ(errc, error_code());
EXPECT_EQ(info, error_info());
validate_eof(result);
EXPECT_EQ(rows, (makerows(2, 1, "f0", 2, "f1")));
}
@@ -578,12 +644,15 @@ TEST_F(QueryTest, FetchAllAsync_NoResults)
auto result = conn.query("SELECT * FROM empty_table");
// Fetch many, but there are no results
auto rows = result.async_fetch_all(net::use_future).get();
auto [info, rows] = result.async_fetch_all(net::use_future).get();
EXPECT_EQ(info, error_info());
EXPECT_TRUE(rows.empty());
EXPECT_TRUE(result.complete());
// Fetch again, should return OK and empty
rows = result.async_fetch_all(net::use_future).get();
reset_errors();
std::tie(info, rows) = result.async_fetch_all(net::use_future).get();
EXPECT_EQ(info, error_info());
EXPECT_TRUE(rows.empty());
validate_eof(result);
}
@@ -592,7 +661,8 @@ TEST_F(QueryTest, FetchAllAsync_OneRow)
{
auto result = conn.query("SELECT * FROM one_row_table");
auto rows = result.async_fetch_all(net::use_future).get();
auto [info, rows] = result.async_fetch_all(net::use_future).get();
EXPECT_EQ(info, error_info());
EXPECT_TRUE(result.complete());
EXPECT_EQ(rows, (makerows(2, 1, "f0")));
}
@@ -601,7 +671,8 @@ TEST_F(QueryTest, FetchAllAsync_SeveralRows)
{
auto result = conn.query("SELECT * FROM two_rows_table");
auto rows = result.async_fetch_all(net::use_future).get();
auto [info, rows] = result.async_fetch_all(net::use_future).get();
EXPECT_EQ(info, error_info());
validate_eof(result);
EXPECT_EQ(rows, (makerows(2, 1, "f0", 2, "f1")));
}
@@ -616,8 +687,3 @@ TEST_F(QueryTest, QueryAndFetch_AliasedTableAndField_MetadataCorrect)
}
} // anon namespace