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

insert_query_builder progress

This commit is contained in:
Sascha Kühl 2026-04-12 22:07:24 +02:00
parent f03664d60a
commit a0326632ab
25 changed files with 319 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
include/matador/orm/session.hpp
View File

@ -7,6 +7,7 @@
#include "matador/query/criteria.hpp"
#include "matador/query/insert_query_builder.hpp"
#include "matador/query/query.hpp"
#include "matador/query/query_contexts.hpp"
#include "matador/query/generator.hpp"
#include "matador/query/schema.hpp"
@ -89,6 +90,7 @@ private:
const query::basic_schema &schema_;
mutable std::unordered_map<std::string, std::vector<object::attribute> > prototypes_;
std::shared_ptr<sql::resolver_service> resolver_service_;
std::unordered_map<std::type_index, query::query_contexts> contexts_by_type_;
};
template<typename Type>
@ -103,63 +105,72 @@ utils::result<object::object_ptr<Type>, utils::error> session::insert(object::ob
}
// Build dependency-ordered insert steps (deps first, root last)
query::insert_query_builder iqb(schema_);
query::insert_query_builder iqb(schema_, contexts_by_type_);
auto steps = iqb.build(obj);
if (!steps.is_ok()) {
return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build insert dependency queries."));
}
// Execute all steps; for Identity steps read RETURNING and write pk back into the object
// for (auto &step : *steps) {
// if (step.pk_is_unset && step.set_pk) {
// if (step.pk_generator == utils::generator_type::Manual) {
// if (step.pk_is_unset()) {
// return utils::failure(make_error(error_code::NoPrimaryKey, "Manual primary key is required but unset."));
// }
// } else if (step.pk_generator == utils::generator_type::Sequence) {
// if (step.pk_is_unset()) {
// // hard-coded naming as you specified earlier
// // <table_name>_seq (table name known in schema meta; if you prefer, store it in step too)
// // For now, we derive from the schema type used for the root insert: simplistic but works if table name == entity name.
// const std::string seq_name = it->second.name() + "_seq";
//
// auto id_res = query::select().nextval(seq_name).fetch_value<std::uint64_t>(*this);
// if (!id_res.is_ok() || !id_res.value().has_value()) {
// return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to obtain next sequence value."));
// }
// step.set_pk(*id_res.value());
// }
// } else if (step.pk_generator == utils::generator_type::Table) {
// if (step.pk_is_unset()) {
// // TODO: implement table id generation; same idea as above:
// // UPDATE <table>_tbl_seq ... RETURNING ...
// return utils::failure(make_error(error_code::Failed, "Table primary key generator not implemented yet."));
// }
// }
// }
//
// // --- Execute step ---
// if (std::holds_alternative<query::executable_query>(step.query)) {
// const auto &q = std::get<query::executable_query>(step.query);
// const auto exec_res = q.execute(*this);
// if (!exec_res.is_ok()) {
// return utils::failure(exec_res.err());
// }
// continue;
// }
//
// const auto &q = std::get<query::fetchable_query>(step.query);
// auto rec_res = q.fetch_one(*this);
// if (!rec_res.is_ok()) {
// return utils::failure(rec_res.err());
// }
// if (!rec_res.value().has_value()) {
// return utils::failure(make_error(error_code::FailedToFindObject, "INSERT ... RETURNING did not return a row."));
// }
// if (step.apply_returning) {
// step.apply_returning(*rec_res.value());
// }
// }
for (auto &step : *steps) {
// if (step.pk_is_unset && step.set_pk) {
// if (step.pk_generator == utils::generator_type::Manual) {
// if (step.pk_is_unset()) {
// return utils::failure(make_error(error_code::NoPrimaryKey, "Manual primary key is required but unset."));
// }
// } else if (step.pk_generator == utils::generator_type::Sequence) {
// if (step.pk_is_unset()) {
// // hard-coded naming as you specified earlier
// // <table_name>_seq (table name known in schema meta; if you prefer, store it in step too)
// // For now, we derive from the schema type used for the root insert: simplistic but works if table name == entity name.
// const std::string seq_name = it->second.name() + "_seq";
//
// auto id_res = query::select().nextval(seq_name).fetch_value<std::uint64_t>(*this);
// if (!id_res.is_ok() || !id_res.value().has_value()) {
// return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to obtain next sequence value."));
// }
// step.set_pk(*id_res.value());
// }
// } else if (step.pk_generator == utils::generator_type::Table) {
// if (step.pk_is_unset()) {
// // TODO: implement table id generation; same idea as above:
// // UPDATE <table>_tbl_seq ... RETURNING ...
// return utils::failure(make_error(error_code::Failed, "Table primary key generator not implemented yet."));
// }
// }
// }
auto result = step.acquire_and_bind(cache_);
if (!result.is_ok()) {
return utils::failure(result.err());
}
if (const auto exec_result = result->execute(); !exec_result.is_ok()) {
return utils::failure(exec_result.err());
}
// --- Execute step ---
// if (std::holds_alternative<query::executable_query>(step.query)) {
// const auto &q = std::get<query::executable_query>(step.query);
// const auto exec_res = q.execute(*this);
// if (!exec_res.is_ok()) {
// return utils::failure(exec_res.err());
// }
// continue;
// }
//
// const auto &q = std::get<query::fetchable_query>(step.query);
// auto rec_res = q.fetch_one(*this);
// if (!rec_res.is_ok()) {
// return utils::failure(rec_res.err());
// }
// if (!rec_res.value().has_value()) {
// return utils::failure(make_error(error_code::FailedToFindObject, "INSERT ... RETURNING did not return a row."));
// }
// if (step.apply_returning) {
// step.apply_returning(*rec_res.value());
// }
}
obj.change_state(object::object_state::Persistent);
return utils::ok(obj);

