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/ColorEnumTraits.cpp
+2 -5
View File
@@ -5,9 +5,7 @@
namespace matador::utils {
void data_type_traits<test::Color, void>::read_value(attribute_reader &reader, const char *id, size_t index,
test::Color &value)
{
void data_type_traits<test::Color>::read_value(attribute_reader &reader, const char *id, const size_t index, test::Color &value) {
std::string enum_string;
reader.read_value(id, index, enum_string, 64);
if (const auto enum_opt = color_enum.to_enum(enum_string)) {
@@ -15,8 +13,7 @@ void data_type_traits<test::Color, void>::read_value(attribute_reader &reader, c
}
}
void data_type_traits<test::Color, void>::bind_value(attribute_writer &binder, const size_t index, const test::Color &value)
{
void data_type_traits<test::Color>::bind_value(attribute_writer &binder, const size_t index, const test::Color &value) {
binder.write_value(index, color_enum.to_string(value));
}
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++]);
// }
// }
test/backends/QueryFixture.cpp
+5 -3
View File
@@ -1,6 +1,8 @@
#include "QueryFixture.hpp"
#include "matador/sql/query.hpp"
#include "matador/query/query.hpp"
#include "matador/sql/dialect.hpp"
#include "catch2/catch_test_macros.hpp"
@@ -10,7 +12,7 @@ QueryFixture::QueryFixture()
: db(connection::dns)
, schema(db.dialect().default_schema_name())
{
db.open();
REQUIRE(db.open());
}
QueryFixture::~QueryFixture() {
@@ -37,7 +39,7 @@ void QueryFixture::check_table_not_exists(const std::string &table_name) const
void QueryFixture::drop_table_if_exists(const std::string &table_name) const {
const auto result = db.exists(table_name).and_then([&table_name, this](bool exists) {
if (exists) {
if (sql::query::drop()
if (query::query::drop()
.table(table_name)
.execute(db).is_ok()) {
this->check_table_not_exists(table_name);
test/backends/QueryFixture.hpp
+1 -1
View File
@@ -21,8 +21,8 @@ public:
protected:
sql::connection db;
sql::schema schema;
std::stack <std::string> tables_to_drop;
object::schema schema;
private:
void drop_table_if_exists(const std::string &table_name) const;
test/backends/QueryRecordTest.cpp
+79 -79
View File
@@ -1,9 +1,10 @@
#include <catch2/catch_test_macros.hpp>
#include "matador/sql/column.hpp"
#include "matador/sql/condition.hpp"
#include "matador/sql/connection.hpp"
#include "matador/sql/query.hpp"
#include "matador/query/condition.hpp"
#include "matador/query/query.hpp"
#include "matador/utils/types.hpp"
#include "matador/utils/string.hpp"
@@ -13,6 +14,8 @@
#include <list>
#include <algorithm>
using namespace matador::object;
using namespace matador::query;
using namespace matador::sql;
using namespace matador::test;
@@ -21,24 +24,22 @@ TEST_CASE_METHOD(QueryFixture, "Test all data types for record", "[query][record
auto res = query::create()
.table("types", {
make_pk_column<unsigned long>("id"),
make_column<char>("val_char"),
make_column<short>("val_short"),
make_column<int>("val_int"),
make_column<long>("val_long"),
make_column<long long>("val_long_long"),
make_column<unsigned char>("val_uchar"),
make_column<unsigned short>("val_ushort"),
make_column<unsigned int>("val_uint"),
make_column<unsigned long>("val_ulong"),
make_column<unsigned long long>("val_ulong_long"),
make_pk_column<uint32_t>("id"),
make_column<int8_t>("val_char"),
make_column<int16_t>("val_short"),
make_column<int32_t>("val_int"),
make_column<int64_t>("val_long_long"),
make_column<uint8_t>("val_uchar"),
make_column<uint16_t>("val_ushort"),
make_column<uint32_t>("val_uint"),
make_column<uint64_t>("val_ulong_long"),
make_column<bool>("val_bool"),
make_column<float>("val_float"),
make_column<double>("val_double"),
make_column<std::string>("val_string"),
make_column<std::string>("val_varchar", 63),
make_column<matador::date>("val_date"),
make_column<matador::time>("val_time"),
// make_column<matador::date>("val_date"),
// make_column<matador::time>("val_time"),
make_column<matador::utils::blob>("val_blob"),
})
.execute(db);
@@ -54,7 +55,8 @@ TEST_CASE_METHOD(QueryFixture, "Test all data types for record", "[query][record
"val_bool",
"val_float", "val_double",
"val_string", "val_varchar",
"val_date", "val_time", "val_blob"};
// "val_date", "val_time",
"val_blob"};
const auto fields = db.describe("types");
REQUIRE(fields.is_ok());
@@ -62,29 +64,27 @@ TEST_CASE_METHOD(QueryFixture, "Test all data types for record", "[query][record
REQUIRE(std::find(cols.begin(), cols.end(), fld.name()) != cols.end());
}
unsigned long id{1};
char c{-11};
short s{-256};
int i{-123456};
long l{-9876543};
long long ll{-987654321};
unsigned char uc{13};
unsigned short us{1024};
unsigned int ui{654321};
unsigned long ul{12345678};
unsigned long long ull{1234567890};
uint32_t id{1};
int8_t c{-11};
int16_t s{-256};
int32_t i{-123456};
int64_t ll{-987654321};
uint8_t uc{13};
uint16_t us{1024};
uint32_t ui{654321};
uint64_t ull{1234567890};
bool b{true};
float f{3.1415f};
double d{2.71828};
std::string str{"long text"};
std::string varchar{"good day"};
auto md{matador::date()};
auto mt{matador::time::now()};
// auto md{matador::date()};
// auto mt{matador::time::now()};
matador::utils::blob bin{0x01,0x02,0x03,0x04};
res = query::insert()
.into("types", cols)
.values({id, c, s, i, l, ll, uc, us, ui, ul, ull, b, f, d, str, varchar, md, mt, bin})
.values({id, c, s, i, ll, uc, us, ui, ull, b, f, d, str, varchar, /*md, mt, */bin})
.execute(db);
REQUIRE(res.is_ok());
REQUIRE(res.value() == 1);
@@ -96,24 +96,22 @@ TEST_CASE_METHOD(QueryFixture, "Test all data types for record", "[query][record
REQUIRE(row.is_ok());
REQUIRE(row.value().has_value());
REQUIRE(id == (*row)->at<unsigned long>("id"));
REQUIRE(c == (*row)->at<char>("val_char"));
REQUIRE(s == (*row)->at<short>("val_short"));
REQUIRE(i == (*row)->at<int>("val_int"));
REQUIRE(l == (*row)->at<long>("val_long"));
REQUIRE(ll == (*row)->at<long long>("val_long_long"));
REQUIRE(uc == (*row)->at<unsigned char>("val_uchar"));
REQUIRE(id == (*row)->at<uint32_t>("id"));
REQUIRE(c == (*row)->at<int8_t>("val_char"));
REQUIRE(s == (*row)->at<int16_t>("val_short"));
REQUIRE(i == (*row)->at<int32_t>("val_int"));
REQUIRE(ll == (*row)->at<int64_t>("val_long_long"));
REQUIRE(uc == (*row)->at<uint8_t>("val_uchar"));
REQUIRE(us == (*row)->at<unsigned short>("val_ushort"));
REQUIRE(ui == (*row)->at<unsigned int>("val_uint"));
REQUIRE(ul == (*row)->at<unsigned long>("val_ulong"));
REQUIRE(ull == (*row)->at<unsigned long long>("val_ulong_long"));
REQUIRE(ull == (*row)->at<uint64_t>("val_ulong_long"));
REQUIRE((*row)->at<bool>("val_bool"));
REQUIRE(f == (*row)->at<float>("val_float"));
REQUIRE(d == (*row)->at<double>("val_double"));
REQUIRE(str == (*row)->at<std::string>("val_string"));
REQUIRE(varchar == (*row)->at<std::string>("val_varchar"));
REQUIRE(md == (*row)->at<matador::date>("val_date"));
REQUIRE(mt == (*row)->at<matador::time>("val_time"));
// REQUIRE(md == (*row)->at<matador::date>("val_date"));
// REQUIRE(mt == (*row)->at<matador::time>("val_time"));
REQUIRE(bin == (*row)->at<matador::utils::blob>("val_blob"));
}
@@ -122,7 +120,7 @@ TEST_CASE_METHOD(QueryFixture, "Create and drop table statement", "[query][recor
check_table_not_exists("person");
auto res = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
make_column<std::string>("name", 255),
make_column<unsigned short>("age")
})
@@ -146,7 +144,7 @@ TEST_CASE_METHOD(QueryFixture, "Create and drop table statement with foreign key
{
auto res = query::create()
.table("airplane", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
make_column<std::string>("brand", 255),
make_column<std::string>("model", 255),
})
@@ -159,8 +157,8 @@ TEST_CASE_METHOD(QueryFixture, "Create and drop table statement with foreign key
res = query::create()
.table("flight", {
make_pk_column<unsigned long>("id"),
make_fk_column<unsigned long>("airplane_id", "airplane", "id"),
make_pk_column<uint32_t>("id"),
make_fk_column<uint32_t>("airplane_id", "airplane", "id"),
make_column<std::string>("pilot_name", 255),
})
.execute(db);
@@ -191,7 +189,7 @@ TEST_CASE_METHOD(QueryFixture, "Execute insert record statement", "[query][recor
{
auto res = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
make_column<std::string>("name", 255),
make_column<unsigned short>("age")
})
@@ -230,7 +228,7 @@ TEST_CASE_METHOD(QueryFixture, "Execute insert record statement with foreign key
{
auto res = query::create()
.table("airplane", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
make_column<std::string>("brand", 255),
make_column<std::string>("model", 255),
})
@@ -241,8 +239,8 @@ TEST_CASE_METHOD(QueryFixture, "Execute insert record statement with foreign key
res = query::create()
.table("flight", {
make_pk_column<unsigned long>("id"),
make_fk_column<unsigned long>("airplane_id", "airplane", "id"),
make_pk_column<uint32_t>("id"),
make_fk_column<uint32_t>("airplane_id", "airplane", "id"),
make_column<std::string>("pilot_name", 255),
})
.execute(db);
@@ -250,7 +248,7 @@ TEST_CASE_METHOD(QueryFixture, "Execute insert record statement with foreign key
REQUIRE(res.value() == 0);
tables_to_drop.emplace("flight");
std::vector<std::vector<matador::utils::any_type>> values_list{
std::vector<std::vector<matador::utils::database_type>> values_list{
{1, "Airbus", "A380"},
{2, "Boeing", "707"},
{3, "Boeing", "747"}
@@ -284,7 +282,7 @@ TEST_CASE_METHOD(QueryFixture, "Execute update record statement", "[query][recor
{
auto res = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
make_column<std::string>("name", 255),
make_column<unsigned short>("age")
})
@@ -333,7 +331,7 @@ TEST_CASE_METHOD(QueryFixture, "Execute select statement", "[query][record]")
{
auto res = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
make_column<std::string>("name", 255),
make_column<unsigned short>("age")
})
@@ -342,7 +340,7 @@ TEST_CASE_METHOD(QueryFixture, "Execute select statement", "[query][record]")
REQUIRE(res.value() == 0);
tables_to_drop.emplace("person");
std::vector<std::vector<matador::utils::any_type>> values_list{
std::vector<std::vector<matador::utils::database_type>> values_list{
{1, "george", 45},
{2, "jane", 32},
{3, "michael", 67},
@@ -389,7 +387,7 @@ TEST_CASE_METHOD(QueryFixture, "Execute select statement with order by", "[query
{
auto res = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
make_column<std::string>("name", 255),
make_column<unsigned short>("age")
})
@@ -398,7 +396,7 @@ TEST_CASE_METHOD(QueryFixture, "Execute select statement with order by", "[query
REQUIRE(res.value() == 0);
tables_to_drop.emplace("person");
std::vector<std::vector<matador::utils::any_type>> values_list{
std::vector<std::vector<matador::utils::database_type>> values_list{
{1, "george", 45},
{2, "jane", 32},
{3, "michael", 67},
@@ -432,7 +430,7 @@ TEST_CASE_METHOD(QueryFixture, "Execute select statement with group by and order
{
auto res = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
make_column<std::string>("name", 255),
make_column<unsigned short>("age")
})
@@ -441,7 +439,7 @@ TEST_CASE_METHOD(QueryFixture, "Execute select statement with group by and order
REQUIRE(*res == 0);
tables_to_drop.emplace("person");
std::vector<std::vector<matador::utils::any_type>> values_list{
std::vector<std::vector<matador::utils::database_type>> values_list{
{1, "george", 45},
{2, "jane", 45},
{3, "joe", 45},
@@ -482,7 +480,7 @@ TEST_CASE_METHOD(QueryFixture, "Execute delete statement", "[query][record]")
{
auto res = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
make_column<std::string>("name", 255),
make_column<unsigned short>("age")
}).execute(db);
@@ -537,9 +535,9 @@ TEST_CASE_METHOD(QueryFixture, "Test quoted identifier record", "[query][record]
// check table description
std::vector<std::string> columns = { "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
};
auto fields = db.describe("quotes");
REQUIRE(fields.is_ok());
@@ -585,7 +583,7 @@ TEST_CASE_METHOD(QueryFixture, "Test create record", "[query][record][create]")
check_table_not_exists("person");
auto res = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
make_column<std::string>("name", 255),
make_column<unsigned short>("age")
})
@@ -608,7 +606,7 @@ TEST_CASE_METHOD(QueryFixture, "Test insert record", "[query][record][insert]")
check_table_not_exists("person");
auto res = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
make_column<std::string>("name", 255),
make_column<unsigned short>("age")
})
@@ -632,7 +630,7 @@ TEST_CASE_METHOD(QueryFixture, "Test insert record", "[query][record][insert]")
REQUIRE(row.is_ok());
REQUIRE(row->has_value());
REQUIRE((*row)->at("id").as<unsigned long>() == 1);
REQUIRE((*row)->at("id").as<uint32_t>() == 1);
REQUIRE((*row)->at("name").as<std::string>() == "hans");
REQUIRE((*row)->at("age").as<unsigned short>() == 45);
}
@@ -641,7 +639,7 @@ TEST_CASE_METHOD(QueryFixture, "Test update record", "[query][record][update]")
check_table_not_exists("person");
auto res = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
make_column<std::string>("name", 255),
make_column<unsigned short>("age")
})
@@ -665,7 +663,7 @@ TEST_CASE_METHOD(QueryFixture, "Test update record", "[query][record][update]")
REQUIRE(row.is_ok());
REQUIRE(row->has_value());
REQUIRE((*row)->at("id").as<unsigned long>() == 1);
REQUIRE((*row)->at("id").as<uint32_t>() == 1);
REQUIRE((*row)->at("name").as<std::string>() == "hans");
REQUIRE((*row)->at("age").as<unsigned short>() == 45);
@@ -682,7 +680,7 @@ TEST_CASE_METHOD(QueryFixture, "Test update record", "[query][record][update]")
REQUIRE(row.is_ok());
REQUIRE(row->has_value());
REQUIRE((*row)->at("id").as<unsigned long>() == 1);
REQUIRE((*row)->at("id").as<uint32_t>() == 1);
REQUIRE((*row)->at("name").as<std::string>() == "jane");
REQUIRE((*row)->at("age").as<unsigned short>() == 47);
}
@@ -691,14 +689,15 @@ TEST_CASE_METHOD(QueryFixture, "Test prepared record statement", "[query][record
check_table_not_exists("person");
auto stmt = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
make_column<std::string>("name", 255),
make_column<unsigned short>("age")
})
.prepare(db);
REQUIRE(stmt.is_ok());
tables_to_drop.emplace("person");
auto res = stmt.execute();
auto res = stmt->execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 0);
check_table_exists("person");
@@ -716,7 +715,7 @@ TEST_CASE_METHOD(QueryFixture, "Test scalar result", "[query][record][scalar][re
check_table_not_exists("person");
auto res = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
})
.execute(db);
REQUIRE(res.is_ok());
@@ -725,7 +724,7 @@ TEST_CASE_METHOD(QueryFixture, "Test scalar result", "[query][record][scalar][re
check_table_exists("person");
tables_to_drop.emplace("person");
std::vector<unsigned long> ids({ 1,2,3,4 });
std::vector<uint32_t> ids({ 1,2,3,4 });
for(auto id : ids) {
res = query::insert()
@@ -740,33 +739,34 @@ TEST_CASE_METHOD(QueryFixture, "Test scalar result", "[query][record][scalar][re
.from("person")
.order_by("id"_col).asc()
.prepare(db);
REQUIRE(stmt);
auto rows = stmt.fetch();
auto rows = stmt->fetch();
REQUIRE(rows.is_ok());
size_t index{0};
for (const auto &row : *rows) {
REQUIRE(row.at("id").as<unsigned long>() == ids[index]);
REQUIRE(row.at("id").as<uint32_t>() == ids[index]);
++index;
}
REQUIRE(index == 4);
stmt.reset();
stmt->reset();
rows = stmt.fetch();
rows = stmt->fetch();
REQUIRE(rows.is_ok());
index = 0;
for (const auto &row : *rows) {
REQUIRE(row.at("id").as<unsigned long>() == ids[index]);
REQUIRE(row.at("id").as<uint32_t>() == ids[index]);
++index;
}
REQUIRE(index == 4);
stmt.reset();
stmt->reset();
auto row = stmt.fetch_one();
auto row = stmt->fetch_one();
REQUIRE(row.is_ok());
REQUIRE(row->has_value());
REQUIRE(row.value()->at("id").as<unsigned long>() == ids[0]);
REQUIRE(row.value()->at("id").as<uint32_t>() == ids[0]);
}
test/backends/QueryStatementTests.cpp
+46 -34
View File
@@ -1,9 +1,10 @@
#include <catch2/catch_test_macros.hpp>
#include "matador/sql/column.hpp"
#include "matador/sql/condition.hpp"
#include "matador/sql/connection.hpp"
#include "matador/sql/query.hpp"
#include "matador/query/condition.hpp"
#include "matador/query/query.hpp"
#include "models/person.hpp"
@@ -13,15 +14,18 @@
#include <vector>
using namespace matador::sql;
using namespace matador::object;
using namespace matador::query;
using namespace matador::test;
TEST_CASE_METHOD(QueryFixture, "Test create statement", "[query][statement][create]") {
schema.attach<matador::test::person>("person");
REQUIRE(schema.attach<matador::test::person>("person"));
auto stmt = query::create()
.table<matador::test::person>("person", schema)
.prepare(db);
REQUIRE(stmt);
auto res = stmt.execute();
auto res = stmt->execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 0);
tables_to_drop.emplace("person");
@@ -39,12 +43,13 @@ TEST_CASE_METHOD(QueryFixture, "Test create statement", "[query][statement][crea
TEST_CASE_METHOD(QueryFixture, "Test insert statement", "[query][statement][insert]") {
using namespace matador::test;
schema.attach<person>("person");
REQUIRE(schema.attach<person>("person"));
auto stmt = query::create()
.table<person>("person", schema)
.prepare(db);
REQUIRE(stmt);
auto res = stmt.execute();
auto res = stmt->execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 0);
tables_to_drop.emplace("person");
@@ -57,8 +62,9 @@ TEST_CASE_METHOD(QueryFixture, "Test insert statement", "[query][statement][inse
.into<person>("person", schema)
.values<person>()
.prepare(db);
REQUIRE(stmt);
res = stmt.bind(george)
res = stmt->bind(george)
.execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 1);
@@ -79,12 +85,13 @@ TEST_CASE_METHOD(QueryFixture, "Test update statement", "[query][statement][upda
using namespace matador::test;
using namespace matador::utils;
schema.attach<matador::test::person>("person");
REQUIRE(schema.attach<matador::test::person>("person"));
auto stmt = query::create()
.table<matador::test::person>("person", schema)
.prepare(db);
REQUIRE(stmt);
auto res = stmt.execute();
auto res = stmt->execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 0);
tables_to_drop.emplace("person");
@@ -97,8 +104,9 @@ TEST_CASE_METHOD(QueryFixture, "Test update statement", "[query][statement][upda
.into<person>("person", schema)
.values<person>()
.prepare(db);
REQUIRE(stmt);
res = stmt.bind(george)
res = stmt->bind(george)
.execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 1);
@@ -120,8 +128,9 @@ TEST_CASE_METHOD(QueryFixture, "Test update statement", "[query][statement][upda
.set<person>()
.where("id"_col == _)
.prepare(db);
REQUIRE(stmt);
res = stmt.bind(george)
res = stmt->bind(george)
.bind(4, george.id)
.execute();
REQUIRE(res.is_ok());
@@ -142,12 +151,13 @@ TEST_CASE_METHOD(QueryFixture, "Test update statement", "[query][statement][upda
TEST_CASE_METHOD(QueryFixture, "Test delete statement", "[query][statement][delete]") {
using namespace matador::test;
schema.attach<matador::test::person>("person");
REQUIRE(schema.attach<matador::test::person>("person"));
auto stmt = query::create()
.table<matador::test::person>("person", schema)
.prepare(db);
REQUIRE(stmt);
auto res = stmt.execute();
auto res = stmt->execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 0);
tables_to_drop.emplace("person");
@@ -158,6 +168,7 @@ TEST_CASE_METHOD(QueryFixture, "Test delete statement", "[query][statement][dele
.into<person>("person", schema)
.values<person>()
.prepare(db);
REQUIRE(stmt);
std::vector<person> peoples {
{1,"george", 45, {1,2,3,4}},
@@ -167,20 +178,20 @@ TEST_CASE_METHOD(QueryFixture, "Test delete statement", "[query][statement][dele
};
for (const auto &p : peoples) {
res = stmt.bind(p)
res = stmt->bind(p)
.execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 1);
stmt.reset();
stmt->reset();
}
auto select_stmt = query::select<person>(schema)
.from("person")
.where("name"_col == matador::utils::_)
.prepare(db);
REQUIRE(select_stmt);
auto rows = select_stmt
.bind(0, "jane")
auto rows = select_stmt->bind(0, "jane")
.fetch<person>();
REQUIRE(rows.is_ok());
@@ -196,30 +207,28 @@ TEST_CASE_METHOD(QueryFixture, "Test delete statement", "[query][statement][dele
.from("person")
.where("name"_col == matador::utils::_)
.prepare(db);
REQUIRE(stmt);
res = stmt.bind(0, "jane")
res = stmt->bind(0, "jane")
.execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 1);
select_stmt.reset();
auto row = select_stmt
.bind(0, "jane")
select_stmt->reset();
auto row = select_stmt->bind(0, "jane")
.fetch_one<person>();
REQUIRE(row.is_ok());
REQUIRE(*row == nullptr);
stmt.reset();
res = stmt
.bind(0, "merlin")
stmt->reset();
res = stmt->bind(0, "merlin")
.execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 1);
select_stmt.reset();
row = select_stmt
.bind(0, "merlin")
select_stmt->reset();
row = select_stmt->bind(0, "merlin")
.fetch_one<person>();
REQUIRE(row.is_ok());
@@ -229,12 +238,13 @@ TEST_CASE_METHOD(QueryFixture, "Test delete statement", "[query][statement][dele
TEST_CASE_METHOD(QueryFixture, "Test reuse prepared statement", "[query][statement][reuse]") {
using namespace matador::test;
schema.attach<matador::test::person>("person");
REQUIRE(schema.attach<matador::test::person>("person"));
auto stmt = query::create()
.table<matador::test::person>("person", schema)
.prepare(db);
REQUIRE(stmt);
auto res = stmt.execute();
auto res = stmt->execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 0);
tables_to_drop.emplace("person");
@@ -245,6 +255,7 @@ TEST_CASE_METHOD(QueryFixture, "Test reuse prepared statement", "[query][stateme
.into<person>("person", schema)
.values<person>()
.prepare(db);
REQUIRE(stmt);
std::vector<person> peoples {
{1,"george", 45, {1,2,3,4}},
@@ -254,18 +265,19 @@ TEST_CASE_METHOD(QueryFixture, "Test reuse prepared statement", "[query][stateme
};
for (const auto &p : peoples) {
res = stmt.bind(p)
res = stmt->bind(p)
.execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 1);
stmt.reset();
stmt->reset();
}
stmt = query::select<person>(schema)
.from("person")
.prepare(db);
REQUIRE(stmt);
auto rows = stmt.fetch<person>();
auto rows = stmt->fetch<person>();
REQUIRE(rows.is_ok());
size_t index = 0;
@@ -277,9 +289,9 @@ TEST_CASE_METHOD(QueryFixture, "Test reuse prepared statement", "[query][stateme
++index;
}
stmt.reset();
stmt->reset();
rows = stmt.fetch<person>();
rows = stmt->fetch<person>();
REQUIRE(rows.is_ok());
index = 0;
test/backends/QueryTest.cpp
+89 -80
View File
@@ -2,6 +2,8 @@
#include "matador/object/attribute_definition.hpp"
#include "matador/sql/column_generator.hpp"
#include "matador/query/condition.hpp"
#include "matador/query/query.hpp"
@@ -12,13 +14,16 @@
#include "models/person.hpp"
#include "models/recipe.hpp"
using namespace matador::object;
using namespace matador::query;
using namespace matador::sql;
using namespace matador::test;
using namespace matador::query;
TEST_CASE_METHOD(QueryFixture, "Create table with foreign key relation", "[query][foreign][relation]") {
schema.attach<airplane>("airplane");
schema.attach<flight>("flight");
auto result = schema.attach<airplane>("airplane")
.and_then( [this] { return schema.attach<flight>("flight");} );
REQUIRE(result.is_ok());
auto res = query::create()
.table<airplane>("airplane", schema)
.execute(db);
@@ -38,9 +43,8 @@ TEST_CASE_METHOD(QueryFixture, "Create table with foreign key relation", "[query
tables_to_drop.emplace("flight");
}
TEST_CASE_METHOD(QueryFixture, "Execute select statement with where clause", "[query][where]")
{
schema.attach<person>("person");
TEST_CASE_METHOD(QueryFixture, "Execute select statement with where clause", "[query][where]") {
REQUIRE(schema.attach<person>("person"));
auto res = query::create()
.table<person>("person", schema)
.execute(db);
@@ -94,11 +98,10 @@ TEST_CASE_METHOD(QueryFixture, "Execute select statement with where clause", "[q
}
}
TEST_CASE_METHOD(QueryFixture, "Execute insert statement", "[query][insert]")
{
TEST_CASE_METHOD(QueryFixture, "Execute insert statement", "[query][insert]") {
auto res = query::create()
.table("person", {
make_pk_column<unsigned long>("id"),
make_pk_column<uint32_t>("id"),
make_column<std::string>("name", 255),
make_column<std::string>("color", 63)
})
@@ -127,7 +130,7 @@ TEST_CASE_METHOD(QueryFixture, "Execute insert statement", "[query][insert]")
REQUIRE(i.size() == 3);
REQUIRE(i.at(0).name() == "id");
REQUIRE(i.at(0).is_integer());
REQUIRE(i.at(0).as<unsigned long>() == 7);
REQUIRE(i.at(0).as<uint32_t>() == 7);
REQUIRE(i.at(1).name() == "name");
REQUIRE(i.at(1).is_varchar());
REQUIRE(i.at(1).as<std::string>() == "george");
@@ -137,10 +140,11 @@ TEST_CASE_METHOD(QueryFixture, "Execute insert statement", "[query][insert]")
}
}
TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key", "[query][foreign]")
{
schema.attach<airplane>("airplane");
schema.attach<flight>("flight");
TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key", "[query][foreign]") {
auto result = schema.attach<airplane>("airplane")
.and_then( [this] { return schema.attach<flight>("flight");} );
REQUIRE(result.is_ok());
auto res = query::create()
.table<airplane>("airplane", schema)
.execute(db);
@@ -159,10 +163,10 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key", "[query][for
REQUIRE(db.exists("flight"));
tables_to_drop.emplace("flight");
std::vector<matador::object_ptr<airplane>> planes{
matador::object_ptr<airplane>(new airplane{1, "Airbus", "A380"}),
matador::object_ptr<airplane>(new airplane{2, "Boeing", "707"}),
matador::object_ptr<airplane>(new airplane{3, "Boeing", "747"})
std::vector planes{
object_ptr(new airplane{1, "Airbus", "A380"}),
object_ptr(new airplane{2, "Boeing", "707"}),
object_ptr(new airplane{3, "Boeing", "747"})
};
for (const auto &plane: planes) {
@@ -194,15 +198,16 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key", "[query][for
.fetch_one(db);
REQUIRE(f.is_ok());
REQUIRE(f.value()->at(0).as<unsigned long>() == 4);
REQUIRE(f.value()->at(1).as<unsigned long>() == 2);
REQUIRE(f.value()->at(0).as<uint32_t>() == 4);
REQUIRE(f.value()->at(1).as<uint32_t>() == 2);
REQUIRE(f.value()->at(2).as<std::string>() == "hans");
}
TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and join_left", "[query][foreign][join_left]")
{
schema.attach<airplane>("airplane");
schema.attach<flight>("flight");
TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and join_left", "[query][foreign][join_left]") {
auto result = schema.attach<airplane>("airplane")
.and_then( [this] { return schema.attach<flight>("flight");} );
REQUIRE(result.is_ok());
auto res = query::create()
.table<airplane>("airplane", schema)
.execute(db);
@@ -221,10 +226,10 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and join_left"
REQUIRE(db.exists("flight"));
tables_to_drop.emplace("flight");
std::vector<matador::object_ptr<airplane>> planes{
matador::object_ptr<airplane>(new airplane{1, "Airbus", "A380"}),
matador::object_ptr<airplane>(new airplane{2, "Boeing", "707"}),
matador::object_ptr<airplane>(new airplane{3, "Boeing", "747"})
std::vector planes{
object_ptr(new airplane{1, "Airbus", "A380"}),
object_ptr(new airplane{2, "Boeing", "707"}),
object_ptr(new airplane{3, "Boeing", "747"})
};
for (const auto &plane: planes) {
@@ -241,11 +246,11 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and join_left"
.fetch_value<int>(db).value();
REQUIRE(count == 3);
std::vector<matador::object_ptr<flight>> flights{
matador::object_ptr<flight>(new flight{4, planes.at(0), "hans"}),
matador::object_ptr<flight>(new flight{5, planes.at(0), "otto"}),
matador::object_ptr<flight>(new flight{6, planes.at(1), "george"}),
matador::object_ptr<flight>(new flight{7, planes.at(2), "paul"})
std::vector flights{
object_ptr(new flight{4, planes.at(0), "hans"}),
object_ptr(new flight{5, planes.at(0), "otto"}),
object_ptr(new flight{6, planes.at(1), "george"}),
object_ptr(new flight{7, planes.at(2), "paul"})
};
for (const auto &f: flights) {
@@ -262,35 +267,37 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and join_left"
.fetch_one(db);
REQUIRE(f.is_ok());
REQUIRE(f->has_value());
REQUIRE(f.value()->at(0).as<unsigned long>() == 4);
REQUIRE(f.value()->at(1).as<unsigned long>() == 1);
REQUIRE(f.value()->at(0).as<uint32_t>() == 4);
REQUIRE(f.value()->at(1).as<uint32_t>() == 1);
REQUIRE(f.value()->at(2).as<std::string>() == "hans");
auto result = query::select({"f.id", "ap.brand", "ap.model", "f.pilot_name"})
auto select_result = query::select({"f.id", "ap.brand", "ap.model", "f.pilot_name"})
.from({"flight", "f"})
.join_left({"airplane", "ap"})
.on("f.airplane_id"_col == "ap.id"_col)
.order_by("f.id").asc()
.fetch_all(db);
REQUIRE(result.is_ok());
REQUIRE(select_result.is_ok());
std::vector<std::pair<unsigned long, std::string>> expected_result {
std::vector<std::pair<uint32_t, std::string>> expected_result {
{4, "hans"},
{5, "otto"},
{6, "george"},
{7, "paul"}
};
size_t index{0};
for (const auto &r: *result) {
for (const auto &r: *select_result) {
REQUIRE(r.size() == 4);
REQUIRE(r.at(0).as<unsigned long>() == expected_result[index].first);
REQUIRE(r.at(0).as<uint32_t>() == expected_result[index].first);
REQUIRE(r.at(3).as<std::string>() == expected_result[index++].second);
}
}
TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and for single entity", "[query][join_left][find]") {
schema.attach<airplane>("airplane");
schema.attach<flight>("flight");
auto result = schema.attach<airplane>("airplane")
.and_then( [this] { return schema.attach<flight>("flight");} );
REQUIRE(result.is_ok());
auto res = query::create()
.table<airplane>("airplane", schema)
.execute(db);
@@ -309,10 +316,10 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and for single
REQUIRE(db.exists("flight"));
tables_to_drop.emplace("flight");
std::vector<matador::object_ptr<airplane>> planes{
matador::object_ptr<airplane>(new airplane{1, "Airbus", "A380"}),
matador::object_ptr<airplane>(new airplane{2, "Boeing", "707"}),
matador::object_ptr<airplane>(new airplane{3, "Boeing", "747"})
std::vector planes{
object_ptr(new airplane{1, "Airbus", "A380"}),
object_ptr(new airplane{2, "Boeing", "707"}),
object_ptr(new airplane{3, "Boeing", "747"})
};
for (const auto &plane: planes) {
@@ -331,11 +338,11 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and for single
REQUIRE(count->has_value());
REQUIRE(count->value() == 3);
std::vector<matador::object_ptr<flight>> flights{
matador::object_ptr<flight>(new flight{4, planes.at(0), "hans"}),
matador::object_ptr<flight>(new flight{5, planes.at(0), "otto"}),
matador::object_ptr<flight>(new flight{6, planes.at(1), "george"}),
matador::object_ptr<flight>(new flight{7, planes.at(2), "paul"})
std::vector flights{
object_ptr(new flight{4, planes.at(0), "hans"}),
object_ptr(new flight{5, planes.at(0), "otto"}),
object_ptr(new flight{6, planes.at(1), "george"}),
object_ptr(new flight{7, planes.at(2), "paul"})
};
for (const auto &f: flights) {
@@ -352,11 +359,11 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and for single
.fetch_one(db);
REQUIRE(f.is_ok());
REQUIRE(f->has_value());
REQUIRE(f.value()->at(0).as<unsigned long>() == 4);
REQUIRE(f.value()->at(1).as<unsigned long>() == 1);
REQUIRE(f.value()->at(0).as<uint32_t>() == 4);
REQUIRE(f.value()->at(1).as<uint32_t>() == 1);
REQUIRE(f.value()->at(2).as<std::string>() == "hans");
auto result = query::select({"f.id", "f.airplane_id", "ap.brand", "ap.model", "f.pilot_name"})
auto select_result = query::select({"f.id", "f.airplane_id", "ap.brand", "ap.model", "f.pilot_name"})
.from({"flight", "f"})
.join_left({"airplane", "ap"})
.on("f.airplane_id"_col == "ap.id"_col)
@@ -365,20 +372,22 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and for single
auto expected_flight = flights[0];
REQUIRE(result.is_ok());
REQUIRE(*result);
REQUIRE(result.value()->id == expected_flight->id);
REQUIRE(result.value()->pilot_name == expected_flight->pilot_name);
REQUIRE(result.value()->airplane.get());
REQUIRE(result.value()->airplane->id == 1);
REQUIRE(result.value()->airplane->model == "A380");
REQUIRE(result.value()->airplane->brand == "Airbus");
REQUIRE(select_result.is_ok());
REQUIRE(*select_result);
auto f1 = select_result.release();
REQUIRE(f1->id == expected_flight->id);
REQUIRE(f1->pilot_name == expected_flight->pilot_name);
REQUIRE(f1->airplane.get());
REQUIRE(f1->airplane->id == 1);
REQUIRE(f1->airplane->model == "A380");
REQUIRE(f1->airplane->brand == "Airbus");
}
TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship", "[query][join][many_to_many]") {
schema.attach<recipe>("recipes");
schema.attach<ingredient>("ingredients");
schema.attach<recipe_ingredient>("recipe_ingredients");
auto result = schema.attach<recipe>("recipes")
.and_then( [this] { return schema.attach<ingredient>("ingredients"); } )
.and_then( [this] { return schema.attach<recipe_ingredient>("recipe_ingredients"); } );
auto res = query::create()
.table<recipe>("recipes", schema)
.execute(db);
@@ -460,14 +469,14 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship"
REQUIRE(*res == 1);
}
auto result = query::select({"r.id", "r.name", "ri.ingredient_id"})
auto select_result = query::select({"r.id", "r.name", "ri.ingredient_id"})
.from({"recipes", "r"})
.join_left({"recipe_ingredients", "ri"})
.on("r.id"_col == "ri.recipe_id"_col)
.fetch_all(db);
REQUIRE(result.is_ok());
REQUIRE(select_result.is_ok());
std::vector<std::tuple<unsigned long, std::string, unsigned long>> expected_result_one_join {
std::vector<std::tuple<uint32_t, std::string, uint32_t>> expected_result_one_join {
{7, "Apple Crumble", 1},
{7, "Apple Crumble", 4},
{7, "Apple Crumble", 5},
@@ -478,22 +487,22 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship"
{9, "Fruit Salad", 3}
};
size_t index{0};
for (const auto &r: *result) {
for (const auto &r: *select_result) {
REQUIRE(r.size() == 3);
REQUIRE(r.at(0).as<unsigned long>().value() == std::get<0>(expected_result_one_join[index]));
REQUIRE(r.at(0).as<uint32_t>().value() == std::get<0>(expected_result_one_join[index]));
REQUIRE(r.at(1).as<std::string>().value() == std::get<1>(expected_result_one_join[index]));
REQUIRE(r.at(2).as<unsigned long>().value() == std::get<2>(expected_result_one_join[index]));
REQUIRE(r.at(2).as<uint32_t>().value() == std::get<2>(expected_result_one_join[index]));
++index;
}
result = query::select({"r.id", "r.name", "ri.ingredient_id", "i.name"})
select_result = query::select({"r.id", "r.name", "ri.ingredient_id", "i.name"})
.from({"recipes", "r"})
.join_left({"recipe_ingredients", "ri"}).on("r.id"_col == "ri.recipe_id"_col)
.join_left({"ingredients", "i"}).on("ri.ingredient_id"_col == "i.id"_col)
.fetch_all(db);
REQUIRE(result.is_ok());
std::vector<std::tuple<unsigned long, std::string, unsigned long, std::string>> expected_result_two_joins {
std::vector<std::tuple<uint32_t, std::string, uint32_t, std::string>> expected_result_two_joins {
{7, "Apple Crumble", 1, "Apple"},
{7, "Apple Crumble", 4, "Sugar"},
{7, "Apple Crumble", 5, "Flour"},
@@ -504,16 +513,16 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship"
{9, "Fruit Salad", 3, "Pineapple"}
};
index = 0;
for (const auto &r: *result) {
for (const auto &r: *select_result) {
REQUIRE(r.size() == 4);
REQUIRE(r.at(0).as<unsigned long>().value() == std::get<0>(expected_result_two_joins[index]));
REQUIRE(r.at(0).as<uint32_t>().value() == std::get<0>(expected_result_two_joins[index]));
REQUIRE(r.at(1).as<std::string>().value() == std::get<1>(expected_result_two_joins[index]));
REQUIRE(r.at(2).as<unsigned long>().value() == std::get<2>(expected_result_two_joins[index]));
REQUIRE(r.at(2).as<uint32_t>().value() == std::get<2>(expected_result_two_joins[index]));
REQUIRE(r.at(3).as<std::string>().value() == std::get<3>(expected_result_two_joins[index]));
++index;
}
result = query::select({"r.id", "r.name", "ri.ingredient_id", "i.name"})
select_result = query::select({"r.id", "r.name", "ri.ingredient_id", "i.name"})
.from({"recipes", "r"})
.join_left({"recipe_ingredients", "ri"}).on("r.id"_col == "ri.recipe_id"_col)
.join_left({"ingredients", "i"}).on("ri.ingredient_id"_col == "i.id"_col)
@@ -522,11 +531,11 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship"
REQUIRE(result.is_ok());
index = 3;
for (const auto &r: *result) {
for (const auto &r: *select_result) {
REQUIRE(r.size() == 4);
REQUIRE(r.at(0).as<unsigned long>().value() == std::get<0>(expected_result_two_joins[index]));
REQUIRE(r.at(0).as<uint32_t>().value() == std::get<0>(expected_result_two_joins[index]));
REQUIRE(r.at(1).as<std::string>().value() == std::get<1>(expected_result_two_joins[index]));
REQUIRE(r.at(2).as<unsigned long>().value() == std::get<2>(expected_result_two_joins[index]));
REQUIRE(r.at(2).as<uint32_t>().value() == std::get<2>(expected_result_two_joins[index]));
REQUIRE(r.at(3).as<std::string>().value() == std::get<3>(expected_result_two_joins[index]));
++index;
}
test/backends/SessionTest.cpp
+50 -38
View File
@@ -7,52 +7,62 @@
#include "models/book.hpp"
#include "models/flight.hpp"
#include <iostream>
using namespace matador;
using namespace matador::object;
using namespace matador::test;
TEST_CASE_METHOD(SessionFixture, "Session relation test", "[session][relation]") {
ses.attach<airplane>("airplanes");
ses.attach<flight>("flights");
ses.create_schema();
const auto result = ses.attach<airplane>("airplanes")
.and_then([this] { return ses.attach<flight>("flights"); } )
.and_then([this] { return ses.create_schema(); } );
REQUIRE(result.is_ok());
tables_to_drop.emplace("airplanes");
tables_to_drop.emplace("flights");
auto plane = ses.insert<airplane>(1, "Boeing", "A380");
auto f = ses.insert<flight>(2, plane, "sully");
REQUIRE(plane.is_ok());
auto f = ses.insert<flight>(2, *plane, "sully");
REQUIRE(f.is_ok());
const auto result = ses.find<flight>(2);
REQUIRE(result.is_ok());
REQUIRE(result->get()->id == f->id);
REQUIRE(result->get()->pilot_name == f->pilot_name);
REQUIRE(result->get()->airplane);
REQUIRE(result->get()->airplane->id == plane->id);
REQUIRE(result->get()->airplane->brand == plane->brand);
REQUIRE(result->get()->airplane->model == plane->model);
const auto res = ses.find<flight>(2);
REQUIRE(res.is_ok());
auto rf = *res;
REQUIRE(rf->id == (*f)->id);
REQUIRE(rf->pilot_name == (*f)->pilot_name);
REQUIRE(rf->airplane);
REQUIRE(rf->airplane->id == (*plane)->id);
REQUIRE(rf->airplane->brand == (*plane)->brand);
REQUIRE(rf->airplane->model == (*plane)->model);
}
TEST_CASE_METHOD(SessionFixture, "Use session to find object with id", "[session][find]") {
ses.attach<airplane>("airplanes");
ses.create_schema();
const auto result = ses.attach<airplane>("airplanes")
.and_then([this] { return ses.create_schema(); } );
REQUIRE(result.is_ok());
tables_to_drop.emplace("airplanes");
auto a380 = ses.insert<airplane>(1, "Boeing", "A380");
REQUIRE(a380.is_ok());
auto result = ses.find<airplane>(2);
auto res = ses.find<airplane>(2);
REQUIRE(!result.is_ok());
REQUIRE((result.err().ec() == sql::session_error_code::FailedToFindObject));
REQUIRE((result.err().ec() == orm::error_code::FailedToFindObject));
result = ses.find<airplane>(1);
auto find_result = ses.find<airplane>(1);
REQUIRE(result);
auto read_a380 = result.value();
REQUIRE(a380->id == read_a380->id);
REQUIRE(find_result);
auto read_a380 = find_result.value();
REQUIRE((*a380)->id == read_a380->id);
}
TEST_CASE_METHOD(SessionFixture, "Use session to find all objects", "[session][find]") {
ses.attach<airplane>("airplanes");
ses.create_schema();
const auto result = ses.attach<airplane>("airplanes")
.and_then([this] { return ses.create_schema(); } );
REQUIRE(result.is_ok());
tables_to_drop.emplace("airplanes");
@@ -62,18 +72,19 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects", "[session][f
planes.emplace_back(new airplane(3, "Boeing", "747"));
for (auto &&plane: planes) {
ses.insert(plane.release());
auto res = ses.insert(plane.release());
REQUIRE(res.is_ok());
}
auto result = ses.find<airplane>();
auto find_result = ses.find<airplane>();
std::vector<std::tuple<unsigned long, std::string, std::string>> expected_result {
{1, "Airbus", "A380"},
{2, "Boeing", "707"},
{3, "Boeing", "747"}
};
REQUIRE(result);
auto all_planes = result.release();
REQUIRE(find_result);
auto all_planes = find_result.release();
size_t index {0};
for (const auto &i: all_planes) {
REQUIRE(i.id == std::get<0>(expected_result[index]));
@@ -84,25 +95,25 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects", "[session][f
}
TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with one-to-many relation", "[session][find][one-to-many]") {
ses.attach<author>("authors");
ses.attach<book>("books");
auto result = ses.attach<author>("authors")
.and_then( [this] { return ses.attach<book>("books"); } )
.and_then( [this] { return ses.create_schema(); } );
tables_to_drop.emplace("authors");
tables_to_drop.emplace("books");
ses.create_schema();
std::vector<std::unique_ptr<author>> authors;
authors.emplace_back(new author{1, "Michael", "Crichton", "23.10.1942", 1975, true, {}});
authors.emplace_back(new author{ 2, "Steven", "King", "21.9.1947", 1956, false, {}});
for (auto &&a: authors) {
ses.insert(a.release());
auto res = ses.insert(a.release());
REQUIRE(res.is_ok());
}
auto result = ses.find<author>();
REQUIRE(result.is_ok());
auto all_authors = result.release();
auto find_result = ses.find<author>();
REQUIRE(find_result.is_ok());
auto all_authors = find_result.release();
std::vector<object_ptr<author>> author_repo;
for (auto it = all_authors.begin(); it != all_authors.end(); ++it) {
std::cout << "author: " << it->first_name << " (books: " << it->books.size() << ")\n";
@@ -123,13 +134,14 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with one-to-ma
books.emplace_back( new book{12, "The Dark Tower: The Gunslinger", author_repo[1], 1982} );
for (auto &&b: books) {
ses.insert(b.release());
auto res = ses.insert(b.release());
REQUIRE(res.is_ok());
}
result = ses.find<author>();
REQUIRE(result);
find_result = ses.find<author>();
REQUIRE(find_result);
all_authors = result.release();
all_authors = find_result.release();
for (auto it = all_authors.begin(); it != all_authors.end(); ++it) {
std::cout << "author: " << it->first_name << " (books: " << it->books.size() << ")\n";
}
test/backends/StatementCacheTest.cpp
+6 -5
View File
@@ -2,8 +2,9 @@
#include "matador/sql/connection_info.hpp"
#include "matador/sql/connection_pool.hpp"
#include "matador/sql/session.hpp"
#include "matador/sql/statement_cache.hpp"
#include "matador/orm/session.hpp"
// #include "matador/sql/statement_cache.hpp"
#include "connection.hpp"
#include "matador/sql/dialect_builder.hpp"
@@ -14,13 +15,13 @@ class StatementCacheFixture
{
public:
StatementCacheFixture()
: pool(matador::test::connection::dns, 4), ses(pool)
: pool(test::connection::dns, 4), ses(pool)
{}
~StatementCacheFixture() = default;
protected:
matador::sql::connection_pool<matador::sql::connection> pool;
matador::sql::session ses;
sql::connection_pool<matador::sql::connection> pool;
orm::session ses;
};
TEST_CASE_METHOD(StatementCacheFixture, "Acquire prepared statement", "[statement cache]") {
test/backends/StatementTest.cpp
+18 -12
View File
@@ -1,9 +1,12 @@
#include <catch2/catch_test_macros.hpp>
#include "matador/sql/column_definition.hpp"
#include "matador/sql/condition.hpp"
#include "matador/object/attribute_definition.hpp"
#include "matador/sql/connection.hpp"
#include "matador/sql/query.hpp"
#include "matador/sql/column_generator.hpp"
#include "matador/query/condition.hpp"
#include "matador/query/query.hpp"
#include "matador/object/object_ptr.hpp"
@@ -12,6 +15,8 @@
#include "models/airplane.hpp"
using namespace matador::sql;
using namespace matador::object;
using namespace matador::query;
using namespace matador::test;
namespace matador::test::detail {
@@ -35,29 +40,29 @@ public:
}
protected:
std::vector<matador::object_ptr<airplane>> planes{
std::vector<object_ptr<airplane>> planes{
matador::test::detail::make_object_ptr<airplane>(1, "Airbus", "A380"),
matador::test::detail::make_object_ptr<airplane>(2, "Boeing", "707"),
matador::test::detail::make_object_ptr<airplane>(3, "Boeing", "747")
};
};
TEST_CASE_METHOD(StatementTestFixture, "Create prepared statement", "[statement]")
{
TEST_CASE_METHOD(StatementTestFixture, "Create prepared statement", "[statement]") {
using namespace matador::utils;
schema.attach<airplane>("airplane");
REQUIRE(schema.attach<airplane>("airplane"));
table ap{"airplane"};
SECTION("Insert with prepared statement and placeholder") {
auto stmt = query::insert()
.into("airplane", column_generator::generate<airplane>(schema, true))
.values<airplane>()
.prepare(db);
REQUIRE(stmt.is_ok());
for (const auto &plane: planes) {
auto res = stmt.bind(*plane).execute();
auto res = stmt->bind(*plane).execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 1);
stmt.reset();
stmt->reset();
}
auto result = query::select(column_generator::generate<airplane>(schema, true))
@@ -87,8 +92,9 @@ TEST_CASE_METHOD(StatementTestFixture, "Create prepared statement", "[statement]
.from(ap)
.where("brand"_col == _)
.prepare(db);
REQUIRE(stmt.is_ok());
auto result = stmt.bind(0, "Airbus")
auto result = stmt->bind(0, "Airbus")
.fetch<airplane>();
REQUIRE(result.is_ok());
@@ -98,9 +104,9 @@ TEST_CASE_METHOD(StatementTestFixture, "Create prepared statement", "[statement]
REQUIRE(i.model == planes[0]->model);
}
stmt.reset();
stmt->reset();
result = stmt.bind(0, "Boeing")
result = stmt->bind(0, "Boeing")
.fetch<airplane>();
size_t index{1};
test/backends/TypeTraitsTest.cpp
+8 -10
View File
@@ -4,21 +4,21 @@
#include "matador/sql/connection.hpp"
#include "matador/sql/column_generator.hpp"
#include "matador/sql/query.hpp"
#include "matador/query/query.hpp"
#include "QueryFixture.hpp"
#include "models/location.hpp"
using namespace matador::query;
using namespace matador::sql;
using namespace matador::test;
class TypeTraitsTestFixture : public QueryFixture
{
public:
TypeTraitsTestFixture()
{
db.open();
TypeTraitsTestFixture() {
REQUIRE(db.open());
const auto res = query::create()
.table<location>("location", schema)
.execute(db);
@@ -26,9 +26,8 @@ public:
}
};
TEST_CASE_METHOD(TypeTraitsTestFixture, "Special handling of attributes with type traits", "[typetraits]")
{
schema.attach<location>("location");
TEST_CASE_METHOD(TypeTraitsTestFixture, "Special handling of attributes with type traits", "[typetraits]") {
REQUIRE(schema.attach<location>("location"));
SECTION("Insert and select with direct execution") {
location loc{1, "center", {1, 2, 3}, Color::Black};
@@ -58,9 +57,8 @@ TEST_CASE_METHOD(TypeTraitsTestFixture, "Special handling of attributes with typ
.into("location", column_generator::generate<location>(schema, true))
.values<location>()
.prepare(db);
auto res = stmt
.bind(loc)
REQUIRE(stmt);
auto res = stmt->bind(loc)
.execute();
REQUIRE(res.is_ok());
REQUIRE(*res == 1);
test/models/book.hpp
+1 -1
View File
@@ -14,8 +14,8 @@ struct author;
struct book {
unsigned int id{};
matador::object::object_ptr<author> book_author;
std::string title;
object::object_ptr<author> book_author;
unsigned short published_in{};
template<typename Operator>
test/models/flight.hpp
+1 -1
View File
@@ -21,7 +21,7 @@ struct flight
: id(id), airplane(plane), pilot_name(std::move(name)) {}
unsigned int id{};
object::object_ptr<test::airplane> airplane;
object::object_ptr<airplane> airplane;
std::string pilot_name;
template<class Operator>
test/models/person.hpp
+30
View File
@@ -0,0 +1,30 @@
#ifndef QUERY_PERSON_HPP
#define QUERY_PERSON_HPP
#include "matador/utils/access.hpp"
#include "matador/utils/field_attributes.hpp"
#include "matador/utils/types.hpp"
#include <string>
namespace matador::test {
struct person {
unsigned int id{};
std::string name;
unsigned int age{};
utils::blob image;
template<class Operator>
void process(Operator &op) {
namespace field = matador::access;
using namespace matador::utils;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 255);
field::attribute(op, "age", age);
field::attribute(op, "image", image);
}
};
}
#endif //QUERY_PERSON_HPP
test/models/types.hpp
+3 -7
View File
@@ -11,15 +11,13 @@ struct types
enum { CSTR_LEN=255 };
unsigned int id_ = 0;
char char_ = 'c';
int8_t char_ = 'c';
short short_ = -127;
int int_ = -65000;
long long_ = -128000;
long long long64_ = -1234567890;
unsigned char unsigned_char_ = 'H';
unsigned short unsigned_short_ = 128;
unsigned int unsigned_int_ = 65000;
unsigned long unsigned_long_ = 128000;
unsigned long long unsigned_long64_ = 1234567890;
float float_ = 3.1415f;
double double_ = 1.1414;
@@ -42,19 +40,17 @@ struct types
field::attribute(op, "val_double", double_);
field::attribute(op, "val_short", short_);
field::attribute(op, "val_int", int_);
field::attribute(op, "val_long", long_);
field::attribute(op, "val_long_long", long64_);
field::attribute(op, "val_unsigned_char", unsigned_char_);
field::attribute(op, "val_unsigned_short", unsigned_short_);
field::attribute(op, "val_unsigned_int", unsigned_int_);
field::attribute(op, "val_unsigned_long", unsigned_long_);
field::attribute(op, "val_unsigned_long_long", unsigned_long64_);
field::attribute(op, "val_bool", bool_);
field::attribute(op, "val_cstr", cstr_, CSTR_LEN);
field::attribute(op, "val_string", string_);
field::attribute(op, "val_varchar", varchar_, 63);
field::attribute(op, "val_date", date_);
field::attribute(op, "val_time", time_);
// field::attribute(op, "val_date", date_);
// field::attribute(op, "val_time", time_);
field::attribute(op, "val_binary", binary_);
}
};