124 lines
3.9 KiB
C++
124 lines
3.9 KiB
C++
#include "matador/orm/session.hpp"
|
|
|
|
#include "matador/sql/backend_provider.hpp"
|
|
#include "matador/sql/dialect.hpp"
|
|
|
|
#include "matador/query/query.hpp"
|
|
|
|
#include <stdexcept>
|
|
|
|
namespace matador::orm {
|
|
utils::error make_error(const error_code ec, const std::string &msg) {
|
|
return utils::error(ec, msg);
|
|
}
|
|
|
|
session::session(session_context&& ctx, const query::schema &scm)
|
|
: cache_(ctx.bus, ctx.pool, ctx.cache_size)
|
|
, dialect_(sql::backend_provider::instance().connection_dialect(ctx.pool.info().type))
|
|
, schema_(scm) {
|
|
}
|
|
|
|
utils::result<void, utils::error> session::drop_table(const std::string &table_name) const {
|
|
auto result = query::query::drop()
|
|
.table(table_name)
|
|
.execute(*this);
|
|
if (result.is_error()) {
|
|
return utils::failure(result.err());
|
|
}
|
|
|
|
return utils::ok<void>();
|
|
}
|
|
|
|
utils::result<sql::query_result<sql::record>, utils::error> session::fetch_all(const sql::query_context &q) const {
|
|
auto c = cache_.pool().acquire();
|
|
if (!c.valid()) {
|
|
return utils::failure(make_error(error_code::NoConnectionAvailable, "Failed to acquire connection."));
|
|
}
|
|
auto it = prototypes_.find(q.table_name);
|
|
if (it == prototypes_.end()) {
|
|
auto result = c->describe(q.table_name);
|
|
if (!result) {
|
|
return utils::failure(result.err());
|
|
}
|
|
it = prototypes_.emplace(q.table_name, *result).first;
|
|
}
|
|
// adjust columns from given query
|
|
for (auto &col: q.prototype) {
|
|
if (const auto rit = std::find_if(it->second.begin(), it->second.end(), [&col](const auto &value) {
|
|
return value.name() == col.name();
|
|
}); rit != it->second.end()) {
|
|
const_cast<object::attribute &>(col).change_type(rit->type());
|
|
}
|
|
}
|
|
auto res = fetch(q);
|
|
if (!res) {
|
|
return utils::failure(res.err());
|
|
}
|
|
const auto prototype = res.value()->prototype();
|
|
return utils::ok(sql::query_result<sql::record>{std::move(*res), [prototype] {
|
|
return sql::detail::create_prototype<sql::record>(prototype);
|
|
}});
|
|
}
|
|
|
|
utils::result<size_t, utils::error> session::execute(const std::string &sql) const {
|
|
return execute(sql::query_context{sql});
|
|
}
|
|
|
|
std::vector<object::attribute> session::describe_table(const std::string &table_name) const {
|
|
const auto c = cache_.pool().acquire();
|
|
if (!c.valid()) {
|
|
throw std::logic_error("no database connection available");
|
|
}
|
|
return c->describe(table_name).release();
|
|
}
|
|
|
|
bool session::table_exists(const std::string &table_name) const {
|
|
const auto c = cache_.pool().acquire();
|
|
if (!c.valid()) {
|
|
throw std::logic_error("no database connection available");
|
|
}
|
|
return c->exists(dialect_.default_schema_name(), table_name);
|
|
}
|
|
|
|
const class sql::dialect &session::dialect() const {
|
|
return dialect_;
|
|
}
|
|
|
|
utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> session::fetch(const sql::query_context& ctx) const {
|
|
if (const auto result = cache_.acquire(ctx); !result) {
|
|
return utils::failure(result.err());
|
|
} else if (auto fetch_result = result->fetch_internal(); !fetch_result) {
|
|
return utils::failure(fetch_result.err());
|
|
} else {
|
|
return fetch_result;
|
|
}
|
|
}
|
|
|
|
utils::result<size_t, utils::error> session::execute(const sql::query_context& ctx) const {
|
|
if (const auto result = cache_.acquire(ctx); !result) {
|
|
return utils::failure(result.err());
|
|
} else if (auto exec_result = result->execute(); !exec_result) {
|
|
return utils::failure(exec_result.err());
|
|
} else {
|
|
return exec_result;
|
|
}
|
|
}
|
|
|
|
utils::result<sql::statement, utils::error> session::prepare(const sql::query_context& ctx) {
|
|
return cache_.acquire(ctx);
|
|
}
|
|
|
|
std::string session::str(const sql::query_context& ctx) const {
|
|
return ctx.sql;
|
|
}
|
|
|
|
query::fetchable_query session::build_select_query(entity_query_data &&data) {
|
|
return query::query::select(data.columns)
|
|
.from(*data.root_table)
|
|
.join_left(data.joins)
|
|
.where(std::move(data.where_clause))
|
|
.order_by({data.root_table, data.pk_column_name})
|
|
.asc();
|
|
}
|
|
}
|