2
include/matador/query/generator.hpp
View File

@ -280,6 +280,8 @@ std::vector<utils::placeholder> placeholders(const Type &obj) {
return generator.generate(obj);
}
std::vector<utils::placeholder> placeholders(size_t num);
template<typename Type>
std::vector<internal::column_value_pair> column_value_pairs(const Type &obj, const column_value_generator_options options = column_value_generator_options::None) {
column_value_generator generator(options);

66
include/matador/query/insert_query_builder.hpp
View File

@ -1,20 +1,65 @@
#ifndef MATADOR_INSERT_QUERY_BUILDER_HPP
#define MATADOR_INSERT_QUERY_BUILDER_HPP
#include <utility>
#include "matador/query/basic_schema.hpp"
#include "matador/query/intermediates/executable_query.hpp"
#include "matador/query/query.hpp"
#include "matador/query/query_contexts.hpp"
#include "matador/query/query_builder_exception.hpp"
#include "matador/sql/statement.hpp"
#include "matador/utils/primary_key_accessor.hpp"
namespace matador::sql {
class statement_cache;
}
namespace matador::query {
template < class ObjectType >
class has_many_linker {
public:
has_many_linker(const object::object_ptr<ObjectType> &ptr, std::string join_column)
: ptr_(ptr), join_column_(std::move(join_column)) {}
template < class PrimaryKeyType >
static void on_primary_key(const char * /*id*/, PrimaryKeyType &, const utils::primary_key_attribute& /*attr*/) {}
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
template<typename Type>
static void on_attribute(const char * /*id*/, Type &, const utils::field_attributes &/*attr*/) {}
template<class Pointer>
static void on_belongs_to(const char * /*id*/, Pointer &/*obj*/, const utils::foreign_attributes &/*attr*/) {}
void on_belongs_to(const char *id, object::object_ptr<ObjectType> &obj, const utils::foreign_attributes &/*attr*/) {
if (id != join_column_) {
return;
}
obj = ptr_;
}
template<class Pointer>
static void on_has_one(const char * /*id*/, Pointer &/*obj*/, const utils::foreign_attributes &/*attr*/) {}
template<class CollectionType>
static void on_has_many(const char * /*id*/, CollectionType &/*con*/, const char *, const utils::foreign_attributes &/*attr*/, std::enable_if_t<!object::is_object_ptr<typename CollectionType::value_type>::value> * = nullptr) {}
template<class Collection>
static void on_has_many_to_many(const char * /*id*/, Collection &/*container*/, const char * /*join_column*/, const char * /*inverse_join_column*/, const utils::foreign_attributes & ) {}
template<class Collection>
static void on_has_many_to_many(const char * /*id*/, Collection &/*container*/, const utils::foreign_attributes & ) {}
private:
object::object_ptr<ObjectType> ptr_;
std::string join_column_;
};
class insert_query_builder {
public:
using step_query_t = std::variant<executable_query, fetchable_query>;
struct insert_step {
step_query_t query;
sql::query_context ctx;
utils::result<sql::statement, utils::error> acquire_and_bind(sql::statement_cache &cache) const;
// Session uses these to handle manual/sequence/table pre-insert PKs
utils::generator_type pk_generator{utils::generator_type::Manual};
@ -22,10 +67,11 @@ public:
// Identity post-insert
std::function<void(const sql::record &)> apply_returning{};
std::function<void(sql::statement &)> bind_object{};
};
public:
explicit insert_query_builder(const basic_schema &schema);
explicit insert_query_builder(const basic_schema &schema, const std::unordered_map<std::type_index, query_contexts> &contexts_by_type);
template<class EntityType>
utils::result<std::vector<insert_step>, query_build_error> build(const object::object_ptr<EntityType> &ptr) {
@ -47,10 +93,9 @@ public:
return utils::ok(steps_);
}
template < class V >
static void on_primary_key(const char * /*id*/, V &, const utils::primary_key_attribute& /*attr*/) {}
template < class PrimaryKeyType >
static void on_primary_key(const char * /*id*/, PrimaryKeyType &, const utils::primary_key_attribute& /*attr*/) {}
static void on_revision(const char *id, uint64_t &/*rev*/);
template<typename Type>
static void on_attribute(const char * /*id*/, Type &, const utils::field_attributes &/*attr*/) {}
@ -165,10 +210,16 @@ private:
step.pk_generator = it->second.pk_generator().type();
}
const auto cit = contexts_by_type_.find(it->second.node().info().type_index());
if (cit == contexts_by_type_.end()) {
throw query_builder_exception(query_build_error::UnknownType);
}
step.ctx = cit->second.insert;
step.bind_object = [ptr](sql::statement &stmt) { stmt.bind(*ptr); };
if (info.has_primary_key() && step.pk_generator == utils::generator_type::Identity) {
const auto pk_name = info.primary_key_attribute()->name();
const table_column pk_col(&it->second.table(), pk_name);
step.query = fetchable_query{insert().into(it->second.table()).values(*ptr).returning(pk_col)};
// step.query = fetchable_query{insert().into(it->second.table()).values(*ptr).returning(pk_col)};
step.apply_returning = [ptr, &step, pk_name = pk_name](const sql::record &rec) {
const auto& f = rec.at(pk_name);
utils::identifier id;
@ -176,7 +227,7 @@ private:
step.pk_accessor.set(*ptr, id);
};
} else {
step.query = executable_query{insert().into(it->second.table()).values(*ptr)};
// step.query = executable_query{insert().into(it->second.table()).values(*ptr)};
}
steps_.push_back(std::move(step));
}
@ -197,6 +248,7 @@ private:
}
private:
const basic_schema &schema_;
const std::unordered_map<std::type_index, query_contexts> &contexts_by_type_;
std::vector<insert_step> steps_;
std::vector<insert_step> relation_steps_;

