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

fixed backend test compilation

Browse Source
This commit is contained in:
Sascha Kühl
2025-02-12 16:01:52 +01:00
parent 42acaf24ce
commit 5d41a592bb
36 changed files with 727 additions and 575 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/backends/QueryBasicTest.cpp
+189 -186
View File
@@ -1,13 +1,15 @@
#include "catch2/catch_test_macros.hpp"
#include "catch2/matchers/catch_matchers_string.hpp"
#include "matador/sql/column_definition.hpp"
#include "matador/object/attribute_definition.hpp"
#include "matador/object/schema.hpp"
#include "matador/sql/connection.hpp"
#include "matador/sql/column_generator.hpp"
#include "matador/query/condition.hpp"
#include "matador/query/query.hpp"
#include "matador/sql/schema.hpp"
#include "matador/utils/basic_types.hpp"
#include "matador/utils/string.hpp"
@@ -15,12 +17,15 @@
#include "QueryFixture.hpp"
#include <iostream>
using namespace matador::test;
using namespace matador::sql;
using namespace matador::object;
using namespace matador::query;
TEST_CASE_METHOD( QueryFixture, "Insert and select basic datatypes", "[query][datatypes]" ) {
schema.attach<types>("types");
REQUIRE(schema.attach<types>("types"));
auto res = query::create()
.table<types>("types", schema)
.execute(db);
@@ -30,18 +35,15 @@ TEST_CASE_METHOD( QueryFixture, "Insert and select basic datatypes", "[query][da
float float_value = 2.44557f;
double double_value = 11111.23433345;
char cval = 'c';
int8_t cval = 'c';
short sval = (std::numeric_limits<short>::min)();
int ival = (std::numeric_limits<int>::min)();
long lval = (std::numeric_limits<long>::min)();
long long llval = (std::numeric_limits<long long>::max)();
unsigned char ucval = (std::numeric_limits<unsigned char>::max)();
unsigned short usval = (std::numeric_limits<unsigned short>::max)();
unsigned int uival = (std::numeric_limits<unsigned int>::max)();
unsigned long ulval = (std::numeric_limits<unsigned long>::max)();
unsigned long long ullval = (std::numeric_limits<unsigned long long>::max)();
if (db.type() == "sqlite" || db.type() == "postgres") {
ulval = (std::numeric_limits<long>::max)();
ullval = (std::numeric_limits<long long>::max)();
}
bool bval = true;
@@ -55,19 +57,19 @@ TEST_CASE_METHOD( QueryFixture, "Insert and select basic datatypes", "[query][da
"eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. "
"At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd "
"gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.";
matador::date date_val(15, 3, 2015);
auto time_val = matador::time(2015, 3, 15, 13, 56, 23, 123);
// matador::date date_val(15, 3, 2015);
// auto time_val = matador::time(2015, 3, 15, 13, 56, 23, 123);
matador::utils::blob blob_val {1,2,3,4,5,6,7,8};
types t {
1,
cval, sval, ival, lval, llval,
ucval, usval, uival, ulval, ullval,
cval, sval, ival, llval,
ucval, usval, uival, ullval,
float_value, double_value,
bval,
"Armer schwarzer Kater",
strval, varcharval,
date_val, time_val,
// date_val, time_val,
blob_val
};
@@ -88,12 +90,10 @@ TEST_CASE_METHOD( QueryFixture, "Insert and select basic datatypes", "[query][da
REQUIRE((*result)->char_ == cval);
REQUIRE((*result)->short_ == sval);
REQUIRE((*result)->int_ == ival);
REQUIRE((*result)->long_ == lval);
REQUIRE((*result)->long64_ == llval);
REQUIRE((*result)->unsigned_char_ == ucval);
REQUIRE((*result)->unsigned_short_ == usval);
REQUIRE((*result)->unsigned_int_ == uival);
REQUIRE((*result)->unsigned_long_ == ulval);
REQUIRE((*result)->unsigned_long64_ == ullval);
REQUIRE((*result)->float_ == float_value);
REQUIRE((*result)->double_ == double_value);
@@ -101,8 +101,8 @@ TEST_CASE_METHOD( QueryFixture, "Insert and select basic datatypes", "[query][da
REQUIRE((*result)->bool_ == bval);
REQUIRE((*result)->varchar_ == varcharval);
REQUIRE((*result)->string_ == strval);
REQUIRE((*result)->date_ == date_val);
REQUIRE((*result)->time_ == time_val);
// REQUIRE((*result)->date_ == date_val);
// REQUIRE((*result)->time_ == time_val);
REQUIRE((*result)->binary_ == blob_val);
}
@@ -121,7 +121,7 @@ TEST_CASE_METHOD( QueryFixture, "Test quoted identifier", "[query][quotes][ident
// check table description
std::vector<std::string> column_names = { "from", "to"};
std::vector<matador::data_type> types = {matador::data_type::type_varchar, matador::data_type::type_varchar};
std::vector<matador::utils::basic_type> types = {matador::utils::basic_type::type_varchar, matador::utils::basic_type::type_varchar};
const auto columns = db.describe("quotes");
REQUIRE(columns.is_ok());
@@ -194,7 +194,7 @@ TEST_CASE_METHOD( QueryFixture, "Test quoted column names", "[query][quotes][col
for (const auto &col : *columns) {
REQUIRE(col.name() == name);
REQUIRE(col.type() == matador::data_type::type_varchar);
REQUIRE(col.type() == matador::utils::basic_type::type_varchar);
}
res = query::drop()
@@ -278,7 +278,7 @@ TEST_CASE_METHOD(QueryFixture, "Test quoted literals", "[query][quotes][literals
TEST_CASE_METHOD(QueryFixture, "Test describe table", "[query][describe][table]") {
using namespace matador::sql;
schema.attach<types>("types");
REQUIRE(schema.attach<types>("types"));
const auto res = query::create()
.table<types>("types", schema)
.execute(db);
@@ -293,29 +293,30 @@ TEST_CASE_METHOD(QueryFixture, "Test describe table", "[query][describe][table]"
"val_char", "val_float", "val_double", "val_short",
"val_int", "val_long", "val_long_long", "val_unsigned_char",
"val_unsigned_short", "val_unsigned_int", "val_unsigned_long", "val_unsigned_long_long",
"val_bool", "val_cstr", "val_string", "val_varchar", "val_date", "val_time",
"val_bool", "val_cstr", "val_string", "val_varchar",
// "val_date", "val_time",
"val_binary"};
const std::vector<std::function<bool (const column_definition&)>> type_check = {
[](const column_definition &cf) { return cf.is_integer(); },
[](const column_definition &cf) { return cf.is_integer(); },
[](const column_definition &cf) { return cf.is_floating_point(); },
[](const column_definition &cf) { return cf.is_floating_point(); },
[](const column_definition &cf) { return cf.is_integer(); },
[](const column_definition &cf) { return cf.is_integer(); },
[](const column_definition &cf) { return cf.is_integer(); },
[](const column_definition &cf) { return cf.is_integer(); },
[](const column_definition &cf) { return cf.is_integer(); },
[](const column_definition &cf) { return cf.is_integer(); },
[](const column_definition &cf) { return cf.is_integer(); },
[](const column_definition &cf) { return cf.is_integer(); },
[](const column_definition &cf) { return cf.is_integer(); },
[](const column_definition &cf) { return cf.is_bool(); },
[](const column_definition &cf) { return cf.is_varchar(); },
[](const column_definition &cf) { return cf.is_string(); },
[](const column_definition &cf) { return cf.is_varchar(); },
[](const column_definition &cf) { return cf.is_date(); },
[](const column_definition &cf) { return cf.is_time(); },
[](const column_definition &cf) { return cf.is_blob(); }
const std::vector<std::function<bool (const attribute_definition&)>> type_check = {
[](const attribute_definition &cf) { return cf.is_integer(); },
[](const attribute_definition &cf) { return cf.is_integer(); },
[](const attribute_definition &cf) { return cf.is_floating_point(); },
[](const attribute_definition &cf) { return cf.is_floating_point(); },
[](const attribute_definition &cf) { return cf.is_integer(); },
[](const attribute_definition &cf) { return cf.is_integer(); },
[](const attribute_definition &cf) { return cf.is_integer(); },
[](const attribute_definition &cf) { return cf.is_integer(); },
[](const attribute_definition &cf) { return cf.is_integer(); },
[](const attribute_definition &cf) { return cf.is_integer(); },
[](const attribute_definition &cf) { return cf.is_integer(); },
[](const attribute_definition &cf) { return cf.is_integer(); },
[](const attribute_definition &cf) { return cf.is_integer(); },
[](const attribute_definition &cf) { return cf.is_bool(); },
[](const attribute_definition &cf) { return cf.is_varchar(); },
[](const attribute_definition &cf) { return cf.is_string(); },
[](const attribute_definition &cf) { return cf.is_varchar(); },
// [](const attribute_definition &cf) { return cf.is_date(); },
// [](const attribute_definition &cf) { return cf.is_time(); },
[](const attribute_definition &cf) { return cf.is_blob(); }
};
const auto &cols = columns.value();
@@ -341,7 +342,7 @@ struct pk {
matador::access::attribute(op, "name", name, 255);
}
unsigned long id{};
uint32_t id{};
std::string name;
};
}
@@ -350,7 +351,7 @@ TEST_CASE_METHOD(QueryFixture, "Test primary key", "[query][primary key]") {
using namespace matador::test::temporary;
using namespace matador::sql;
schema.attach<pk>("pk");
REQUIRE(schema.attach<pk>("pk"));
auto res = query::create()
.table<pk>("pk", schema)
.execute(db);
@@ -379,7 +380,7 @@ TEST_CASE_METHOD(QueryFixture, "Test primary key prepared", "[query][primary key
using namespace matador::test::temporary;
using namespace matador::sql;
schema.attach<pk>("pk");
REQUIRE(schema.attach<pk>("pk"));
auto res = query::create()
.table<pk>("pk", schema)
.execute(db);
@@ -393,8 +394,9 @@ TEST_CASE_METHOD(QueryFixture, "Test primary key prepared", "[query][primary key
.into("pk", column_generator::generate<pk>(schema))
.values<pk>()
.prepare(db);
REQUIRE(stmt);
res = stmt.bind(pk1)
res = stmt->bind(pk1)
.execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 1);
@@ -402,150 +404,151 @@ TEST_CASE_METHOD(QueryFixture, "Test primary key prepared", "[query][primary key
stmt = query::select<pk>(schema)
.from("pk")
.prepare(db);
REQUIRE(stmt);
auto row = stmt.fetch_one<pk>();
auto row = stmt->fetch_one<pk>();
REQUIRE(row.is_ok());
REQUIRE(*row != nullptr);
REQUIRE(row.value()->id > 0);
REQUIRE(row.value()->name == "george");
}
namespace matador::test::temporary {
struct appointment
{
unsigned long id{};
std::string name;
matador::time time_point{};
matador::date date_point{};
template < class Operator >
void process(Operator &op)
{
matador::access::primary_key(op, "id", id);
matador::access::attribute(op, "name", name, 255);
matador::access::attribute(op, "time_point", time_point);
matador::access::attribute(op, "date_point", date_point);
}
};
}
TEST_CASE_METHOD(QueryFixture, "Test select time and date", "[query][select][time]") {
using namespace matador::test::temporary;
using namespace matador::sql;
schema.attach<appointment>("appointment");
auto res = query::create()
.table<appointment>("appointment", schema)
.execute(db);
REQUIRE(res.is_ok());
REQUIRE(*res == 0);
tables_to_drop.emplace("appointment");
auto dinner = appointment{ 1, "dinner" };
auto time_str = matador::utils::to_string(dinner.time_point);
auto date_str = matador::utils::to_string(dinner.date_point);
res = query::insert()
.into("appointment", column_generator::generate<appointment>(schema))
.values(dinner)
.execute(db);
REQUIRE(res.is_ok());
REQUIRE(*res == 1);
auto row = query::select<appointment>(schema)
.from("appointment")
.fetch_one<appointment>(db);
REQUIRE(row.is_ok());
REQUIRE(*row != nullptr);
REQUIRE(matador::utils::to_string(row.value()->time_point) == time_str);
REQUIRE(matador::utils::to_string(row.value()->date_point) == date_str);
}
TEST_CASE_METHOD(QueryFixture, "Test null column", "[query][select][null]") {
using namespace matador::sql;
auto res = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("first_name", 255, null_option::NULLABLE),
make_column<std::string>("last_name", 255, null_option::NULLABLE)
})
.execute(db);
REQUIRE(res.is_ok());
REQUIRE(*res == 0);
tables_to_drop.emplace("person");
res = query::insert()
.into("person", {"id", "first_name"})
.values({1, "george"})
.execute(db);
REQUIRE(res.is_ok());
REQUIRE(*res == 1);
res = query::insert()
.into("person", {"id", "last_name"})
.values({2, "clooney"})
.execute(db);
REQUIRE(res.is_ok());
REQUIRE(*res == 1);
auto result = query::select({"id", "first_name", "last_name"})
.from("person")
.fetch_all(db);
REQUIRE(result.is_ok());
std::vector<std::string> expected_first_names{"george", ""};
std::vector<std::string> expected_last_names{"", "clooney"};
size_t index{0};
for (const auto& row : *result) {
auto first_name = row.at<std::string>("first_name");
auto last_name = row.at<std::string>("last_name");
std::cout << "first name " << first_name.value() << " last name " << last_name.value() << std::endl;
REQUIRE(first_name == expected_first_names[index]);
REQUIRE(last_name == expected_last_names[index++]);
}
}
TEST_CASE_METHOD(QueryFixture, "Test null column prepared", "[query][select][null][prepared]") {
using namespace matador::sql;
auto res = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_column<std::string>("first_name", 255, null_option::NULLABLE),
make_column<std::string>("last_name", 255, null_option::NULLABLE)
})
.execute(db);
REQUIRE(res.is_ok());
REQUIRE(*res == 0);
tables_to_drop.emplace("person");
res = query::insert()
.into("person", {"id", "first_name"})
.values({1, "george"})
.execute(db);
REQUIRE(res.is_ok());
REQUIRE(*res == 1);
res = query::insert()
.into("person", {"id", "last_name"})
.values({2, "clooney"})
.execute(db);
REQUIRE(res.is_ok());
REQUIRE(*res == 1);
auto result = query::select({"id", "first_name", "last_name"})
.from("person")
.fetch_all(db);
REQUIRE(result.is_ok());
std::vector<std::string> expected_first_names{"george", ""};
std::vector<std::string> expected_last_names{"", "clooney"};
size_t index{0};
for (const auto& row : *result) {
auto first_name = row.at("first_name").as<std::string>();
auto last_name = row.at("last_name").as<std::string>();
REQUIRE(first_name == expected_first_names[index]);
REQUIRE(last_name == expected_last_names[index++]);
}
}
// namespace matador::test::temporary {
// struct appointment
// {
// unsigned long id{};
// std::string name;
// matador::time time_point{};
// matador::date date_point{};
//
// template < class Operator >
// void process(Operator &op)
// {
// matador::access::primary_key(op, "id", id);
// matador::access::attribute(op, "name", name, 255);
// matador::access::attribute(op, "time_point", time_point);
// matador::access::attribute(op, "date_point", date_point);
// }
// };
//
// }
// TEST_CASE_METHOD(QueryFixture, "Test select time and date", "[query][select][time]") {
// using namespace matador::test::temporary;
// using namespace matador::sql;
// REQUIRE(schema.attach<appointment>("appointment"));
// auto res = query::create()
// .table<appointment>("appointment", schema)
// .execute(db);
// REQUIRE(res.is_ok());
// REQUIRE(*res == 0);
// tables_to_drop.emplace("appointment");
//
// auto dinner = appointment{ 1, "dinner" };
// auto time_str = matador::utils::to_string(dinner.time_point);
// auto date_str = matador::utils::to_string(dinner.date_point);
//
// res = query::insert()
// .into("appointment", column_generator::generate<appointment>(schema))
// .values(dinner)
// .execute(db);
// REQUIRE(res.is_ok());
// REQUIRE(*res == 1);
//
// auto row = query::select<appointment>(schema)
// .from("appointment")
// .fetch_one<appointment>(db);
// REQUIRE(row.is_ok());
//
// REQUIRE(*row != nullptr);
// REQUIRE(matador::utils::to_string(row.value()->time_point) == time_str);
// REQUIRE(matador::utils::to_string(row.value()->date_point) == date_str);
// }
//
// TEST_CASE_METHOD(QueryFixture, "Test null column", "[query][select][null]") {
// using namespace matador::sql;
//
// auto res = query::create()
// .table("person", {
// make_pk_column<unsigned long>("id"),
// make_column<std::string>("first_name", 255, null_option::NULLABLE),
// make_column<std::string>("last_name", 255, null_option::NULLABLE)
// })
// .execute(db);
// REQUIRE(res.is_ok());
// REQUIRE(*res == 0);
// tables_to_drop.emplace("person");
//
// res = query::insert()
// .into("person", {"id", "first_name"})
// .values({1, "george"})
// .execute(db);
// REQUIRE(res.is_ok());
// REQUIRE(*res == 1);
//
// res = query::insert()
// .into("person", {"id", "last_name"})
// .values({2, "clooney"})
// .execute(db);
// REQUIRE(res.is_ok());
// REQUIRE(*res == 1);
//
// auto result = query::select({"id", "first_name", "last_name"})
// .from("person")
// .fetch_all(db);
// REQUIRE(result.is_ok());
//
// std::vector<std::string> expected_first_names{"george", ""};
// std::vector<std::string> expected_last_names{"", "clooney"};
// size_t index{0};
// for (const auto& row : *result) {
// auto first_name = row.at<std::string>("first_name");
// auto last_name = row.at<std::string>("last_name");
// std::cout << "first name " << first_name.value() << " last name " << last_name.value() << std::endl;
// REQUIRE(first_name == expected_first_names[index]);
// REQUIRE(last_name == expected_last_names[index++]);
// }
// }
//
// TEST_CASE_METHOD(QueryFixture, "Test null column prepared", "[query][select][null][prepared]") {
// using namespace matador::sql;
//
// auto res = query::create()
// .table("person", {
// make_pk_column<unsigned long>("id"),
// make_column<std::string>("first_name", 255, null_option::NULLABLE),
// make_column<std::string>("last_name", 255, null_option::NULLABLE)
// })
// .execute(db);
// REQUIRE(res.is_ok());
// REQUIRE(*res == 0);
// tables_to_drop.emplace("person");
//
// res = query::insert()
// .into("person", {"id", "first_name"})
// .values({1, "george"})
// .execute(db);
// REQUIRE(res.is_ok());
// REQUIRE(*res == 1);
//
// res = query::insert()
// .into("person", {"id", "last_name"})
// .values({2, "clooney"})
// .execute(db);
// REQUIRE(res.is_ok());
// REQUIRE(*res == 1);
//
// auto result = query::select({"id", "first_name", "last_name"})
// .from("person")
// .fetch_all(db);
// REQUIRE(result.is_ok());
//
// std::vector<std::string> expected_first_names{"george", ""};
// std::vector<std::string> expected_last_names{"", "clooney"};
// size_t index{0};
// for (const auto& row : *result) {
// auto first_name = row.at("first_name").as<std::string>();
// auto last_name = row.at("last_name").as<std::string>();
// REQUIRE(first_name == expected_first_names[index]);
// REQUIRE(last_name == expected_last_names[index++]);
// }
// }