sascha
/
query
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity

removed sql statement from execute result

This commit is contained in:
Sascha Kuehl 2023-12-11 20:07:07 +01:00
parent 1c92e07173
commit 81f22d73d9
11 changed files with 230 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
backends/sqlite/src/sqlite_connection.cpp
View File

@ -173,7 +173,7 @@ sql::record sqlite_connection::describe(const std::string& table)
bool sqlite_connection::exists(const std::string &table_name)
{
const auto result = fetch_internal("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND tbl_name='" + table_name + "' LIMIT 1");
sqlite_result_reader reader(std::move(result.rows), result.prototype.size());
sqlite_result_reader reader(result.rows, result.prototype.size());
if (!reader.fetch()) {
// Todo: throw an exception?

2
include/matador/sql/connection.hpp
View File

@ -35,7 +35,7 @@ public:
[[nodiscard]] bool exists(const std::string &table_name) const;
[[nodiscard]] std::unique_ptr<query_result_impl> fetch(const std::string &sql) const;
[[nodiscard]] std::pair<size_t, std::string> execute(const std::string &sql) const;
[[nodiscard]] size_t execute(const std::string &sql) const;
statement prepare(query_context &&query) const;

2
include/matador/sql/query_intermediates.hpp
View File

@ -36,7 +36,7 @@ class query_execute_finish : public query_intermediate
public:
using query_intermediate::query_intermediate;
std::pair<size_t, std::string> execute();
size_t execute();
statement prepare();
};

2
include/matador/sql/session.hpp
View File

@ -31,7 +31,7 @@ public:
[[nodiscard]] query_result<record> fetch(const query_context &q) const;
// [[nodiscard]] query_result<record> fetch(const std::string &sql) const;
[[nodiscard]] std::pair<size_t, std::string> execute(const std::string &sql) const;
[[nodiscard]] size_t execute(const std::string &sql) const;
statement prepare(query_context q) const;
record describe_table(const std::string &table_name) const;

4
src/sql/connection.cpp
View File

@ -76,10 +76,10 @@ bool connection::exists(const std::string &table_name) const
return connection_->exists(table_name);
}
std::pair<size_t, std::string> connection::execute(const std::string &sql) const
size_t connection::execute(const std::string &sql) const
{
logger_.debug(sql);
return {connection_->execute(sql), sql};
return connection_->execute(sql);
}
std::unique_ptr<query_result_impl> connection::fetch(const std::string &sql) const

2
src/sql/query_intermediates.cpp
View File

@ -103,7 +103,7 @@ query_into_intermediate query_insert_intermediate::into(const std::string &table
return {session_, builder_.into(table, column_names)};
}
std::pair<size_t, std::string> query_execute_finish::execute()
size_t query_execute_finish::execute()
{
return session_.execute(builder_.compile().sql);
}

2
src/sql/session.cpp
View File