3
include/matador/query/intermediates/executable_query.hpp
View File

@ -7,6 +7,7 @@
#include "../../utils/result.hpp"
namespace matador::sql {
class dialect;
class executor;
class statement;
struct execute_result;
@ -21,7 +22,7 @@ public:
[[nodiscard]] utils::result<sql::execute_result, utils::error> execute(const sql::executor &exec) const;
[[nodiscard]] utils::result<sql::statement, utils::error> prepare(sql::executor &exec) const;
[[nodiscard]] sql::query_context compile(const sql::executor &exec) const;
[[nodiscard]] sql::query_context compile(const sql::dialect &d) const;
[[nodiscard]] std::string str(const sql::executor &exec) const;
};

15
include/matador/query/query_contexts.hpp Normal file
View File

@ -0,0 +1,15 @@
#ifndef MATADOR_QUERY_CONTEXTS_HPP
#define MATADOR_QUERY_CONTEXTS_HPP
#include "matador/sql/query_context.hpp"
namespace matador::query {
struct query_contexts {
sql::query_context insert;
sql::query_context update_one;
sql::query_context delete_one;
sql::query_context select_one;
sql::query_context select_all;
};
}
#endif //MATADOR_QUERY_CONTEXTS_HPP

4
include/matador/query/schema.hpp
View File

@ -256,8 +256,8 @@ public:
void dump(std::ostream &os) const;
private:
[[nodiscard]] static sql::query_context build_add_constraint_context(const object::repository_node& node, const object::restriction& cons, const sql::connection &conn) ;
[[nodiscard]] static sql::query_context build_drop_constraint_context(const object::repository_node& node, const object::restriction& cons, const sql::connection &conn) ;
[[nodiscard]] static sql::query_context build_add_constraint_context(const object::repository_node& node, const object::restriction& cons, const sql::dialect &d) ;
[[nodiscard]] static sql::query_context build_drop_constraint_context(const object::repository_node& node, const object::restriction& cons, const sql::dialect &d) ;
iterator insert_table(const std::type_index& ti, const object::repository_node &node, utils::generator_type generator_type);

