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

Compare commits

base: sascha:f13837e515692fc646b9169ce513da2ca59dfaa5
Branches Tags
sascha:main
sascha:feature/matador-ng
..
compare: sascha:7c02d745c816c6567a17fb63baa05c1f3b256c66
Branches Tags
sascha:feature/matador-ng
sascha:main

No commits in common. "f13837e515692fc646b9169ce513da2ca59dfaa5" and "7c02d745c816c6567a17fb63baa05c1f3b256c66" have entirely different histories.
f13837e515 ... 7c02d745c8

26 changed files with 281 additions and 390 deletions
Show Stats Expand all files Collapse all files

6
backends/mysql/src/mysql_connection.cpp
View File

@ -234,15 +234,19 @@ sql::record mysql_connection::describe(const std::string &table)
while (reader.fetch()) {
char *end = nullptr;
// Todo: Handle error
auto index = strtoul(reader.column(0), &end, 10);
std::string name = reader.column(0);
// Todo: extract size
auto typeinfo = determine_type_info(reader.column(1));
end = nullptr;
sql::null_option null_opt{sql::null_option::NULLABLE};
if (strtoul(reader.column(2), &end, 10) == 0) {
null_opt = sql::null_option::NOT_NULL;
}
prototype.append({name, typeinfo.type, {typeinfo.size}, null_opt, prototype.size()});
// f.default_value(res->column(4));
prototype.append({name, typeinfo.type, {typeinfo.size}, null_opt});
}
return prototype;

3
backends/mysql/test/CMakeLists.txt
View File

@ -24,8 +24,7 @@ set(TEST_SOURCES
../../tests/ConnectionTest.cpp
../../tests/SessionRecordTest.cpp
../../tests/StatementTest.cpp
../../tests/TypeTraitsTest.cpp
../../tests/StatementCacheTest.cpp)
../../tests/TypeTraitsTest.cpp)
set(LIBRARY_TEST_TARGET mysql_tests)

9
backends/postgres/src/postgres_error.cpp
View File

@ -22,12 +22,9 @@ void throw_postgres_error(PGconn *db, const std::string &source)
void throw_postgres_error(PGresult *res, PGconn *db, const std::string &source, const std::string &sql)
{
if (res == nullptr) {
std::stringstream msg;
msg << "postgres error (" << source << ", " << PQerrorMessage(db) << ": " << sql;
throw std::logic_error(msg.str());
} else if ((PQresultStatus(res) != PGRES_COMMAND_OK &&
PQresultStatus(res) != PGRES_TUPLES_OK)) {
if (res == nullptr ||
(PQresultStatus(res) != PGRES_COMMAND_OK &&
PQresultStatus(res) != PGRES_TUPLES_OK)) {
std::stringstream msg;
msg << "postgres error (" << source << ", " << PQresultErrorField(res, PG_DIAG_SQLSTATE) << ") " << PQerrorMessage(db) << ": " << sql;
throw std::logic_error(msg.str());

3
backends/postgres/test/CMakeLists.txt
View File

@ -24,8 +24,7 @@ set(TEST_SOURCES
../../tests/ConnectionTest.cpp
../../tests/SessionRecordTest.cpp
../../tests/StatementTest.cpp
../../tests/TypeTraitsTest.cpp
../../tests/StatementCacheTest.cpp)
../../tests/TypeTraitsTest.cpp)
set(LIBRARY_TEST_TARGET postgres_tests)

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

@ -163,7 +163,7 @@ sql::record sqlite_connection::describe(const std::string& table)
null_opt = sql::null_option::NOT_NULL;
}
// f.default_value(res->column(4));
prototype.append({name, type, utils::null_attributes, null_opt, index});
prototype.append({name, type, utils::null_attributes, null_opt});
}
return std::move(prototype);

3
backends/sqlite/test/CMakeLists.txt
View File

@ -24,8 +24,7 @@ set(TEST_SOURCES
../../tests/ConnectionTest.cpp
../../tests/SessionRecordTest.cpp
../../tests/StatementTest.cpp
../../tests/TypeTraitsTest.cpp
../../tests/StatementCacheTest.cpp)
../../tests/TypeTraitsTest.cpp)
set(LIBRARY_TEST_TARGET sqlite_tests)

157
backends/tests/SessionRecordTest.cpp
View File