@ -65,7 +65,7 @@ query_result<record> session::fetch(const query_context &q) const
// return query_result<record>(std::unique_ptr());
//}
std::pair<size_t, std::string> session::execute(const std::string &sql) const {
size_t session::execute(const std::string &sql) const {
auto c = pool_.acquire();
if (!c.valid()) {
throw std::logic_error("no database connection available");

162
test/SessionRecordTest.cpp
View File

@ -8,7 +8,8 @@
using namespace matador::sql;
TEST_CASE("Create and drop table statement", "[session record]") {
TEST_CASE("Create and drop table statement", "[session record]")
{
auto dns = GENERATE(as < std::string > {},
"sqlite://sqlite.db",
"postgres://test:test123@127.0.0.1:5432/matador_test");
@ -16,7 +17,7 @@ TEST_CASE("Create and drop table statement", "[session record]") {
session s(pool);
REQUIRE(!s.table_exists("person"));
auto res = s.create()
s.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
@ -24,22 +25,21 @@ TEST_CASE("Create and drop table statement", "[session record]") {
})
.execute();
REQUIRE(res.second == R"(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255), "age" INTEGER, CONSTRAINT PK_person PRIMARY KEY (id)))");
REQUIRE(s.table_exists("person"));
res = s.drop()
s.drop()
.table("person")
.execute();
REQUIRE(res.second == R"(DROP TABLE "person")");
REQUIRE(!s.table_exists("person"));
}
TEST_CASE("Create and drop table statement with foreign key", "[session record]") {
TEST_CASE("Create and drop table statement with foreign key", "[session record]")
{
connection_pool<connection> pool("sqlite://sqlite.db", 4);
session s(pool);
auto res = s.create()
s.create()
.table("airplane", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("brand", 255),
@ -47,9 +47,9 @@ TEST_CASE("Create and drop table statement with foreign key", "[session record]"
})
.execute();
REQUIRE(res.second == R"(CREATE TABLE "airplane" ("id" BIGINT NOT NULL, "brand" VARCHAR(255), "model" VARCHAR(255), CONSTRAINT PK_airplane PRIMARY KEY (id)))");
REQUIRE(s.table_exists("airplane"));
res = s.create()
s.create()
.table("flight", {
make_pk_column<unsigned long>("id"),
make_fk_column<unsigned long>("airplane_id", "airplane", "id"),
@ -57,22 +57,23 @@ TEST_CASE("Create and drop table statement with foreign key", "[session record]"
})
.execute();
REQUIRE(res.second == R"(CREATE TABLE "flight" ("id" BIGINT NOT NULL, "airplane_id" BIGINT, "pilot_name" VARCHAR(255), CONSTRAINT PK_flight PRIMARY KEY (id), CONSTRAINT FK_flight_airplane_id FOREIGN KEY (airplane_id) REFERENCES airplane(id)))");
REQUIRE(s.table_exists("flight"));
res = s.drop()
s.drop()
.table("flight")
.execute();
REQUIRE(res.second == R"(DROP TABLE "flight")");
REQUIRE(!s.table_exists("flight"));
res = s.drop()
s.drop()
.table("airplane")
.execute();
REQUIRE(res.second == R"(DROP TABLE "airplane")");
REQUIRE(!s.table_exists("airplane"));
}
TEST_CASE("Execute insert record statement", "[session record]") {
TEST_CASE("Execute insert record statement", "[session record]")
{
auto dns = GENERATE(as < std::string > {},
"sqlite://sqlite.db",
"postgres://test:test123@127.0.0.1:5432/matador_test");
@ -80,7 +81,7 @@ TEST_CASE("Execute insert record statement", "[session record]") {
connection_pool<connection> pool(dns, 4);
session s(pool);
auto res = s.create()
s.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
@ -88,15 +89,12 @@ TEST_CASE("Execute insert record statement", "[session record]") {
})
.execute();
REQUIRE(res.first == 0);
res = s.insert()
auto res = s.insert()
.into("person", {"id", "name", "age"})
.values({7, "george", 45})
.execute();
REQUIRE(res.first == 1);
REQUIRE(res.second == R"(INSERT INTO "person" ("id", "name", "age") VALUES (7, 'george', 45))");
REQUIRE(res == 1);
auto result = s.select({"id", "name", "age"})
.from("person")
@ -120,11 +118,12 @@ TEST_CASE("Execute insert record statement", "[session record]") {
.execute();
}
TEST_CASE("Execute insert record statement with foreign key", "[session record]") {
TEST_CASE("Execute insert record statement with foreign key", "[session record]")
{
connection_pool<connection> pool("sqlite://sqlite.db", 4);
session s(pool);
auto res = s.create()
s.create()
.table("airplane", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("brand", 255),
@ -132,9 +131,7 @@ TEST_CASE("Execute insert record statement with foreign key", "[session record]"
})
.execute();
REQUIRE(res.second == R"(CREATE TABLE "airplane" ("id" BIGINT NOT NULL, "brand" VARCHAR(255), "model" VARCHAR(255), CONSTRAINT PK_airplane PRIMARY KEY (id)))");
res = s.create()
s.create()
.table("flight", {
make_pk_column<unsigned long>("id"),
make_fk_column<unsigned long>("airplane_id", "airplane", "id"),
@ -142,34 +139,34 @@ TEST_CASE("Execute insert record statement with foreign key", "[session record]"
})
.execute();
REQUIRE(res.second == R"(CREATE TABLE "flight" ("id" BIGINT NOT NULL, "airplane_id" BIGINT, "pilot_name" VARCHAR(255), CONSTRAINT PK_flight PRIMARY KEY (id), CONSTRAINT FK_flight_airplane_id FOREIGN KEY (airplane_id) REFERENCES airplane(id)))");
res = s.insert().into("airplane", {"id", "brand", "model"}).values({1, "Airbus", "A380"}).execute();
REQUIRE(res.first == 1);
auto res = s.insert().into("airplane", {"id", "brand", "model"}).values({1, "Airbus", "A380"}).execute();
REQUIRE(res == 1);
res = s.insert().into("airplane", {"id", "brand", "model"}).values({2, "Boeing", "707"}).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
res = s.insert().into("airplane", {"id", "brand", "model"}).values({3, "Boeing", "747"}).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
auto count = s.select({count_all()}).from("airplane").fetch_value<int>();
REQUIRE(count == 3);
res = s.insert().into("flight", {"id", "airplane_id", "pilot_name"}).values({4, 1, "George"}).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
res = s.drop().table("flight").execute();
REQUIRE(res.second == R"(DROP TABLE "flight")");
res = s.drop().table("airplane").execute();
REQUIRE(res.second == R"(DROP TABLE "airplane")");
s.drop().table("flight").execute();
s.drop().table("airplane").execute();
REQUIRE(!s.table_exists("flight"));
REQUIRE(!s.table_exists("airplane"));
}
TEST_CASE("Execute update record statement", "[session record]") {
TEST_CASE("Execute update record statement", "[session record]")
{
connection_pool<connection> pool("sqlite://sqlite.db", 4);
session s(pool);
auto res = s.create()
s.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
@ -177,23 +174,21 @@ TEST_CASE("Execute update record statement", "[session record]") {
})
.execute();
REQUIRE(res.first == 0);
res = s.insert()
auto res = s.insert()
.into("person", {"id", "name", "age"})
.values({7, "george", 45})
.execute();
REQUIRE(res.first == 1);
REQUIRE(res.second == R"(INSERT INTO "person" ("id", "name", "age") VALUES (7, 'george', 45))");
REQUIRE(res == 1);
res = s.update("person")
.set({{"id", 7}, {"name", "jane"}, {"age", 35}})
.set({{"id", 7},
{"name", "jane"},
{"age", 35}})
.where("id"_col == 7)
.execute();
REQUIRE(res.first == 1);
REQUIRE(res.second == R"(UPDATE "person" SET "id"=7, "name"='jane', "age"=35 WHERE "id" = 7)");
REQUIRE(res == 1);
auto result = s.select({"id", "name", "age"})
.from("person")
@ -215,11 +210,12 @@ TEST_CASE("Execute update record statement", "[session record]") {
s.drop().table("person").execute();
}
TEST_CASE("Execute select statement", "[session record]") {
TEST_CASE("Execute select statement", "[session record]")
{
connection_pool<connection> pool("sqlite://sqlite.db", 4);
session s(pool);
auto res = s.create()
s.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
@ -227,16 +223,14 @@ TEST_CASE("Execute select statement", "[session record]") {
})
.execute();
REQUIRE(res.first == 0);
res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
REQUIRE(res.first == 1);
auto res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
REQUIRE(res == 1);
res = s.insert().into("person", {"id", "name", "age"}).values({2, "jane", 32}).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
res = s.insert().into("person", {"id", "name", "age"}).values({3, "michael", 67}).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
res = s.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
auto result = s.select({"id", "name", "age"})
.from("person")
@ -262,11 +256,12 @@ TEST_CASE("Execute select statement", "[session record]") {
s.drop().table("person").execute();
}
TEST_CASE("Execute select statement with order by", "[session record]") {
TEST_CASE("Execute select statement with order by", "[session record]")
{
connection_pool<connection> pool("sqlite://sqlite.db", 4);
session s(pool);
auto res = s.create()
s.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
@ -274,16 +269,14 @@ TEST_CASE("Execute select statement with order by", "[session record]") {
})
.execute();
REQUIRE(res.first == 0);
res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
REQUIRE(res.first == 1);
auto res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
REQUIRE(res == 1);
res = s.insert().into("person", {"id", "name", "age"}).values({2, "jane", 32}).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
res = s.insert().into("person", {"id", "name", "age"}).values({3, "michael", 67}).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
res = s.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
auto result = s.select({"id", "name", "age"})
.from("person")
@ -300,11 +293,12 @@ TEST_CASE("Execute select statement with order by", "[session record]") {
s.drop().table("person").execute();
}
TEST_CASE("Execute select statement with group by and order by", "[session record]") {
TEST_CASE("Execute select statement with group by and order by", "[session record]")
{
connection_pool<connection> pool("sqlite://sqlite.db", 4);
session s(pool);
auto res = s.create()
s.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
@ -312,16 +306,16 @@ TEST_CASE("Execute select statement with group by and order by", "[session recor
})
.execute();
res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
REQUIRE(res.first == 1);
auto res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
REQUIRE(res == 1);
res = s.insert().into("person", {"id", "name", "age"}).values({2, "jane", 45}).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
res = s.insert().into("person", {"id", "name", "age"}).values({3, "michael", 13}).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
res = s.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
res = s.insert().into("person", {"id", "name", "age"}).values({5, "charlie", 67}).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
auto result = s.select({alias(count("age"), "age_count"), "age"})
.from("person")
@ -329,7 +323,9 @@ TEST_CASE("Execute select statement with group by and order by", "[session recor
.order_by("age_count").desc()
.fetch_all();
std::list<std::pair<int, int>> expected_values {{2, 45}, {2, 13}, {1, 67}};
std::list<std::pair<int, int>> expected_values{{2, 45},
{2, 13},
{1, 67}};
for (const auto &r: result) {
REQUIRE(r.at(0).as<int>() == expected_values.front().first);
REQUIRE(r.at(1).as<int>() == expected_values.front().second);
@ -339,23 +335,22 @@ TEST_CASE("Execute select statement with group by and order by", "[session recor
s.drop().table("person").execute();
}
TEST_CASE("Execute delete statement", "[session record]") {
TEST_CASE("Execute delete statement", "[session record]")
{
connection_pool<connection> pool("sqlite://sqlite.db", 4);
session s(pool);
auto res = s.create()
s.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
make_column<unsigned short>("age")
}).execute();
REQUIRE(res.first == 0);
res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
REQUIRE(res.first == 1);
auto res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
REQUIRE(res == 1);
res = s.insert().into("person", {"id", "name", "age"}).values({2, "jane", 45}).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
auto count = s.select({count_all()}).from("person").fetch_value<int>();
REQUIRE(count == 2);
@ -365,8 +360,7 @@ TEST_CASE("Execute delete statement", "[session record]") {
.where("id"_col == 1)
.execute();
REQUIRE(res.second == R"(DELETE FROM "main"."person" WHERE "id" = 1)");
REQUIRE(res.first == 1);
REQUIRE(res == 1);
count = s.select({count_all()}).from("person").fetch_value<int>();
REQUIRE(count == 1);

46
test/SessionTest.cpp
View File

@ -22,38 +22,39 @@ TEST_CASE("Create table with foreign key relation", "[session]") {
connection_pool<connection> pool(dns, 4);
session s(pool);
auto res = s.create()
s.create()
.table<airplane>("airplane")
.execute();
REQUIRE(res.first == 0);
REQUIRE(res.second == R"(CREATE TABLE "airplane" ("id" BIGINT, "brand" VARCHAR(255), "model" VARCHAR(255), CONSTRAINT PK_airplane PRIMARY KEY (id)))");
res = s.create()
REQUIRE(s.table_exists("airplane"));
s.create()
.table<flight>("flight")
.execute();
REQUIRE(res.first == 0);
REQUIRE(res.second == R"(CREATE TABLE "flight" ("id" BIGINT, "airplane_id" BIGINT, "pilot_name" VARCHAR(255), CONSTRAINT PK_flight PRIMARY KEY (id), CONSTRAINT FK_flight_airplane_id FOREIGN KEY (airplane_id) REFERENCES airplane(id)))");
REQUIRE(s.table_exists("flight"));
s.drop().table("flight").execute();
s.drop().table("airplane").execute();
REQUIRE(!s.table_exists("flight"));
REQUIRE(!s.table_exists("airplane"));
}
TEST_CASE("Execute select statement with where clause", "[session]") {
connection_pool<connection> pool("sqlite://sqlite.db", 4);
session s(pool);
auto res = s.create()
s.create()
.table<person>("person")
.execute();
REQUIRE(res.first == 0);
person george{7, "george", 45};
res = s.insert()
auto res = s.insert()
.into("person", george)
.execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
// fetch person as record
auto result_record = s.select<person>()
@ -93,7 +94,7 @@ TEST_CASE("Execute insert statement", "[session]") {
connection_pool<connection> pool("sqlite://sqlite.db", 4);
session s(pool);
auto res = s.create()
s.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
@ -101,13 +102,12 @@ TEST_CASE("Execute insert statement", "[session]") {
})
.execute();
res = s.insert()
auto res = s.insert()
.into("person", {"id", "name", "color"})
.values({7, "george", "green"})
.execute();
REQUIRE(res.first == 1);
REQUIRE(res.second == R"(INSERT INTO "person" ("id", "name", "color") VALUES (7, 'george', 'green'))");
REQUIRE(res == 1);
s.drop().table("person").execute();
}
@ -116,17 +116,13 @@ TEST_CASE("Select statement with foreign key", "[session]") {
connection_pool<connection> pool("sqlite://sqlite.db", 4);
session s(pool);
auto res = s.create()
s.create()
.table<airplane>("airplane")
.execute();
REQUIRE(res.first == 0);
REQUIRE(res.second == R"(CREATE TABLE "airplane" ("id" BIGINT, "brand" VARCHAR(255), "model" VARCHAR(255), CONSTRAINT PK_airplane PRIMARY KEY (id)))");
res = s.create()
s.create()
.table<flight>("flight")
.execute();
REQUIRE(res.first == 0);
REQUIRE(res.second == R"(CREATE TABLE "flight" ("id" BIGINT, "airplane_id" BIGINT, "pilot_name" VARCHAR(255), CONSTRAINT PK_flight PRIMARY KEY (id), CONSTRAINT FK_flight_airplane_id FOREIGN KEY (airplane_id) REFERENCES airplane(id)))");
std::vector<entity<airplane>> planes {
make_entity<airplane>(1, "Airbus", "A380"),
@ -135,8 +131,8 @@ TEST_CASE("Select statement with foreign key", "[session]") {
};
for (const auto &plane : planes) {
res = s.insert().into<airplane>("airplane").values(*plane).execute();
REQUIRE(res.first == 1);
auto res = s.insert().into<airplane>("airplane").values(*plane).execute();
REQUIRE(res == 1);
}
auto count = s.select({count_all()}).from("airplane").fetch_value<int>();
@ -144,8 +140,8 @@ TEST_CASE("Select statement with foreign key", "[session]") {
flight f4711{4, planes.at(1), "hans"};
res = s.insert().into<flight>("flight").values(f4711).execute();
REQUIRE(res.first == 1);
auto res = s.insert().into<flight>("flight").values(f4711).execute();
REQUIRE(res == 1);
auto f = *s.select<flight>().from("flight").fetch_all<flight>().begin();
REQUIRE(f.id == 4);

6
test/StatementTest.cpp
View File

@ -21,11 +21,9 @@ public:
StatementTestFixture()
: pool_(Type::dns, 4), session_(pool_)
{
auto res = session_.create()
session_.create()
.table<airplane>("airplane")
.execute();
REQUIRE(res.first == 0);
REQUIRE(res.second == R"(CREATE TABLE "airplane" ("id" BIGINT, "brand" VARCHAR(255), "model" VARCHAR(255), CONSTRAINT PK_airplane PRIMARY KEY (id)))");
}
~StatementTestFixture()
@ -79,7 +77,7 @@ TEMPLATE_TEST_CASE_METHOD(StatementTestFixture, "Create prepared statement", "[s
SECTION("Select with prepared statement") {
for (const auto &plane: planes) {
auto res = s.insert().template into<airplane>("airplane").values(*plane).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
}
auto stmt = s.template select<airplane>().from("airplane").where("brand"_col == _).prepare();

6
test/TypeTraitsTest.cpp
View File

@ -23,11 +23,9 @@ public:
TypeTraitsTestFixture()
: pool_(Type::dns, 4), session_(pool_)
{
auto res = session_.create()
session_.create()
.table<location>("location")
.execute();
REQUIRE(res.first == 0);
REQUIRE(res.second == R"(CREATE TABLE "location" ("id" BIGINT, "name" VARCHAR(255), "coordinate_x" INTEGER, "coordinate_y" INTEGER, "coordinate_z" INTEGER, "color" TEXT, CONSTRAINT PK_location PRIMARY KEY (id)))");
}
~TypeTraitsTestFixture()
@ -93,7 +91,7 @@ TEMPLATE_TEST_CASE_METHOD(TypeTraitsTestFixture, "Special handling of attributes
location loc{1, "center", {1, 2, 3}, Color::Black};
auto res = s.insert().template into<location>("location").values(loc).execute();
REQUIRE(res.first == 1);
REQUIRE(res == 1);
auto result = s.template select<location>().from("location").
template fetch_all<location>();