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

added more tests

Browse Source
This commit is contained in:
Sascha Kühl
2025-02-06 16:17:47 +01:00
parent c76aa56440
commit 0b70f5d4ee
68 changed files with 2117 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/models/airplane.hpp
+37
View File
@@ -0,0 +1,37 @@
#ifndef QUERY_AIRPLANE_HPP
#define QUERY_AIRPLANE_HPP
#include "category.hpp"
#include "supplier.hpp"
#include "matador/utils/access.hpp"
#include "matador/utils/cascade_type.hpp"
#include "matador/utils/field_attributes.hpp"
#include <string>
namespace matador::test {
struct airplane {
airplane() = default;
airplane(unsigned int id, std::string b, std::string m)
: id(id)
, brand(std::move(b))
, model(std::move(m)) {}
unsigned int id{};
std::string brand;
std::string model;
template<class Operator>
void process(Operator &op) {
namespace field = matador::access;
using namespace matador::utils;
field::primary_key(op, "id", id);
field::attribute(op, "brand", brand, 255);
field::attribute(op, "model", model, 255);
}
};
}
#endif //QUERY_AIRPLANE_HPP
test/models/author.hpp
+40
View File
@@ -0,0 +1,40 @@
#ifndef QUERY_AUTHOR_HPP
#define QUERY_AUTHOR_HPP
#include "matador/utils/access.hpp"
#include "matador/object/object_ptr.hpp"
#include <string>
#include <vector>
namespace matador::test {
struct book;
struct author {
unsigned int id{};
std::string first_name;
std::string last_name;
std::string date_of_birth;
unsigned short year_of_birth{};
bool distinguished{false};
std::vector<matador::object::object_ptr<book>> books;
template<typename Operator>
void process(Operator &op)
{
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "first_name", first_name, 63);
field::attribute(op, "last_name", last_name, 63);
field::attribute(op, "date_of_birth", date_of_birth, 31);
field::attribute(op, "year_of_birth", year_of_birth);
field::attribute(op, "distinguished", distinguished);
// field::has_many(op, books, "author_id", utils::fetch_type::LAZY);
}
};
}
#endif //QUERY_AUTHOR_HPP
test/models/book.hpp
+33
View File
@@ -0,0 +1,33 @@
#ifndef QUERY_BOOK_HPP
#define QUERY_BOOK_HPP
#include "matador/object/object_ptr.hpp"
#include "matador/utils/access.hpp"
#include "matador/utils/foreign_attributes.hpp"
#include <string>
namespace matador::test {
struct author;
struct book {
unsigned int id{};
matador::object::object_ptr<author> book_author;
std::string title;
unsigned short published_in{};
template<typename Operator>
void process(Operator &op)
{
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "title", title, 511);
field::belongs_to(op, "author_id", book_author, utils::fetch_type::EAGER);
field::attribute(op, "published_in", published_in);
}
};
}
#endif //QUERY_BOOK_HPP
test/models/category.hpp
+24
View File
@@ -0,0 +1,24 @@
#ifndef QUERY_CATEGORY_HPP
#define QUERY_CATEGORY_HPP
#include "matador/utils/access.hpp"
#include <string>
namespace matador::test {
struct category {
unsigned int id{};
std::string name;
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);
}
};
}
#endif //QUERY_CATEGORY_HPP
test/models/flight.hpp
+39
View File
@@ -0,0 +1,39 @@
#ifndef QUERY_FLIGHT_HPP
#define QUERY_FLIGHT_HPP
#include "airplane.hpp"
#include "matador/utils/access.hpp"
#include "matador/utils/cascade_type.hpp"
#include "matador/utils/fetch_type.hpp"
#include "matador/object/object_ptr.hpp"
#include <string>
#include <utility>
namespace matador::test {
struct flight
{
flight() = default;
flight(const unsigned int id, const object::object_ptr<airplane> &plane, std::string name)
: id(id), airplane(plane), pilot_name(std::move(name)) {}
unsigned int id{};
object::object_ptr<test::airplane> airplane;
std::string pilot_name;
template<class Operator>
void process(Operator &op) {
namespace field = matador::access;
using namespace matador::utils;
field::primary_key(op, "id", id);
// field::has_one(op, "airplane_id", airplane, {utils::cascade_type::ALL, utils::fetch_type::EAGER});
field::attribute(op, "pilot_name", pilot_name, 255);
}
};
}
#endif //QUERY_FLIGHT_HPP
test/models/location.hpp
+1 -1
View File
@@ -15,7 +15,7 @@ enum class Color : uint8_t {
struct location
{
unsigned long id{};
unsigned int id{};
std::string name;
coordinate coord;
Color color{Color::Green};
test/models/optional.hpp
+30
View File
@@ -0,0 +1,30 @@
#ifndef QUERY_OPTIONAL_HPP
#define QUERY_OPTIONAL_HPP
#include "matador/utils/access.hpp"
#include "matador/utils/field_attributes.hpp"
#include <optional>
#include <string>
namespace matador::test {
struct optional
{
unsigned int id{};
std::optional<std::string> name;
std::optional<unsigned int> age{};
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);
}
};
}
#endif //QUERY_OPTIONAL_HPP
test/models/order.hpp
+50
View File
@@ -0,0 +1,50 @@
#ifndef QUERY_ORDER_HPP
#define QUERY_ORDER_HPP
#include "order_details.hpp"
#include "matador/utils/access.hpp"
#include "matador/object/object_ptr.hpp"
#include <vector>
namespace matador::test {
struct order
{
unsigned int order_id{};
std::string order_date;
std::string required_date;
std::string shipped_date;
unsigned int ship_via{};
unsigned int freight{};
std::string ship_name;
std::string ship_address;
std::string ship_city;
std::string ship_region;
std::string ship_postal_code;
std::string ship_country;
std::vector<matador::object::object_ptr<order_details>> order_details_;
template<class Operator>
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "order_id", order_id);
field::attribute(op, "order_date", order_date, 255);
field::attribute(op, "required_date", required_date, 255);
field::attribute(op, "shipped_date", shipped_date, 255);
field::attribute(op, "ship_via", ship_via);
field::attribute(op, "freight", freight);
field::attribute(op, "ship_name", ship_name, 255);
field::attribute(op, "ship_address", ship_address, 255);
field::attribute(op, "ship_city", ship_city, 255);
field::attribute(op, "ship_region", ship_region, 255);
field::attribute(op, "ship_postal_code", ship_postal_code, 255);
field::attribute(op, "ship_country", ship_country, 255);
// field::has_many(op, order_details_, "order_id", utils::fetch_type::EAGER);
}
};
}
#endif //QUERY_ORDER_HPP
test/models/order_details.hpp
+30
View File
@@ -0,0 +1,30 @@
#ifndef QUERY_ORDER_DETAILS_HPP
#define QUERY_ORDER_DETAILS_HPP
#include "product.hpp"
#include "matador/object/object_ptr.hpp"
#include "matador/utils/foreign_attributes.hpp"
namespace matador::test {
struct order;
struct order_details
{
unsigned int order_details_id;
matador::object::object_ptr<order> order_;
matador::object::object_ptr<product> product_;
template<class Operator>
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "order_details_id", order_details_id);
field::belongs_to(op, "order_id", order_, utils::default_foreign_attributes);
field::has_one(op, "product_id", product_, utils::default_foreign_attributes);
}
};
}
#endif //QUERY_ORDER_DETAILS_HPP
test/models/product.hpp
+45
View File
@@ -0,0 +1,45 @@
#ifndef QUERY_PRODUCT_HPP
#define QUERY_PRODUCT_HPP
#include "category.hpp"
#include "supplier.hpp"
#include "matador/utils/access.hpp"
#include "matador/utils/cascade_type.hpp"
#include "matador/utils/field_attributes.hpp"
#include "matador/object/object_ptr.hpp"
#include <string>
namespace matador::test {
struct product {
std::string product_name;
object::object_ptr<test::supplier> supplier;
object::object_ptr<test::category> category;
std::string quantity_per_unit;
unsigned int unit_price;
unsigned int units_in_stock;
unsigned int units_in_order;
unsigned int reorder_level;
bool discontinued;
template<class Operator>
void process(Operator &op) {
namespace field = matador::access;
using namespace matador::utils;
field::primary_key(op, "product_name", product_name, 255);
field::has_one(op, "supplier_id", supplier, utils::cascade_type::ALL);
field::has_one(op, "category_id", category, utils::cascade_type::ALL);
field::attribute(op, "quantity_per_unit", quantity_per_unit, 255);
field::attribute(op, "unit_price", unit_price);
field::attribute(op, "units_in_stock", units_in_stock);
field::attribute(op, "units_in_order", units_in_order);
field::attribute(op, "reorder_level", reorder_level);
field::attribute(op, "discontinued", discontinued);
}
};
}
#endif //QUERY_PRODUCT_HPP
test/models/recipe.hpp
+52
View File
@@ -0,0 +1,52 @@
#ifndef QUERY_RECIPE_HPP
#define QUERY_RECIPE_HPP
#include "matador/utils/access.hpp"
#include "matador/utils/foreign_attributes.hpp"
#include "matador/object/object_ptr.hpp"
#include "matador/object/many_to_many_relation.hpp"
#include <string>
namespace matador::test {
struct recipe;
struct ingredient
{
unsigned int id{};
std::string name;
std::vector<matador::object::object_ptr<recipe>> recipes;
template<class Operator>
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 255);
// field::has_many_to_many(op, "recipe_ingredients", recipes, "ingredient_id", "recipe_id", utils::fetch_type::EAGER);
}
};
struct recipe
{
unsigned int id{};
std::string name;
std::vector<matador::object::object_ptr<ingredient>> ingredients;
template<class Operator>
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 255);
// field::has_many_to_many(op, "recipe_ingredients", ingredients, utils::fetch_type::LAZY);
}
};
class recipe_ingredient : public object::many_to_many_relation<recipe, ingredient> {
public:
recipe_ingredient() : many_to_many_relation("recipe_id", "ingredient_id") {}
};
}
#endif //QUERY_RECIPE_HPP
test/models/student.hpp
+62
View File
@@ -0,0 +1,62 @@
#ifndef QUERY_STUDENT_HPP
#define QUERY_STUDENT_HPP
#include "matador/utils/access.hpp"
#include "matador/utils/foreign_attributes.hpp"
#include "matador/object/object_ptr.hpp"
#include "matador/object/many_to_many_relation.hpp"
#include <utility>
#include <vector>
namespace matador::test {
struct course;
struct student {
unsigned int id{};
std::string name;
std::vector<matador::object::object_ptr<course>> courses;
student() = default;
explicit student(unsigned int id, std::string name)
: id(id)
, name(std::move(name)) {}
template < class Operator >
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 255);
// field::has_many_to_many(op, "student_courses", courses, "student_id", "course_id", utils::fetch_type::LAZY);
}
};
struct course {
unsigned int id{};
std::string title;
std::vector<matador::object::object_ptr<student>> students;
course() = default;
explicit course(unsigned int id, std::string title)
: id(id)
, title(std::move(title)) {}
template < class Operator >
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "title", title, 255);
// field::has_many_to_many(op, "student_courses", students, utils::fetch_type::EAGER);
}
};
class student_course : public object::many_to_many_relation<student, course> {
public:
student_course() : many_to_many_relation("student_id", "course_id") {}
};
}
#endif //QUERY_STUDENT_HPP
test/models/supplier.hpp
+24
View File
@@ -0,0 +1,24 @@
#ifndef QUERY_SUPPLIER_HPP
#define QUERY_SUPPLIER_HPP
#include "matador/utils/access.hpp"
#include <string>
namespace matador::test {
struct supplier {
unsigned int id{};
std::string name;
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);
}
};
}
#endif //QUERY_SUPPLIER_HPP
test/models/types.hpp
+3 -3
View File
@@ -10,7 +10,7 @@ struct types
{
enum { CSTR_LEN=255 };
unsigned long id_ = 0;
unsigned int id_ = 0;
char char_ = 'c';
short short_ = -127;
int int_ = -65000;
@@ -27,8 +27,8 @@ struct types
char cstr_[CSTR_LEN]{};
std::string string_ = "Welt";
std::string varchar_ = "Erde";
matador::date date_;
matador::time time_;
// matador::date date_;
// matador::time time_;
utils::blob binary_{ 1, 2, 3, 4 };
template < class Operator >