@ -2,7 +2,7 @@
#include "matador/sql/column.hpp"
#include "matador/sql/condition.hpp"
#include "matador/sql/connection.hpp"
#include "matador/sql/session.hpp"
#include "connection.hpp"
@ -12,10 +12,8 @@ class SessionRecordFixture
{
public:
SessionRecordFixture()
: db(matador::test::connection::dns)
{
db.open();
}
: pool(matador::test::connection::dns, 4), ses(pool)
{}
~SessionRecordFixture() {
drop_table_if_exists("flight");
drop_table_if_exists("airplane");
@ -24,12 +22,13 @@ public:
}
protected:
matador::sql::connection db;
matador::sql::connection_pool<matador::sql::connection> pool;
matador::sql::session ses;
private:
void drop_table_if_exists(const std::string &table_name) {
if (db.exists(table_name)) {
db.drop().table(table_name).execute();
if (ses.table_exists(table_name)) {
ses.drop().table(table_name).execute();
}
}
};
@ -38,8 +37,8 @@ using namespace matador::sql;
TEST_CASE_METHOD(SessionRecordFixture, " Create and drop table statement", "[session][record]")
{
REQUIRE(!db.exists("person"));
db.create()
REQUIRE(!ses.table_exists("person"));
ses.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
@ -47,18 +46,18 @@ TEST_CASE_METHOD(SessionRecordFixture, " Create and drop table statement", "[ses
})
.execute();
REQUIRE(db.exists("person"));
REQUIRE(ses.table_exists("person"));
db.drop()
ses.drop()
.table("person")
.execute();
REQUIRE(!db.exists("person"));
REQUIRE(!ses.table_exists("person"));
}
TEST_CASE_METHOD(SessionRecordFixture, " Create and drop table statement with foreign key", "[session][record]")
{
db.create()
ses.create()
.table("airplane", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("brand", 255),
@ -66,9 +65,9 @@ TEST_CASE_METHOD(SessionRecordFixture, " Create and drop table statement with fo
})
.execute();
REQUIRE(db.exists("airplane"));
REQUIRE(ses.table_exists("airplane"));
db.create()
ses.create()
.table("flight", {
make_pk_column<unsigned long>("id"),
make_fk_column<unsigned long>("airplane_id", "airplane", "id"),
@ -76,24 +75,24 @@ TEST_CASE_METHOD(SessionRecordFixture, " Create and drop table statement with fo
})
.execute();
REQUIRE(db.exists("flight"));
REQUIRE(ses.table_exists("flight"));
db.drop()
ses.drop()
.table("flight")
.execute();
REQUIRE(!db.exists("flight"));
REQUIRE(!ses.table_exists("flight"));
db.drop()
ses.drop()
.table("airplane")
.execute();
REQUIRE(!db.exists("airplane"));
REQUIRE(!ses.table_exists("airplane"));
}
TEST_CASE_METHOD(SessionRecordFixture, " Execute insert record statement", "[session][record]")
{
db.create()
ses.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
@ -101,14 +100,14 @@ TEST_CASE_METHOD(SessionRecordFixture, " Execute insert record statement", "[ses
})
.execute();
auto res = db.insert()
auto res = ses.insert()
.into("person", {"id", "name", "age"})
.values({7, "george", 45})
.execute();
REQUIRE(res == 1);
auto result = db.select({"id", "name", "age"})
auto result = ses.select({"id", "name", "age"})
.from("person")
.fetch_all();
@ -125,14 +124,14 @@ TEST_CASE_METHOD(SessionRecordFixture, " Execute insert record statement", "[ses
REQUIRE(i.at(2).template as<int>() == 45);
}
db.drop()
ses.drop()
.table("person")
.execute();
}
TEST_CASE_METHOD(SessionRecordFixture, " Execute insert record statement with foreign key", "[session][record]")
{
db.create()
ses.create()
.table("airplane", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("brand", 255),
@ -140,7 +139,7 @@ TEST_CASE_METHOD(SessionRecordFixture, " Execute insert record statement with fo
})
.execute();
db.create()
ses.create()
.table("flight", {
make_pk_column<unsigned long>("id"),
make_fk_column<unsigned long>("airplane_id", "airplane", "id"),
@ -148,31 +147,31 @@ TEST_CASE_METHOD(SessionRecordFixture, " Execute insert record statement with fo
})
.execute();
auto res = db.insert().into("airplane", {"id", "brand", "model"}).values({1, "Airbus", "A380"}).execute();
auto res = ses.insert().into("airplane", {"id", "brand", "model"}).values({1, "Airbus", "A380"}).execute();
REQUIRE(res == 1);
res = db.insert().into("airplane", {"id", "brand", "model"}).values({2, "Boeing", "707"}).execute();
res = ses.insert().into("airplane", {"id", "brand", "model"}).values({2, "Boeing", "707"}).execute();
REQUIRE(res == 1);
res = db.insert().into("airplane", {"id", "brand", "model"}).values({3, "Boeing", "747"}).execute();
res = ses.insert().into("airplane", {"id", "brand", "model"}).values({3, "Boeing", "747"}).execute();
REQUIRE(res == 1);
auto count = db.select({count_all()}).from("airplane").fetch_value<int>();
auto count = ses.select({count_all()}).from("airplane").fetch_value<int>();
REQUIRE(count == 3);
res = db.insert().into("flight", {"id", "airplane_id", "pilot_name"}).values({4, 1, "George"}).execute();
res = ses.insert().into("flight", {"id", "airplane_id", "pilot_name"}).values({4, 1, "George"}).execute();
REQUIRE(res == 1);
db.drop().table("flight").execute();
db.drop().table("airplane").execute();
ses.drop().table("flight").execute();
ses.drop().table("airplane").execute();
REQUIRE(!db.exists("flight"));
REQUIRE(!db.exists("airplane"));
REQUIRE(!ses.table_exists("flight"));
REQUIRE(!ses.table_exists("airplane"));
}
TEST_CASE_METHOD(SessionRecordFixture, " Execute update record statement", "[session][record]")
{
db.create()
ses.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
@ -180,14 +179,14 @@ TEST_CASE_METHOD(SessionRecordFixture, " Execute update record statement", "[ses
})
.execute();
auto res = db.insert()
auto res = ses.insert()
.into("person", {"id", "name", "age"})
.values({7, "george", 45})
.execute();
REQUIRE(res == 1);
res = db.update("person")
res = ses.update("person")
.set({{"id", 7},
{"name", "jane"},
{"age", 35}})
@ -196,7 +195,7 @@ TEST_CASE_METHOD(SessionRecordFixture, " Execute update record statement", "[ses
REQUIRE(res == 1);
auto result = db.select({"id", "name", "age"})
auto result = ses.select({"id", "name", "age"})
.from("person")
.fetch_all();
@ -213,12 +212,12 @@ TEST_CASE_METHOD(SessionRecordFixture, " Execute update record statement", "[ses
REQUIRE(i.at(2).as<int>() == 35);
}
db.drop().table("person").execute();
ses.drop().table("person").execute();
}
TEST_CASE_METHOD(SessionRecordFixture, " Execute select statement", "[session][record]")
{
db.create()
ses.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
@ -226,16 +225,16 @@ TEST_CASE_METHOD(SessionRecordFixture, " Execute select statement", "[session][r
})
.execute();
auto res = db.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
auto res = ses.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
REQUIRE(res == 1);
res = db.insert().into("person", {"id", "name", "age"}).values({2, "jane", 32}).execute();
res = ses.insert().into("person", {"id", "name", "age"}).values({2, "jane", 32}).execute();
REQUIRE(res == 1);
res = db.insert().into("person", {"id", "name", "age"}).values({3, "michael", 67}).execute();
res = ses.insert().into("person", {"id", "name", "age"}).values({3, "michael", 67}).execute();
REQUIRE(res == 1);
res = db.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
res = ses.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
REQUIRE(res == 1);
auto result = db.select({"id", "name", "age"})
auto result = ses.select({"id", "name", "age"})
.from("person")
.fetch_all();
@ -246,22 +245,22 @@ TEST_CASE_METHOD(SessionRecordFixture, " Execute select statement", "[session][r
}
REQUIRE(expected_names.empty());
auto rec = db.select({"id", "name", "age"})
auto rec = ses.select({"id", "name", "age"})
.from("person")
.fetch_one();
REQUIRE(rec.at(1).str() == "george");
auto name = db.select({"name"})
auto name = ses.select({"name"})
.from("person")
.fetch_value<std::string>();
REQUIRE(name == "george");
db.drop().table("person").execute();
ses.drop().table("person").execute();
}
TEST_CASE_METHOD(SessionRecordFixture, " Execute select statement with order by", "[session][record]")
{
db.create()
ses.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
@ -269,16 +268,16 @@ TEST_CASE_METHOD(SessionRecordFixture, " Execute select statement with order by"
})
.execute();
auto res = db.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
auto res = ses.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
REQUIRE(res == 1);
res = db.insert().into("person", {"id", "name", "age"}).values({2, "jane", 32}).execute();
res = ses.insert().into("person", {"id", "name", "age"}).values({2, "jane", 32}).execute();
REQUIRE(res == 1);
res = db.insert().into("person", {"id", "name", "age"}).values({3, "michael", 67}).execute();
res = ses.insert().into("person", {"id", "name", "age"}).values({3, "michael", 67}).execute();
REQUIRE(res == 1);
res = db.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
res = ses.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
REQUIRE(res == 1);
auto result = db.select({"id", "name", "age"})
auto result = ses.select({"id", "name", "age"})
.from("person")
.order_by("name").asc()
.fetch_all();
@ -290,12 +289,12 @@ TEST_CASE_METHOD(SessionRecordFixture, " Execute select statement with order by"
}
REQUIRE(expected_names.empty());
db.drop().table("person").execute();
ses.drop().table("person").execute();
}
TEST_CASE_METHOD(SessionRecordFixture, " Execute select statement with group by and order by", "[session][record]")
{
db.create()
ses.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
@ -303,18 +302,18 @@ TEST_CASE_METHOD(SessionRecordFixture, " Execute select statement with group by
})
.execute();
auto res = db.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
auto res = ses.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
REQUIRE(res == 1);
res = db.insert().into("person", {"id", "name", "age"}).values({2, "jane", 45}).execute();
res = ses.insert().into("person", {"id", "name", "age"}).values({2, "jane", 45}).execute();
REQUIRE(res == 1);
res = db.insert().into("person", {"id", "name", "age"}).values({3, "michael", 13}).execute();
res = ses.insert().into("person", {"id", "name", "age"}).values({3, "michael", 13}).execute();
REQUIRE(res == 1);
res = db.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
res = ses.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
REQUIRE(res == 1);
res = db.insert().into("person", {"id", "name", "age"}).values({5, "charlie", 67}).execute();
res = ses.insert().into("person", {"id", "name", "age"}).values({5, "charlie", 67}).execute();
REQUIRE(res == 1);
auto result = db.select({alias(count("age"), "age_count"), "age"})
auto result = ses.select({alias(count("age"), "age_count"), "age"})
.from("person")
.group_by("age")
.order_by("age_count").desc()
@ -329,41 +328,41 @@ TEST_CASE_METHOD(SessionRecordFixture, " Execute select statement with group by
expected_values.pop_front();
}
db.drop().table("person").execute();
ses.drop().table("person").execute();
}
TEST_CASE_METHOD(SessionRecordFixture, " Execute delete statement", "[session][record]")
{
db.create()
ses.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
make_column<unsigned short>("age")
}).execute();
auto res = db.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
auto res = ses.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
REQUIRE(res == 1);
res = db.insert().into("person", {"id", "name", "age"}).values({2, "jane", 45}).execute();
res = ses.insert().into("person", {"id", "name", "age"}).values({2, "jane", 45}).execute();
REQUIRE(res == 1);
auto count = db.select({count_all()}).from("person").fetch_value<int>();
auto count = ses.select({count_all()}).from("person").fetch_value<int>();
REQUIRE(count == 2);
res = db.remove()
res = ses.remove()
.from("person")
.where("id"_col == 1)
.execute();
REQUIRE(res == 1);
count = db.select({count_all()}).from("person").fetch_value<int>();
count = ses.select({count_all()}).from("person").fetch_value<int>();
REQUIRE(count == 1);
db.drop().table("person").execute();
ses.drop().table("person").execute();
}
TEST_CASE_METHOD(SessionRecordFixture, " Test quoted identifier", "[session][record]") {
db.create()
ses.create()
.table("quotes", {
make_column<std::string>("from", 255),
make_column<std::string>("to", 255)
@ -372,26 +371,26 @@ TEST_CASE_METHOD(SessionRecordFixture, " Test quoted identifier", "[session][rec
// check table description
std::vector<std::string> columns = { "from", "to"};
std::vector<data_type_t> types = {data_type_t::type_varchar, data_type_t::type_varchar};
auto fields = db.describe("quotes");
auto fields = ses.describe_table("quotes");
for (const auto &field : fields) {
REQUIRE(field.name() == columns[field.index()]);
REQUIRE(field.type() == types[field.index()]);
}
db.insert().into("quotes", {"from", "to"}).values({"Berlin", "London"}).execute();
ses.insert().into("quotes", {"from", "to"}).values({"Berlin", "London"}).execute();
auto res = db.select({"from", "to"}).from("quotes").fetch_one();
auto res = ses.select({"from", "to"}).from("quotes").fetch_one();
REQUIRE("Berlin" == res.at("from").str());
REQUIRE("London" == res.at("to").str());
db.update("quotes").set({{"from", "Hamburg"}, {"to", "New York"}}).where("from"_col == "Berlin").execute();
ses.update("quotes").set({{"from", "Hamburg"}, {"to", "New York"}}).where("from"_col == "Berlin").execute();
res = db.select({"from", "to"}).from("quotes").fetch_one();
res = ses.select({"from", "to"}).from("quotes").fetch_one();
REQUIRE("Hamburg" == res.at("from").str());
REQUIRE("New York" == res.at("to").str());
db.drop().table("quotes").execute();
ses.drop().table("quotes").execute();
}

77
backends/tests/SessionTest.cpp
View File

@ -13,66 +13,65 @@
using namespace matador::sql;
using namespace matador::test;
class QueryFixture
class SessionFixture
{
public:
QueryFixture()
: db(matador::test::connection::dns)
{
db.open();
}
~QueryFixture() {
SessionFixture()
: pool(matador::test::connection::dns, 4), ses(pool)
{}
~SessionFixture() {
drop_table_if_exists("flight");
drop_table_if_exists("airplane");
drop_table_if_exists("person");
}
protected:
matador::sql::connection db;
matador::sql::connection_pool<matador::sql::connection> pool;
matador::sql::session ses;
private:
void drop_table_if_exists(const std::string &table_name) {
if (db.exists(table_name)) {
db.drop().table(table_name).execute();
if (ses.table_exists(table_name)) {
ses.drop().table(table_name).execute();
}
}
};
TEST_CASE_METHOD(QueryFixture, " Create table with foreign key relation", "[session]") {
db.create()
TEST_CASE_METHOD(SessionFixture, " Create table with foreign key relation", "[session]") {
ses.create()
.table<airplane>("airplane")
.execute();
REQUIRE(db.exists("airplane"));
REQUIRE(ses.table_exists("airplane"));
db.create()
ses.create()
.table<flight>("flight")
.execute();
REQUIRE(db.exists("flight"));
REQUIRE(ses.table_exists("flight"));
db.drop().table("flight").execute();
db.drop().table("airplane").execute();
ses.drop().table("flight").execute();
ses.drop().table("airplane").execute();
REQUIRE(!db.exists("flight"));
REQUIRE(!db.exists("airplane"));
REQUIRE(!ses.table_exists("flight"));
REQUIRE(!ses.table_exists("airplane"));
}
TEST_CASE_METHOD(QueryFixture, " Execute select statement with where clause", "[session]") {
db.create()
TEST_CASE_METHOD(SessionFixture, " Execute select statement with where clause", "[session]") {
ses.create()
.table<person>("person")
.execute();
person george{7, "george", 45};
george.image.push_back(37);
auto res = db.insert()
auto res = ses.insert()
.into("person", george)
.execute();
REQUIRE(res == 1);
// fetch person as record
auto result_record = db.select<person>()
auto result_record = ses.select<person>()
.from("person")
.where("id"_col == 7)
.fetch_all();
@ -91,7 +90,7 @@ TEST_CASE_METHOD(QueryFixture, " Execute select statement with where clause", "[
}
// fetch person as person
auto result_person = db.select<person>()
auto result_person = ses.select<person>()
.from("person")
.where("id"_col == 7)
.fetch_all<person>();
@ -102,11 +101,11 @@ TEST_CASE_METHOD(QueryFixture, " Execute select statement with where clause", "[
REQUIRE(i.age == 45);
}
db.drop().table("person").execute();
ses.drop().table("person").execute();
}
TEST_CASE_METHOD(QueryFixture, " Execute insert statement", "[session]") {
db.create()
TEST_CASE_METHOD(SessionFixture, " Execute insert statement", "[session]") {
ses.create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("name", 255),
@ -114,7 +113,7 @@ TEST_CASE_METHOD(QueryFixture, " Execute insert statement", "[session]") {
})
.execute();
auto res = db.insert()
auto res = ses.insert()
.into("person", {"id", "name", "color"})
.values({7, "george", "green"})
.execute();
@ -122,7 +121,7 @@ TEST_CASE_METHOD(QueryFixture, " Execute insert statement", "[session]") {
REQUIRE(res == 1);
// fetch person as record
auto result_record = db.select({"id", "name", "color"})
auto result_record = ses.select({"id", "name", "color"})
.from("person")
.where("id"_col == 7)
.fetch_all();
@ -140,15 +139,15 @@ TEST_CASE_METHOD(QueryFixture, " Execute insert statement", "[session]") {
REQUIRE(i.at(2).as<std::string>() == "green");
}
db.drop().table("person").execute();
ses.drop().table("person").execute();
}
TEST_CASE_METHOD(QueryFixture, " Select statement with foreign key", "[session]") {
db.create()
TEST_CASE_METHOD(SessionFixture, " Select statement with foreign key", "[session]") {
ses.create()
.table<airplane>("airplane")
.execute();
db.create()
ses.create()
.table<flight>("flight")
.execute();
@ -159,24 +158,24 @@ TEST_CASE_METHOD(QueryFixture, " Select statement with foreign key", "[session]"
};
for (const auto &plane : planes) {
auto res = db.insert().into<airplane>("airplane").values(*plane).execute();
auto res = ses.insert().into<airplane>("airplane").values(*plane).execute();
REQUIRE(res == 1);
}
auto count = db.select({count_all()}).from("airplane").fetch_value<int>();
auto count = ses.select({count_all()}).from("airplane").fetch_value<int>();
REQUIRE(count == 3);
flight f4711{4, planes.at(1), "hans"};
auto res = db.insert().into<flight>("flight").values(f4711).execute();
auto res = ses.insert().into<flight>("flight").values(f4711).execute();
REQUIRE(res == 1);
auto f = *db.select<flight>().from("flight").fetch_all<flight>().begin();
auto f = *ses.select<flight>().from("flight").fetch_all<flight>().begin();
REQUIRE(f.id == 4);
REQUIRE(f.pilot_name == "hans");
REQUIRE(f.airplane.get() != nullptr);
REQUIRE(f.airplane->id == 2);
db.drop().table("flight").execute();
db.drop().table("airplane").execute();
ses.drop().table("flight").execute();
ses.drop().table("airplane").execute();
}

24
backends/tests/StatementTest.cpp
View File

@ -2,7 +2,9 @@
#include "matador/sql/column.hpp"
#include "matador/sql/condition.hpp"
#include "matador/sql/connection.hpp"
#include "matador/sql/connection_info.hpp"
#include "matador/sql/connection_pool.hpp"
#include "matador/sql/session.hpp"
#include "connection.hpp"
@ -15,10 +17,9 @@ class StatementTestFixture
{
public:
StatementTestFixture()
: db(matador::test::connection::dns)
: pool(matador::test::connection::dns, 4), ses(pool)
{
db.open();
db.create().table<airplane>("airplane").execute();
ses.create().table<airplane>("airplane").execute();
}
~StatementTestFixture()
@ -27,7 +28,8 @@ public:
}
protected:
matador::sql::connection db;
matador::sql::connection_pool<matador::sql::connection> pool;
matador::sql::session ses;
std::vector<entity<airplane>> planes{
make_entity<airplane>(1, "Airbus", "A380"),
@ -37,8 +39,8 @@ protected:
private:
void drop_table_if_exists(const std::string &table_name) {
if (db.exists(table_name)) {
db.drop().table(table_name).execute();
if (ses.table_exists(table_name)) {
ses.drop().table(table_name).execute();
}
}
@ -47,7 +49,7 @@ private:
TEST_CASE_METHOD(StatementTestFixture, " Create prepared statement", "[statement]")
{
SECTION("Insert with prepared statement and placeholder") {
auto stmt = db.insert()
auto stmt = ses.insert()
.into<airplane>("airplane")
.values<airplane>().prepare();
@ -57,7 +59,7 @@ TEST_CASE_METHOD(StatementTestFixture, " Create prepared statement", "[statement
stmt.reset();
}
auto result = db.select<airplane>().from("airplane").fetch_all<airplane>();
auto result = ses.select<airplane>().from("airplane").fetch_all<airplane>();
size_t index{0};
for (const auto &i: result) {
@ -69,11 +71,11 @@ TEST_CASE_METHOD(StatementTestFixture, " Create prepared statement", "[statement
SECTION("Select with prepared statement") {
for (const auto &plane: planes) {
auto res = db.insert().into<airplane>("airplane").values(*plane).execute();
auto res = ses.insert().into<airplane>("airplane").values(*plane).execute();
REQUIRE(res == 1);
}
auto stmt = db.select<airplane>().from("airplane").where("brand"_col == _).prepare();
auto stmt = ses.select<airplane>().from("airplane").where("brand"_col == _).prepare();
stmt.bind(0, "Airbus");

24
backends/tests/TypeTraitsTest.cpp
View File

@ -1,6 +1,6 @@
#include <catch2/catch_test_macros.hpp>
#include "matador/sql/connection.hpp"
#include "matador/sql/session.hpp"
#include "matador/utils/enum_mapper.hpp"
@ -14,26 +14,26 @@ class TypeTraitsTestFixture
{
public:
TypeTraitsTestFixture()
: db(matador::test::connection::dns)
: pool(matador::test::connection::dns, 4), ses(pool)
{
db.open();
db.create()
ses.create()
.table<location>("location")
.execute();
}
~TypeTraitsTestFixture()
{
db.drop().table("location").execute();
ses.drop().table("location").execute();
}
protected:
matador::sql::connection db;
matador::sql::connection_pool<matador::sql::connection> pool;
matador::sql::session ses;
private:
void drop_table_if_exists(const std::string &table_name) {
if (db.exists(table_name)) {
db.drop().table(table_name).execute();
if (ses.table_exists(table_name)) {
ses.drop().table(table_name).execute();
}
}
};
@ -85,10 +85,10 @@ TEST_CASE_METHOD(TypeTraitsTestFixture, "Special handling of attributes with typ
SECTION("Insert and select with direct execution") {
location loc{1, "center", {1, 2, 3}, Color::Black};
auto res = db.insert().into<location>("location").values(loc).execute();
auto res = ses.insert().into<location>("location").values(loc).execute();
REQUIRE(res == 1);
auto result = db.select<location>().from("location").fetch_all<location>();
auto result = ses.select<location>().from("location").fetch_all<location>();
for (const auto &l: result) {
REQUIRE(l.name == "center");
@ -98,11 +98,11 @@ TEST_CASE_METHOD(TypeTraitsTestFixture, "Special handling of attributes with typ
SECTION("Insert and select with prepared statement") {
location loc{1, "center", {1, 2, 3}, Color::Black};
auto stmt = db.insert().into<location>("location").values<location>().prepare();
auto stmt = ses.insert().into<location>("location").values<location>().prepare();
auto res = stmt.bind(loc).execute();
REQUIRE(res == 1);
auto result = db.select<location>().from("location").
auto result = ses.select<location>().from("location").
template fetch_all<location>();
for (const auto &l: result) {

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

@ -4,7 +4,6 @@
#include "matador/sql/connection_info.hpp"
#include "matador/sql/connection_impl.hpp"
#include "matador/sql/dialect.hpp"
#include "matador/sql/query_intermediates.hpp"
#include "matador/sql/query_context.hpp"
#include "matador/sql/query_result.hpp"
#include "matador/sql/record.hpp"
@ -19,11 +18,12 @@ namespace matador::sql {
class connection
{
public:
explicit connection(connection_info info, const std::shared_ptr<table_repository> &repo = std::make_shared<table_repository>());
explicit connection(const std::string& dns, const std::shared_ptr<table_repository> &repo = std::make_shared<table_repository>());
explicit connection(connection_info info);
explicit connection(const std::string& dns);
connection(const connection &x);
connection& operator=(const connection &x);
connection(connection &&x) noexcept = default;
connection& operator=(connection &&x) noexcept = default;
~connection();
void open();
@ -31,41 +31,22 @@ public:
[[nodiscard]] bool is_open() const;
[[nodiscard]] const connection_info& info() const;
query_create_intermediate create();
query_drop_intermediate drop();
template < class Type >
query_select_intermediate select();
query_select_intermediate select(std::initializer_list<column> columns);
query_insert_intermediate insert();
query_update_intermediate update(const std::string &table);
query_delete_intermediate remove();
[[nodiscard]] record describe(const std::string &table_name) const;
[[nodiscard]] bool exists(const std::string &schema_name, const std::string &table_name) const;
[[nodiscard]] bool exists(const std::string &table_name) const;
query_result<record> fetch(const query_context &q) const;
[[nodiscard]] std::unique_ptr<query_result_impl> fetch(const std::string &sql) const;
[[nodiscard]] size_t execute(const std::string &sql) const;
statement prepare(query_context &&query) const;
const class dialect& dialect() const;
std::shared_ptr<table_repository> tables() const;
private:
connection_info connection_info_;
std::unique_ptr<connection_impl> connection_;
utils::logger logger_;
const class dialect &dialect_;
std::shared_ptr<table_repository> table_repository_;
};
template<class Type>
query_select_intermediate connection::select()
{
return query_select_intermediate{*this, column_generator::generate<Type>(*table_repository_)};
}
}
#endif //QUERY_CONNECTION_HPP

4
include/matador/sql/dialect.hpp
View File

@ -30,8 +30,6 @@ public:
COLUMNS,
COLUMN,
FROM,
JOIN,
ON,
INTO,
WHERE,
WHERE_CLAUSE,
@ -163,8 +161,6 @@ private:
{token_t::COLUMNS, "COLUMNS"},
{token_t::COLUMN, "COLUMN"},
{token_t::FROM, "FROM"},
{token_t::JOIN, "INNER JOIN"},
{token_t::ON, "ON"},
{token_t::WHERE, "WHERE"},
{token_t::AND, "AND"},
{token_t::OR, "OR"},

4
include/matador/sql/query_builder.hpp
View File

@ -80,8 +80,6 @@ private:
QUERY_DELETE,
QUERY_SET,
QUERY_FROM,
QUERY_JOIN,
QUERY_ON,
QUERY_INTO,
QUERY_WHERE,
QUERY_VALUES,
@ -131,7 +129,7 @@ public:
query_builder& values(std::initializer_list<any_type> values);
query_builder& values(const std::vector<any_type> &values);
query_builder& from(const std::string &table, const std::string &as = "");
query_builder& join(const std::string &table, join_type_t, const std::string &as = "");
query_builder& join(const std::string &table, join_type_t);
query_builder& on(const std::string &column, const std::string &join_column);
query_builder& set(std::initializer_list<key_value_pair> key_values);
query_builder& set(const std::vector<key_value_pair> &key_values);

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

@ -19,15 +19,15 @@
namespace matador::sql {
class basic_condition;
class connection;
class session;
class query_intermediate
{
public:
query_intermediate(connection &db, query_builder &query);
query_intermediate(session &db, query_builder &query);
protected:
connection &connection_;
session &session_;
query_builder &builder_;
};
@ -130,17 +130,17 @@ public:
class query_start_intermediate
{
public:
explicit query_start_intermediate(connection &s);
explicit query_start_intermediate(session &s);
protected:
connection &connection_;
session &session_;
query_builder builder_;
};
class query_select_intermediate : public query_start_intermediate
{
public:
query_select_intermediate(connection &s, const std::vector<column>& columns);
query_select_intermediate(session &s, const std::vector<column>& columns);
query_from_intermediate from(const std::string &table, const std::string &as = "");
};
@ -164,38 +164,36 @@ public:
query_execute_finish values()
{
Type obj;
return {connection_, builder_.values(as_placeholder(obj))};
return {session_, builder_.values(as_placeholder(obj))};
}
template<class Type>
query_execute_finish values(const Type &obj)
{
return {connection_, builder_.values(value_extractor::extract(obj))};
return {session_, builder_.values(value_extractor::extract(obj))};
}
};
class query_create_intermediate : public query_start_intermediate
class query_create_intermediate : query_start_intermediate
{
public:
explicit query_create_intermediate(connection &db);
query_create_intermediate(session &s, table_repository &repo);
query_execute_finish table(const std::string &table, std::initializer_list<column> columns);
template<class Type>
query_execute_finish table(const std::string &table_name)
{
if (!tables()->exists<Type>()) {
tables()->attach<Type>(table_name);
}
return {connection_, builder_.table(table_name, column_generator::generate<Type>(*tables()))};
const auto &info = repository_.attach<Type>(table_name);
return {session_, builder_.table(table_name, info.prototype.columns())};
}
private:
std::shared_ptr<table_repository> tables() const;
table_repository &repository_;
};
class query_drop_intermediate : query_start_intermediate
{
public:
explicit query_drop_intermediate(connection &s);
explicit query_drop_intermediate(session &s);
query_execute_finish table(const std::string &table);
};
@ -203,18 +201,18 @@ public:
class query_insert_intermediate : public query_start_intermediate
{
public:
explicit query_insert_intermediate(connection &s);
explicit query_insert_intermediate(session &s);
query_into_intermediate into(const std::string &table, std::initializer_list<std::string> column_names);
template<class Type>
query_into_intermediate into(const std::string &table)
{
return {connection_, builder_.into(table, column_name_generator::generate<Type>())};
return {session_, builder_.into(table, column_name_generator::generate<Type>())};
}
template<class Type>
query_execute_finish into(const std::string &table, const Type &obj)
{
return {connection_, builder_.into(table, column_name_generator::generate<Type>())
return {session_, builder_.into(table, column_name_generator::generate<Type>())
.values(value_extractor::extract(obj))};
}
};
@ -238,13 +236,13 @@ public:
class query_update_intermediate : public query_start_intermediate
{
public:
query_update_intermediate(connection &s, const std::string& table_name);
query_update_intermediate(session &s, const std::string& table_name);
query_set_intermediate set(std::initializer_list<key_value_pair> columns);
template<class Type>
query_set_intermediate set(const Type &obj)
{
return {connection_, builder_.set(key_value_generator::generate(obj))};
return {session_, builder_.set(key_value_generator::generate(obj))};
}
};
@ -259,7 +257,7 @@ public:
class query_delete_intermediate : public query_start_intermediate
{
public:
explicit query_delete_intermediate(connection &s);
explicit query_delete_intermediate(session &s);
query_delete_from_intermediate from(const std::string &table);
};

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

@ -68,8 +68,6 @@ public:
[[nodiscard]] bool empty() const;
void clear();
[[nodiscard]] bool unknown() const;
private:
void init();
void add_to_map(column &col, size_t index);

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

@ -20,6 +20,15 @@ class session
public:
explicit session(connection_pool<connection> &pool);
query_create_intermediate create();
query_drop_intermediate drop();
template < class Type >
query_select_intermediate select();
query_select_intermediate select(std::initializer_list<column> columns);
query_insert_intermediate insert();
query_update_intermediate update(const std::string &table);
query_delete_intermediate remove();
[[nodiscard]] query_result<record> fetch(const query_context &q) const;
// [[nodiscard]] query_result<record> fetch(const std::string &sql) const;
[[nodiscard]] size_t execute(const std::string &sql) const;
@ -51,5 +60,11 @@ private:
mutable std::unordered_map<std::string, record> prototypes_;
};
template<class Type>
query_select_intermediate session::select()
{
return query_select_intermediate{*this, column_generator::generate<Type>(table_repository_)};
}
}
#endif //QUERY_SESSION_HPP

9
include/matador/sql/table_repository.hpp
View File

@ -44,18 +44,11 @@ public:
[[nodiscard]] std::pair<std::string, std::string> reference(const std::type_index &ti) const;
template<typename Type>
[[nodiscard]] bool exists() const
{
return exists(std::type_index(typeid(Type)));
}
[[nodiscard]] bool exists(const std::type_index &ti) const;
private:
using repository = std::unordered_map<std::type_index, table_info>;
repository repository_;
};
;
}

73
src/sql/connection.cpp
View File

@ -8,17 +8,16 @@
namespace matador::sql {
connection::connection(connection_info info, const std::shared_ptr<table_repository> &repo)
connection::connection(connection_info info)
: connection_info_(std::move(info))
, logger_(stdout, "SQL")
, dialect_(backend_provider::instance().connection_dialect(connection_info_.type))
, table_repository_(repo)
, dialect_(backend_provider::instance().connection_dialect(info.type))
{
connection_.reset(backend_provider::instance().create_connection(connection_info_.type, connection_info_));
}
connection::connection(const std::string& dns, const std::shared_ptr<table_repository> &repo)
: connection(connection_info::parse(dns), repo)
connection::connection(const std::string& dns)
: connection(connection_info::parse(dns))
{}
connection::connection(const connection &x)
@ -69,36 +68,6 @@ const connection_info &connection::info() const
return connection_info_;
}
query_create_intermediate connection::create()
{
return query_create_intermediate(*this);
}
query_drop_intermediate connection::drop()
{
return query_drop_intermediate{*this};
}
query_select_intermediate connection::select(std::initializer_list<column> columns)
{
return {*this, columns};
}
query_insert_intermediate connection::insert()
{
return query_insert_intermediate{*this};
}
query_update_intermediate connection::update(const std::string &table)
{
return query_update_intermediate{*this, table};
}
query_delete_intermediate connection::remove()
{
return query_delete_intermediate{*this};
}
record connection::describe(const std::string &table_name) const
{
return std::move(connection_->describe(table_name));
@ -109,41 +78,12 @@ bool connection::exists(const std::string &schema_name, const std::string &table
return connection_->exists(schema_name, table_name);
}
bool connection::exists(const std::string &table_name) const
{
return connection_->exists(dialect_.default_schema_name(), table_name);
}
size_t connection::execute(const std::string &sql) const
{
logger_.debug(sql);
return connection_->execute(sql);
}
query_result<record> connection::fetch(const query_context &q) const
{
if (q.prototype.empty() || q.prototype.unknown()) {
const auto table_prototype = describe(q.table_name);
for (auto &col : q.prototype) {
if (const auto rit = table_prototype.find(col.name()); col.type() == data_type_t::type_unknown && rit != table_prototype.end()) {
const_cast<column&>(col).type(rit->type());
}
}
}
// auto it = prototypes_.find(q.table_name);
// if (it == prototypes_.end()) {
// it = prototypes_.emplace(q.table_name, describe(q.table_name)).first;
// }
// // adjust columns from given query
// for (auto &col : q.prototype) {
// if (const auto rit = it->second.find(col.name()); col.type() == data_type_t::type_unknown && rit != it->second.end()) {
// const_cast<column&>(col).type(rit->type());
// }
// }
auto res = fetch(q.sql);
return query_result<record>{std::move(res), q.prototype};
}
std::unique_ptr<query_result_impl> connection::fetch(const std::string &sql) const
{
logger_.debug(sql);
@ -160,9 +100,4 @@ const class dialect &connection::dialect() const
return dialect_;
}
std::shared_ptr<table_repository> connection::tables() const
{
return table_repository_;
}
}

31
src/sql/query_builder.cpp
View File

@ -10,8 +10,7 @@ namespace matador::sql {
namespace detail {
any_type_to_string_visitor::any_type_to_string_visitor(const dialect &d, query_context &query)
: d(d), query(query)
{}
: d(d), query(query) {}
void any_type_to_string_visitor::to_string(const char *val)
{
@ -53,10 +52,8 @@ query_builder::query_state_transition_map query_builder::transitions_{
{state_t::QUERY_DELETE, {state_t::QUERY_FROM}},
{state_t::QUERY_TABLE_CREATE, {state_t::QUERY_FINISH}},
{state_t::QUERY_TABLE_DROP, {state_t::QUERY_FINISH}},
{state_t::QUERY_FROM, {state_t::QUERY_OFFSET, state_t::QUERY_LIMIT, state_t::QUERY_WHERE, state_t::QUERY_ORDER_BY, state_t::QUERY_GROUP_BY, state_t::QUERY_JOIN, state_t::QUERY_FINISH}},
{state_t::QUERY_FROM, {state_t::QUERY_OFFSET, state_t::QUERY_LIMIT, state_t::QUERY_WHERE, state_t::QUERY_ORDER_BY, state_t::QUERY_GROUP_BY, state_t::QUERY_FINISH}},
{state_t::QUERY_SET, {state_t::QUERY_WHERE, state_t::QUERY_FINISH}},
{state_t::QUERY_JOIN, {state_t::QUERY_ON}},
{state_t::QUERY_ON, {state_t::QUERY_OFFSET, state_t::QUERY_LIMIT, state_t::QUERY_WHERE, state_t::QUERY_ORDER_BY, state_t::QUERY_GROUP_BY, state_t::QUERY_JOIN, state_t::QUERY_FINISH}},
{state_t::QUERY_INTO, {state_t::QUERY_VALUES}},
{state_t::QUERY_WHERE, {state_t::QUERY_ORDER_BY, state_t::QUERY_GROUP_BY, state_t::QUERY_OFFSET, state_t::QUERY_LIMIT, state_t::QUERY_FINISH}},
{state_t::QUERY_ORDER_BY, {state_t::QUERY_ORDER_DIRECTION}},
@ -327,38 +324,26 @@ query_builder &query_builder::from(const std::string &table, const std::string &
if (dialect_.default_schema_name().empty()) {
query_parts_.emplace_back(dialect::token_t::FROM, " " + dialect_.token_at(dialect::token_t::FROM) +
" " + dialect_.prepare_identifier(table) +
(as.empty() ? "" : " AS " + dialect_.prepare_identifier(as)));
" " + dialect_.prepare_identifier(table) +
(as.empty() ? "" : " " + as));
} else {
query_parts_.emplace_back(dialect::token_t::FROM, " " + dialect_.token_at(dialect::token_t::FROM) +
" " + dialect_.prepare_identifier(dialect_.default_schema_name()) +
"." + dialect_.prepare_identifier(table) +
(as.empty() ? "" : " AS " + dialect_.prepare_identifier(as)));
" " + dialect_.prepare_identifier(dialect_.default_schema_name()) +
"." + dialect_.prepare_identifier(table) +
(as.empty() ? "" : " " + as));
}
query_.table_name = table;
return *this;
}
query_builder &query_builder::join(const std::string &table, join_type_t, const std::string &as)
query_builder &query_builder::join(const std::string &table, join_type_t)
{
transition_to(state_t::QUERY_JOIN);
query_parts_.emplace_back(dialect::token_t::JOIN, " " + dialect_.token_at(dialect::token_t::JOIN) +
" " + dialect_.prepare_identifier(table) +
(as.empty() ? "" : " AS " + dialect_.prepare_identifier(as)));
return *this;
}
query_builder &query_builder::on(const std::string &column, const std::string &join_column)
{
transition_to(state_t::QUERY_ON);
query_parts_.emplace_back(dialect::token_t::ON, " " + dialect_.token_at(dialect::token_t::ON) +
" " + dialect_.prepare_identifier(column) +
"=" + dialect_.prepare_identifier(join_column));
return *this;
}

82
src/sql/query_intermediates.cpp
View File

@ -5,83 +5,83 @@ namespace matador::sql {
query_result<record> query_select_finish::fetch_all()
{
return connection_.fetch(builder_.compile());
return session_.fetch(builder_.compile());
}
record query_select_finish::fetch_one()
{
return *connection_.fetch(builder_.compile()).begin().get();
return *session_.fetch(builder_.compile()).begin().get();
}
std::unique_ptr<query_result_impl> query_select_finish::fetch()
{
return connection_.fetch(builder_.compile().sql);
return session_.fetch(builder_.compile().sql);
}
statement query_select_finish::prepare()
{
return connection_.prepare(builder_.compile());
return session_.prepare(builder_.compile());
}
query_intermediate::query_intermediate(connection &db, query_builder &query)
: connection_(db), builder_(query) {}
query_intermediate::query_intermediate(session &db, query_builder &query)
: session_(db), builder_(query) {}
query_offset_intermediate query_order_direction_intermediate::offset(size_t offset)
{
return {connection_, builder_};
return {session_, builder_};
}
query_limit_intermediate query_offset_intermediate::limit(size_t limit)
{
return {connection_, builder_};
return {session_, builder_};
}
query_limit_intermediate query_order_direction_intermediate::limit(size_t limit)
{
return {connection_, builder_};
return {session_, builder_};
}
query_order_by_intermediate query_group_by_intermediate::order_by(const std::string &name)
{
return {connection_, builder_.order_by(name)};
return {session_, builder_.order_by(name)};
}
query_order_direction_intermediate query_order_by_intermediate::asc()
{
return {connection_, builder_.asc()};
return {session_, builder_.asc()};
}
query_order_direction_intermediate query_order_by_intermediate::desc()
{
return {connection_, builder_.desc()};
return {session_, builder_.desc()};
}
query_group_by_intermediate query_from_intermediate::group_by(const std::string &name)
{
return {connection_, builder_.group_by(name)};
return {session_, builder_.group_by(name)};
}
query_order_by_intermediate query_from_intermediate::order_by(const std::string &name)
{
return {connection_, builder_.order_by(name)};
return {session_, builder_.order_by(name)};
}
query_group_by_intermediate query_where_intermediate::group_by(const std::string &name)
{
return {connection_, builder_.group_by(name)};
return {session_, builder_.group_by(name)};
}
query_order_by_intermediate query_where_intermediate::order_by(const std::string &name)
{
return {connection_, builder_.order_by(name)};
return {session_, builder_.order_by(name)};
}
query_where_intermediate query_from_intermediate::where(const basic_condition &cond)
{
return query_where_intermediate{connection_, builder_.where(cond)};
return query_where_intermediate{session_, builder_.where(cond)};
}
query_select_intermediate::query_select_intermediate(connection &s, const std::vector<column>& columns)
query_select_intermediate::query_select_intermediate(session &s, const std::vector<column>& columns)
: query_start_intermediate(s)
{
builder_.select(columns);
@ -89,10 +89,10 @@ query_select_intermediate::query_select_intermediate(connection &s, const std::v
query_from_intermediate query_select_intermediate::from(const std::string &table, const std::string &as)
{
return {connection_, builder_.from(table, as)};
return {session_, builder_.from(table, as)};
}
query_insert_intermediate::query_insert_intermediate(connection &s)
query_insert_intermediate::query_insert_intermediate(session &s)
: query_start_intermediate(s)
{
builder_.insert();
@ -100,40 +100,36 @@ query_insert_intermediate::query_insert_intermediate(connection &s)
query_into_intermediate query_insert_intermediate::into(const std::string &table, std::initializer_list<std::string> column_names)
{
return {connection_, builder_.into(table, column_names)};
return {session_, builder_.into(table, column_names)};
}
size_t query_execute_finish::execute()
{
return connection_.execute(builder_.compile().sql);
return session_.execute(builder_.compile().sql);
}
statement query_execute_finish::prepare()
{
return connection_.prepare(builder_.compile());
return session_.prepare(builder_.compile());
}
query_execute_finish query_into_intermediate::values(std::initializer_list<any_type> values)
{
return {connection_, builder_.values(values)};
return {session_, builder_.values(values)};
}
query_create_intermediate::query_create_intermediate(connection &db)
: query_start_intermediate(db) {
query_create_intermediate::query_create_intermediate(session &s, table_repository &repo)
: query_start_intermediate(s)
, repository_(repo) {
builder_.create();
}
query_execute_finish query_create_intermediate::table(const std::string &table, std::initializer_list<column> columns)
{
return {connection_, builder_.table(table, columns)};
return {session_, builder_.table(table, columns)};
}
std::shared_ptr<table_repository> query_create_intermediate::tables() const
{
return connection_.tables();
}
query_drop_intermediate::query_drop_intermediate(connection &s)
query_drop_intermediate::query_drop_intermediate(session &s)
: query_start_intermediate(s)
{
builder_.drop();
@ -141,20 +137,20 @@ query_drop_intermediate::query_drop_intermediate(connection &s)
query_execute_finish query_drop_intermediate::table(const std::string &table)
{
return {connection_, builder_.table(table)};
return {session_, builder_.table(table)};
}
query_execute_finish query_execute_where_intermediate::limit(int limit)
{
return {connection_, builder_.limit(limit)};
return {session_, builder_.limit(limit)};
}
query_execute_where_intermediate query_set_intermediate::where(const basic_condition &cond)
{
return {connection_, builder_.where(cond)};
return {session_, builder_.where(cond)};
}
query_update_intermediate::query_update_intermediate(connection &s, const std::string& table_name)
query_update_intermediate::query_update_intermediate(session &s, const std::string& table_name)
: query_start_intermediate(s)
{
builder_.update(table_name);
@ -162,15 +158,15 @@ query_update_intermediate::query_update_intermediate(connection &s, const std::s
query_set_intermediate query_update_intermediate::set(std::initializer_list<key_value_pair> columns)
{
return {connection_, builder_.set(columns)};
return {session_, builder_.set(columns)};
}
query_execute_where_intermediate query_delete_from_intermediate::where(const basic_condition &cond)
{
return {connection_, builder_.where(cond)};
return {session_, builder_.where(cond)};
}
query_delete_intermediate::query_delete_intermediate(connection &s)
query_delete_intermediate::query_delete_intermediate(session &s)
: query_start_intermediate(s)
{
builder_.remove();
@ -178,11 +174,11 @@ query_delete_intermediate::query_delete_intermediate(connection &s)
query_delete_from_intermediate query_delete_intermediate::from(const std::string &table)
{
return {connection_, builder_.from(table)};
return {session_, builder_.from(table)};
}
query_start_intermediate::query_start_intermediate(connection &s)
: connection_(s)
query_start_intermediate::query_start_intermediate(session &s)
: session_(s)
, builder_(s.dialect())
{}
}

8
src/sql/record.cpp
View File

@ -1,6 +1,5 @@
#include "matador/sql/record.hpp"
#include <algorithm>
#include <stdexcept>
namespace matador::sql {
@ -134,13 +133,6 @@ void record::clear()
columns_by_name_.clear();
}
bool record::unknown() const
{
return std::all_of(std::begin(columns_), std::end(columns_), [](const auto &col) {
return col.type() == data_type_t::type_unknown;
});
}
void record::init()
{
size_t index{0};

30
src/sql/session.cpp
View File

@ -10,6 +10,36 @@ session::session(connection_pool<connection> &pool)
: pool_(pool)
, dialect_(backend_provider::instance().connection_dialect(pool_.info().type)) {}
query_create_intermediate session::create()
{
return query_create_intermediate{*this, table_repository_};
}
query_drop_intermediate session::drop()
{
return query_drop_intermediate{*this};
}
query_select_intermediate session::select(std::initializer_list<column> columns)
{
return {*this, columns};
}
query_insert_intermediate session::insert()
{
return query_insert_intermediate{*this};
}
query_update_intermediate session::update(const std::string &table)
{
return query_update_intermediate{*this, table};
}
query_delete_intermediate session::remove()
{
return query_delete_intermediate{*this};
}
query_result<record> session::fetch(const query_context &q) const
{
auto c = pool_.acquire();

5
src/sql/table_repository.cpp
View File

@ -31,9 +31,4 @@ std::pair<std::string, std::string> table_repository::reference(const std::type_
return {};
}
bool table_repository::exists(const std::type_index &ti) const
{
return repository_.count(ti) > 0;
}
}

1
test/CMakeLists.txt
View File

@ -23,6 +23,7 @@ add_executable(tests QueryBuilderTest.cpp
models/person.hpp
AnyTypeToVisitorTest.cpp
ColumnTest.cpp
StatementCacheTest.cpp
models/coordinate.hpp
models/location.hpp
models/optional.hpp

10
test/QueryBuilderTest.cpp
View File

@ -175,13 +175,3 @@ TEST_CASE("Create, insert and select a blob column", "[query][blob]") {
REQUIRE(q.sql == R"(SELECT "id", "name", "data" FROM "person")");
REQUIRE(q.table_name == "person");
}
TEST_CASE("Select statement with join", "[query][join]") {
dialect d = dialect_builder::builder().create().build();
query_builder query(d);
auto q = query.select({"f.id", "ap.brand", "f.pilot_name"}).from("flight", "f").join("airplane", join_type_t::INNER, "ap").on("f.airplane_id", "ap.id").compile();
REQUIRE(q.sql == R"(SELECT "f.id", "ap.brand", "f.pilot_name" FROM "flight" AS "f" INNER JOIN "airplane" AS "ap" ON "f.airplane_id"="ap.id")");
REQUIRE(q.table_name == "flight");
}

22
backends/tests/StatementCacheTest.cpp → test/StatementCacheTest.cpp
View File

@ -5,28 +5,18 @@
#include "matador/sql/session.hpp"
#include "matador/sql/statement_cache.hpp"
#include "connection.hpp"
using namespace matador;
class StatementCacheFixture
{
public:
StatementCacheFixture()
: pool(matador::test::connection::dns, 4), ses(pool)
{}
~StatementCacheFixture() = default;
protected:
matador::sql::connection_pool<matador::sql::connection> pool;
matador::sql::session ses;
};
TEST_CASE_METHOD(StatementCacheFixture, " Acquire prepared statement", "[statement cache]") {
TEST_CASE("Acquire prepared statement", "[statement cache]") {
sql::statement_cache cache;
sql::connection_pool<sql::connection> pool("sqlite://sqlite.db", 4);
sql::session s(pool);
auto conn = pool.acquire();
std::string sql = R"(SELECT * FROM person WHERE name = 'george')";
// auto &stmt = cache.acquire(sql, *conn);
}