7
include/matador/query/table.hpp
View File

@ -1,6 +1,8 @@
#ifndef QUERY_TABLE_HPP
#define QUERY_TABLE_HPP
#include <optional>
#include "matador/query/table_column.hpp"
#include <string>
@ -41,11 +43,12 @@ public:
[[nodiscard]] bool is_relation_table() const;
[[nodiscard]] bool has_primary_key() const;
[[nodiscard]] std::optional<table_column*> primary_key_column() const;
[[nodiscard]] const std::string& join_column_name() const;
[[nodiscard]] const std::string& inverse_join_column_name() const;
protected:
static const table_column& create_column(class table& tab, const std::string& name);
// static const table_column& create_column(class table& tab, const std::string& name);
table(std::string name, std::string alias, const std::vector<table_column>& columns);
@ -58,7 +61,7 @@ private:
std::string schema_name_;
std::vector<table_column> columns_;
std::string pk_column_name_;
std::optional<table_column*> pk_column_{std::nullopt};
std::string join_column_name_;
std::string inverse_join_column_name_;
};

5
include/matador/query/table_column.hpp
View File

@ -91,6 +91,11 @@ public:
[[nodiscard]] bool is_function() const;
[[nodiscard]] bool is_nullable() const;
[[nodiscard]] bool is_primary_key() const;
[[nodiscard]] bool is_foreign_key() const;
[[nodiscard]] bool is_unique() const;
[[nodiscard]] bool is_identity() const;
[[nodiscard]] sql::sql_function_t function() const;
[[nodiscard]] bool has_alias() const;

7
include/matador/sql/statement.hpp
View File

