query/source/orm/orm/session.cpp

#include "matador/orm/session.hpp"

#include "matador/sql/backend_provider.hpp"
#include "matador/sql/dialect.hpp"

#include "matador/query/query.hpp"
#include "matador/query/generator.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)
: pool_(ctx.dns, ctx.connection_count, [ctx](const sql::connection_info& info) { return sql::connection(info, ctx.resolver_service); })
, cache_(ctx.bus, pool_, ctx.cache_size)
, 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 {
  auto result = 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});
}

utils::result<sql::execute_result, 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_;
}

std::shared_ptr<sql::resolver_service> session::resolver() const {
  return resolver_service_;
}

const query::basic_schema & session::schema() const {
  return schema_;
}

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<sql::execute_result, 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;
}
}