added session context and implemented the executor interface for session

source/orm/orm/error_code.cpp

@@ -18,6 +18,8 @@ std::string orm_category_impl::message(const int ev) const {
       return "Failed to build query";
     case error_code::FailedToFindObject:
       return "Failed to find object";
+    case error_code::Failed:
+      return "Failed";
     default:
       return "Unknown error";
   }

source/orm/orm/session.cpp

@@ -12,9 +12,9 @@ utils::error make_error(const error_code ec, const std::string &msg) {
   return utils::error(ec, msg);
 }
 
-session::session(sql::connection_pool &pool)
-: pool_(pool)
-, dialect_(sql::backend_provider::instance().connection_dialect(pool_.info().type))
+session::session(session_context&& ctx)
+: cache_(ctx.bus, ctx.pool, ctx.cache_size)
+, dialect_(sql::backend_provider::instance().connection_dialect(ctx.pool.info().type))
 , schema_(std::make_unique<object::schema>(dialect_.default_schema_name())) {
 }
 
@@ -49,7 +49,7 @@ utils::result<void, utils::error> session::create_schema() const {
     }
 
   std::vector<std::string> fk_sql_commands;
-  auto c = pool_.acquire();
+  auto c = cache_.pool().acquire();
   for (const auto &node: *schema_) {
     auto ctx = query::query::create()
       .table(node->name(), node->info().definition().columns())
@@ -75,14 +75,9 @@ utils::result<void, utils::error> session::create_schema() const {
 }
 
 utils::result<void, utils::error> session::drop_table(const std::string &table_name) const {
-  auto c = pool_.acquire();
-  if (!c.valid()) {
-    throw std::logic_error("no database connection available");
-  }
-
   auto result = query::query::drop()
       .table(table_name)
-      .execute(*c);
+      .execute(*this);
   if (result.is_error()) {
     return utils::failure(result.err());
   }
@@ -90,10 +85,10 @@ utils::result<void, utils::error> session::drop_table(const std::string &table_n
   return utils::ok<void>();
 }
 
-utils::result<sql::query_result<sql::record>, utils::error> session::fetch(const sql::query_context &q) const {
-  auto c = pool_.acquire();
+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()) {
-    throw std::logic_error("no database connection available");
+    return utils::failure(make_error(error_code::NoConnectionAvailable, "Failed to acquire connection."));
   }
   auto it = prototypes_.find(q.table.name);
   if (it == prototypes_.end()) {
@@ -109,28 +104,19 @@ utils::result<sql::query_result<sql::record>, utils::error> session::fetch(const
       const_cast<object::attribute_definition &>(col).type(rit->type());
     }
   }
-  auto res = c->fetch(q);
+  auto res = fetch(q);
+  if (!res) {
+    return utils::failure(res.err());
+  }
   return utils::ok(sql::query_result<sql::record>{std::move(*res)});
 }
 
-size_t session::execute(const std::string &sql) const {
-  auto c = pool_.acquire();
-  if (!c.valid()) {
-    throw std::logic_error("no database connection available");
-  }
-  return c->execute(sql);
-}
-
-sql::statement session::prepare(const sql::query_context &q) const {
-  auto c = pool_.acquire();
-  if (!c.valid()) {
-    throw std::logic_error("no database connection available");
-  }
-  return c->prepare(q).release();
+utils::result<size_t, utils::error> session::execute(const std::string &sql) const {
+  return execute(sql::query_context{sql});
 }
 
 std::vector<object::attribute_definition> session::describe_table(const std::string &table_name) const {
-  auto c = pool_.acquire();
+  const auto c = cache_.pool().acquire();
   if (!c.valid()) {
     throw std::logic_error("no database connection available");
   }
@@ -138,7 +124,7 @@ std::vector<object::attribute_definition> session::describe_table(const std::str
 }
 
 bool session::table_exists(const std::string &table_name) const {
-  auto c = pool_.acquire();
+  const auto c = cache_.pool().acquire();
   if (!c.valid()) {
     throw std::logic_error("no database connection available");
   }
@@ -153,6 +139,34 @@ void session::dump_schema(std::ostream &os) const {
   schema_->dump(os);
 }
 
+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)