@ -62,6 +62,8 @@ public:
*/
template<class Type>
statement &bind(const Type &obj);
template<class Type>
statement &bind(const object::object_ptr<Type> &ptr);
template<typename Type>
statement &bind(size_t pos, Type &value);
@ -161,6 +163,11 @@ statement &statement::bind(const Type &obj) {
return *this;
}
template<class Type>
statement &statement::bind(const object::object_ptr<Type> &ptr) {
return bind(*ptr);
}
template<class Type>
utils::result<query_result<Type>, utils::error> statement::fetch() {
std::cout << statement_proxy_->sql() << std::endl;

12
include/matador/utils/result.hpp
View File

@ -18,8 +18,7 @@ template < typename ValueType, typename ErrorType >
struct is_result<result<ValueType, ErrorType>> : std::true_type {};
template < typename ValueType >
class ok
{
class ok {
public:
using value_type = ValueType;
explicit constexpr ok(const ValueType &value) : value_(value) {}
@ -34,16 +33,14 @@ private:
};
template <>
class ok<void>
{
class ok<void> {
public:
using value_type = void;
explicit constexpr ok() = default;
};
template < typename ErrorType >
class failure
{
class failure {
public:
using value_type = ErrorType;
@ -59,8 +56,7 @@ private:
};
template < typename ValueType, typename ErrorType >
class result
{
class result {
public:
using value_type = ValueType;
using error_type = ErrorType;

1
source/orm/CMakeLists.txt
View File

@ -73,6 +73,7 @@ add_library(matador-orm STATIC
../../include/matador/query/query_builder.hpp
../../include/matador/query/query_collection_resolver.hpp
../../include/matador/query/query_column.hpp
../../include/matador/query/query_contexts.hpp
../../include/matador/query/query_data.hpp
../../include/matador/query/query_intermediates.hpp
../../include/matador/query/query_object_resolver.hpp

36
source/orm/orm/session.cpp
View File

@ -4,6 +4,7 @@
#include "matador/sql/dialect.hpp"
#include "matador/query/query.hpp"
#include "matador/query/generator.hpp"
#include <stdexcept>
@ -18,6 +19,41 @@ session::session(session_context&& ctx, const query::schema &scm)
, dialect_(sql::backend_provider::instance().connection_dialect(pool_.info().type))
, schema_(scm)
, resolver_service_(ctx.resolver_service) {
using namespace matador::utils;
for (const auto &[type, node] : schema_) {
query::query_contexts queries;
// SELECT all
queries.select_all = query::select(node.table())
.from(node.name())
.compile(dialect_);
if (node.table().has_primary_key()) {
// SELECT one
queries.select_one = query::select(node.table())
.from(node.name())
.where(*node.table().primary_key_column().value() == _)
.compile(dialect_);
// UPDATE one
auto update_set = query::update(node.table());
for (const auto &col: node.table().columns()) {
update_set.set(col, _);
}
queries.update_one = update_set.where(*node.table().primary_key_column().value() == _)
.compile(dialect_);
// DELETE one
queries.delete_one = query::remove()
.from(node.name())
.where(*node.table().primary_key_column().value() == _)
.compile(dialect_);
}
// INSERT one
queries.insert = query::insert()
.into(node.name(), node.table())
.values(query::generator::placeholders(node.table().columns().size()))
.compile(dialect_);
contexts_by_type_[node.node().type_index()] = queries;
}
}
utils::result<void, utils::error> session::drop_table(const std::string &table_name) const {

9
source/orm/query/generator.cpp
View File

@ -31,4 +31,13 @@ column_value_generator::column_value_generator(column_value_generator_options op
void column_value_generator::on_revision(const char* id, uint64_t& x) {
push_back(id, x);
}
std::vector<utils::placeholder> placeholders(const size_t num) {
std::vector<utils::placeholder> result;
for (size_t i = 0; i < num; ++i) {
result.emplace_back(utils::_);
}
return result;
}
}

19
source/orm/query/insert_query_builder.cpp
View File

@ -1,8 +1,23 @@
#include "matador/query/insert_query_builder.hpp"
#include "matador/sql/statement_cache.hpp"
namespace matador::query {
insert_query_builder::insert_query_builder(const basic_schema& schema)
: schema_(schema) {}
insert_query_builder::insert_query_builder(const basic_schema& schema, const std::unordered_map<std::type_index, query_contexts> &contexts_by_type)
: schema_(schema)
, contexts_by_type_{contexts_by_type}
{}
utils::result<sql::statement, utils::error> insert_query_builder::insert_step::acquire_and_bind(sql::statement_cache &cache) const {
auto result = cache.acquire(ctx);
if (!result.is_ok()) {
return utils::failure(result.err());
}
bind_object(*result);
return utils::ok(std::move(*result));
}
void insert_query_builder::on_revision(const char* /*id*/, uint64_t&) {}
} // namespace matador::query

4
source/orm/query/intermediates/executable_query.cpp
View File

@ -17,9 +17,9 @@ utils::result<sql::statement, utils::error> executable_query::prepare(sql::execu
return exec.prepare(compiler.build(*context_, exec.dialect(), std::nullopt));
}
sql::query_context executable_query::compile( const sql::executor& exec ) const {
sql::query_context executable_query::compile(const sql::dialect& d) const {
query_builder compiler;
return compiler.build(*context_, exec.dialect(), std::nullopt);
return compiler.build(*context_, d, std::nullopt);
}
std::string executable_query::str(const sql::executor &exec) const {

24
source/orm/query/schema.cpp
View File

@ -16,7 +16,7 @@ namespace matador::query {
utils::result<void, utils::error> schema::create(const sql::connection &conn) const {
std::vector<std::string> fk_sql_commands;
const auto q = query::create().schema(repo_.name()).compile(conn);
const auto q = query::create().schema(repo_.name()).compile(conn.dialect());
std::cout << q.sql << std::endl;
// create plain tables without constraints
@ -24,7 +24,7 @@ utils::result<void, utils::error> schema::create(const sql::connection &conn) co
auto ctx = query::create()
.table(node.name())
.columns(node.info().attributes())
.compile(conn);
.compile(conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
@ -37,7 +37,7 @@ utils::result<void, utils::error> schema::create(const sql::connection &conn) co
if (!cons.is_primary_key_constraint()) {
continue;
}
auto ctx = build_add_constraint_context(node, cons, conn);
auto ctx = build_add_constraint_context(node, cons, conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
@ -50,7 +50,7 @@ utils::result<void, utils::error> schema::create(const sql::connection &conn) co
if (cons.is_primary_key_constraint()) {
continue;
}
auto ctx = build_add_constraint_context(node, cons, conn);
auto ctx = build_add_constraint_context(node, cons, conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
@ -70,7 +70,7 @@ utils::result<void, utils::error> schema::drop(const sql::connection &conn) cons
auto ctx = alter()
.table(node.name())
.drop_constraint(cons)
.compile(conn);
.compile(conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
@ -87,7 +87,7 @@ utils::result<void, utils::error> schema::drop(const sql::connection &conn) cons
auto ctx = alter()
.table(node.name())
.drop_constraint(cons)
.compile(conn);
.compile(conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
@ -99,7 +99,7 @@ utils::result<void, utils::error> schema::drop(const sql::connection &conn) cons
for (const auto &node: repo_) {
auto ctx = query::drop()
.table(node.name())
.compile(conn);
.compile(conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
@ -135,29 +135,29 @@ void schema::dump(std::ostream &os) const {
sql::query_context schema::build_add_constraint_context(const object::repository_node &node,
const object::restriction &cons,
const sql::connection &conn) {
const sql::dialect &d) {
if (cons.is_foreign_key_constraint()) {
return alter()
.table(node.name())
.add_constraint(cons)
.compile(conn);
.compile(d);
}
if (cons.is_primary_key_constraint()) {
return alter()
.table(node.name())
.add_constraint(cons)
.compile(conn);
.compile(d);
}
return {};
}
sql::query_context schema::build_drop_constraint_context(const object::repository_node &node,
const object::restriction &cons,
const sql::connection &conn) {
const sql::dialect &d) {
return alter()
.table(node.name())
.drop_constraint(cons)
.compile(conn);
.compile(d);
}
schema::iterator schema::insert_table(const std::type_index &ti, const object::repository_node &node, const utils::generator_type /*generator_type*/) {

21
source/orm/query/table.cpp
View File

@ -21,6 +21,9 @@ table::table(std::string name, std::string alias, const std::vector<table_column
, columns_(columns) {
for (auto &col : columns_) {
col.table(this);
if (col.is_primary_key()) {
pk_column_ = &col;
}
}
}
@ -102,11 +105,15 @@ std::string table::schema_name() const {
}
bool table::is_relation_table() const {
return false;
return !has_primary_key();
}
bool table::has_primary_key() const {
return false;
return pk_column_.has_value();
}
std::optional<table_column *> table::primary_key_column() const {
return pk_column_;
}
const std::string &table::join_column_name() const {
@ -117,9 +124,9 @@ const std::string &table::inverse_join_column_name() const {
return inverse_join_column_name_;
}
const table_column& table::create_column(class table &tab, const std::string &name) {
tab.columns_.emplace_back(name);
tab.columns_.back().table(&tab);
return tab.columns_.back();
}
// const table_column& table::create_column(class table &tab, const std::string &name) {
// tab.columns_.emplace_back(name);
// tab.columns_.back().table(&tab);
// return tab.columns_.back();
// }
}

16
source/orm/query/table_column.cpp
View File

@ -138,6 +138,22 @@ bool table_column::is_nullable() const {
return !utils::is_constraint_set(attributes_.options(), utils::constraints::NotNull);
}
bool table_column::is_primary_key() const {
return !utils::is_constraint_set(attributes_.options(), utils::constraints::PrimaryKey);
}
bool table_column::is_foreign_key() const {
return !utils::is_constraint_set(attributes_.options(), utils::constraints::ForeignKey);
}
bool table_column::is_unique() const {
return !utils::is_constraint_set(attributes_.options(), utils::constraints::Unique);
}
bool table_column::is_identity() const {
return !utils::is_constraint_set(attributes_.options(), utils::constraints::Identity);
}
sql::sql_function_t table_column::function() const {
return function_;
}

7
test/backends/SessionFixture.cpp
View File

@ -7,8 +7,7 @@
namespace matador::test {
SessionFixture::SessionFixture()
: ses({bus, connection::dns, 4}, schema)
, db(connection::dns) {
: db(connection::dns) {
REQUIRE(db.open());
}
@ -19,8 +18,8 @@ SessionFixture::~SessionFixture() {
}
void SessionFixture::drop_table_if_exists(const std::string &table_name) const {
if (ses.table_exists(table_name)) {
REQUIRE(ses.drop_table(table_name));
if (db.exists(table_name)) {
REQUIRE(query::drop().table(table_name).execute(db));
}
}

3
test/backends/SessionFixture.hpp
View File

@ -5,8 +5,6 @@
#include "matador/utils/message_bus.hpp"
#include <stack>
namespace matador::test {
class SessionFixture {
@ -15,7 +13,6 @@ public:
~SessionFixture();
protected:
orm::session ses;
utils::message_bus bus;
sql::connection db;

3
test/backends/SessionInsertHasMany.cpp
View File

@ -2,6 +2,8 @@
#include "SessionFixture.hpp"
#include "connection.hpp"
#include "models/author.hpp"
#include "models/book.hpp"
@ -15,6 +17,7 @@ TEST_CASE_METHOD(SessionFixture, "Test insert object with has many relation", "[
.and_then([this] { return schema.create(db); } );
REQUIRE(result.is_ok());
orm::session ses({bus, connection::dns, 4}, schema);
schema.initialize(ses);
auto s_king = make_object<author>(1, "Steven", "King", "21.9.1947", 1956, false);

17
test/backends/SessionTest.cpp
View File

@ -2,6 +2,8 @@
#include "SessionFixture.hpp"
#include "connection.hpp"
#include "models/airplane.hpp"
#include "models/author.hpp"
#include "models/book.hpp"
@ -20,6 +22,7 @@ TEST_CASE_METHOD(SessionFixture, "Session insert test", "[session][insert]") {
.and_then([this] { return schema.create(db); } );
REQUIRE(result.is_ok());
orm::session ses({bus, connection::dns, 4}, schema);
auto plane = ses.insert(make_object<airplane>(1, "Boeing", "A380"));
REQUIRE(plane.is_ok());
@ -36,6 +39,7 @@ TEST_CASE_METHOD(SessionFixture, "Session update test", "[session][update]") {
.and_then([this] { return schema.create(db); } );
REQUIRE(res.is_ok());
orm::session ses({bus, connection::dns, 4}, schema);
auto result = ses.insert(make_object<airplane>(1, "Boeing", "A380"));
REQUIRE(result.is_ok());
@ -66,6 +70,8 @@ TEST_CASE_METHOD(SessionFixture, "Session delete test", "[session][delete]") {
.and_then([this] { return schema.create(db); } );
REQUIRE(res.is_ok());
orm::session ses({bus, connection::dns, 4}, schema);
schema.initialize(ses);
auto result = ses.insert(make_object<airplane>(1, "Boeing", "A380"));
@ -90,6 +96,7 @@ TEST_CASE_METHOD(SessionFixture, "Session relation test", "[session][relation]")
.and_then([this] { return schema.create(db); } );
REQUIRE(result.is_ok());
orm::session ses({bus, connection::dns, 4}, schema);
auto plane = ses.insert(make_object<airplane>(1, "Boeing", "A380"));
REQUIRE(plane.is_ok());
auto f = ses.insert(make_object<flight>(2, *plane, "sully"));
@ -111,6 +118,7 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find object with id", "[session
.and_then([this] { return schema.create(db); } );
REQUIRE(result.is_ok());
orm::session ses({bus, connection::dns, 4}, schema);
auto a380 = ses.insert(make_object<airplane>(1, "Boeing", "A380"));
REQUIRE(a380.is_ok());
@ -130,6 +138,8 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects", "[session][f
.and_then([this] { return schema.create(db); } );
REQUIRE(result.is_ok());
orm::session ses({bus, connection::dns, 4}, schema);
std::vector planes {
make_object<airplane>(1, "Airbus", "A380"),
make_object<airplane>(2, "Boeing", "707"),
@ -165,6 +175,7 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with one-to-ma
.and_then([this] { return schema.create(db); } );
REQUIRE(result.is_ok());
orm::session ses({bus, connection::dns, 4}, schema);
schema.initialize(ses);
std::vector authors {
make_object<author>(1, "Michael", "Crichton", "23.10.1942", 1975, true),
@ -219,6 +230,8 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with one-to-ma
.and_then([this] { return schema.create(db); } );
REQUIRE(result.is_ok());
orm::session ses({bus, connection::dns, 4}, schema);
std::vector departments {
make_object<department>(1, "Insurance"),
make_object<department>(2, "Invoice")
@ -276,6 +289,8 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with many-to-m
return schema.create(db);
} );
orm::session ses({bus, connection::dns, 4}, schema);
std::vector ingredients {
make_object<ingredient>(1, "Apple"),
make_object<ingredient>(2, "Strawberry"),
@ -310,6 +325,8 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with many-to-m
return schema.create(db);
} );
orm::session ses({bus, connection::dns, 4}, schema);
std::vector ingredients {
make_object<ingredient>(1, "Apple"),
make_object<ingredient>(2, "Strawberry"),

30
test/orm/query/InsertQueryBuilderTest.cpp
View File

@ -58,19 +58,19 @@ TEST_CASE("Test insert builder has many", "[query][insert_query_builder][has_man
.and_then( [&scm] { return scm.attach<author>("authors"); } );
REQUIRE(result.is_ok());
auto s_king = make_object<author>(1, "Steven", "King", "21.9.1947", 1956, false);
s_king->books.push_back(make_object<book>(2, "Carrie", object_ptr<author>{}, 1974));
s_king->books.push_back(make_object<book>(3, "The Shining", object_ptr<author>{}, 1977));
s_king->books.push_back(make_object<book>(4, "It", object_ptr<author>{}, 1986));
s_king->books.push_back(make_object<book>(5, "Misery", object_ptr<author>{}, 1987));
s_king->books.push_back(make_object<book>(6, "The Dark Tower: The Gunslinger", object_ptr<author>{}, 1982));
insert_query_builder iqb(scm);
auto build_result = iqb.build(s_king);
REQUIRE(build_result.is_ok());
const auto& stmts = *build_result;
REQUIRE(stmts.size() == 1);
// auto s_king = make_object<author>(1, "Steven", "King", "21.9.1947", 1956, false);
//
// s_king->books.push_back(make_object<book>(2, "Carrie", object_ptr<author>{}, 1974));
// s_king->books.push_back(make_object<book>(3, "The Shining", object_ptr<author>{}, 1977));
// s_king->books.push_back(make_object<book>(4, "It", object_ptr<author>{}, 1986));
// s_king->books.push_back(make_object<book>(5, "Misery", object_ptr<author>{}, 1987));
// s_king->books.push_back(make_object<book>(6, "The Dark Tower: The Gunslinger", object_ptr<author>{}, 1982));
//
// insert_query_builder iqb(scm);
//
// auto build_result = iqb.build(s_king);
// REQUIRE(build_result.is_ok());
//
// const auto& stmts = *build_result;
// REQUIRE(stmts.size() == 1);
}

2
test/orm/query/QueryBuilderTest.cpp
View File

@ -73,7 +73,7 @@ TEST_CASE_METHOD(QueryFixture, "Test create table sql statement string", "[query
constraint("PK_person").primary_key({"id"}),
constraint("FK_person_address").foreign_key({"address"}).references("address", {"id"})
})
.compile(*db);
.compile(db->dialect());
REQUIRE(ctx.sql == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255) NOT NULL UNIQUE, "age" INTEGER NOT NULL, "address" BIGINT NOT NULL, CONSTRAINT PK_person PRIMARY KEY (id), CONSTRAINT FK_person_address FOREIGN KEY (address) REFERENCES address (id)))##");
}

15
test/orm/sql/StatementCacheTest.cpp
View File

@ -134,6 +134,7 @@ TEST_CASE("Test statement cache", "[statement][cache]") {
const auto stmt = result.value();
ctx.sql = "SELECT title FROM book";
ctx.sql_hash = std::hash<std::string>{}(ctx.sql);
result = cache.acquire(ctx);
REQUIRE(result);
@ -143,6 +144,7 @@ TEST_CASE("Test statement cache", "[statement][cache]") {
REQUIRE(cache.capacity() == 2);
ctx.sql = "SELECT name FROM author";
ctx.sql_hash = std::hash<std::string>{}(ctx.sql);
result = cache.acquire(ctx);
REQUIRE(result);
@ -163,18 +165,19 @@ TEST_CASE("Test LRU cache evicts oldest entries", "[statement][cache][evict]") {
REQUIRE(cache.capacity() == 2);
REQUIRE(cache.empty());
auto result = cache.acquire({"SELECT * FROM person"});
auto result = cache.acquire({"SELECT * FROM person", std::hash<std::string>{}("SELECT * FROM person")});
REQUIRE(result);
auto stmt1 = result.value();
result = cache.acquire({"SELECT title FROM book"});
result = cache.acquire({"SELECT title FROM book", std::hash<std::string>{}("SELECT title FROM book")});
REQUIRE(result);
auto stmt2 = result.value();
result = cache.acquire({"SELECT name FROM author"}); // Should evict the first statement
result = cache.acquire({"SELECT name FROM author", std::hash<std::string>{}("SELECT name FROM author")}); // Should evict the first statement
REQUIRE(result);
auto stmt3 = result.value();
// Trigger re-prepares of an evicted statement
result = cache.acquire({"SELECT 1"});
result = cache.acquire({"SELECT 1", std::hash<std::string>{}("SELECT 1")});
REQUIRE(result);
auto stmt4 = result.value();
@ -211,10 +214,10 @@ TEST_CASE("Test statement reuse avoids reprepare", "[statement][cache][prepare]"
REQUIRE(cache.capacity() == 2);
REQUIRE(cache.empty());
auto result = cache.acquire({"SELECT * FROM person"});
auto result = cache.acquire({"SELECT * FROM person", std::hash<std::string>{}("SELECT * FROM person")});
REQUIRE(result);
auto stmt1 = result.value();
result = cache.acquire({"SELECT * FROM person"});
result = cache.acquire({"SELECT * FROM person", std::hash<std::string>{}("SELECT * FROM person")});
REQUIRE(result);
auto stmt2 = result.value();
}