removed obsolete interface namespace

backends/postgres/include/postgres_parameter_binder.h

@@ -7,7 +7,7 @@
 
 namespace matador::backends::postgres {
 
-class postgres_parameter_binder final : public sql::interface::parameter_binder {
+class postgres_parameter_binder final : public sql::parameter_binder {
 public:
   struct bind_data {
     explicit bind_data(size_t size);

backends/postgres/include/postgres_statement.hpp

@@ -13,8 +13,8 @@ class postgres_statement final : public sql::statement_impl
 public:
   postgres_statement(PGconn *db, std::string name, const sql::query_context &query);
 
-  utils::result<size_t, utils::error> execute(const sql::interface::parameter_binder& bindings) override;
+  utils::result<size_t, utils::error> execute(const sql::parameter_binder& bindings) override;
-  utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> fetch(const sql::interface::parameter_binder& bindings) override;
+  utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> fetch(const sql::parameter_binder& bindings) override;
   void reset() override;
 
 protected:

backends/postgres/src/postgres_statement.cpp

@@ -11,7 +11,7 @@ postgres_statement::postgres_statement(PGconn *db, std::string name, const sql::
 , name_(std::move(name))
 {}
 
-utils::result<size_t, utils::error> postgres_statement::execute(const sql::interface::parameter_binder& bindings) {
+utils::result<size_t, utils::error> postgres_statement::execute(const sql::parameter_binder& bindings) {
   const auto* postgres_bindings = dynamic_cast<const postgres_parameter_binder*>(&bindings);
   if (!postgres_bindings) {
     return utils::failure(utils::error(sql::error_code::EXECUTE_FAILED, "Failed to cast bindings to postgres bindings"));
@@ -33,10 +33,10 @@ utils::result<size_t, utils::error> postgres_statement::execute(const sql::inter
     return utils::ok(static_cast<size_t>(0));
   }
 
-  return utils::ok((std::stoul(tuples)));
+  return utils::ok(static_cast<size_t>(std::stoul(tuples)));
 }
 
-utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> postgres_statement::fetch(const sql::interface::parameter_binder& bindings) {
+utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> postgres_statement::fetch(const sql::parameter_binder& bindings) {
   const auto* postgres_bindings = dynamic_cast<const postgres_parameter_binder*>(&bindings);
   if (!postgres_bindings) {
     return utils::failure(utils::error(sql::error_code::EXECUTE_FAILED, "Failed to cast bindings to postgres bindings"));

include/matador/orm/error_code.hpp

@@ -11,7 +11,8 @@ enum class error_code : uint8_t {
   NoConnectionAvailable,
   UnknownType,
   FailedToBuildQuery,
-  FailedToFindObject
+  FailedToFindObject,
+  Failed
 };
 
 class orm_category_impl final : public std::error_category

include/matador/orm/session.hpp

@@ -9,7 +9,9 @@
 #include "matador/sql/column_generator.hpp"
 #include "matador/sql/connection.hpp"
 #include "matador/sql/connection_pool.hpp"
+#include "matador/sql/executor.hpp"
 #include "matador/sql/statement.hpp"
+#include "matador/sql/statement_cache.hpp"
 
 #include "matador/object/object_ptr.hpp"
 #include "matador/object/object_definition.hpp"
@@ -21,9 +23,15 @@ namespace matador::orm {
 
 utils::error make_error(error_code ec, const std::string &msg);
 
-class session final {
+struct session_context {
+  utils::message_bus &bus;
+  sql::connection_pool &pool;
+  size_t cache_size{500};
+};
+
+class session final : public sql::executor {
 public:
-  explicit session(sql::connection_pool &pool);
+  explicit session(session_context &&ctx);
 
   template<typename Type>
   [[nodiscard]] utils::result<void, utils::error> attach(const std::string &table_name) const;
@@ -42,10 +50,10 @@ public:
 
   template<typename Type, typename PrimaryKeyType>
   utils::result<object::object_ptr<Type>, utils::error> find(const PrimaryKeyType &pk) {
-    auto c = pool_.acquire();
+    // auto c = pool_.acquire();
-    if (!c.valid()) {
+    // if (!c.valid()) {
-      return utils::failure(make_error(error_code::NoConnectionAvailable, "Failed to acquire connection."));
+      // return utils::failure(make_error(error_code::NoConnectionAvailable, "Failed to acquire connection."));
-    }
+    // }
     auto info = schema_->info<Type>();
     if (!info) {
       return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
@@ -57,7 +65,7 @@ public:
       return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + info->get().name() + "."));
     }
 
-    auto obj = build_select_query(data.release()).template fetch_one<Type>(*c);
+    auto obj = build_select_query(data.release()).template fetch_one<Type>(*this);
 
     if (!obj) {
       return utils::failure(obj.err());
@@ -70,10 +78,10 @@ public:
 
   template<typename Type>
   utils::result<sql::query_result<Type>, utils::error> find() {
-    const auto c = pool_.acquire();
+    // const auto c = pool_.acquire();
-    if (!c.valid()) {
+    // if (!c.valid()) {
-      return utils::failure(make_error(error_code::NoConnectionAvailable, "Failed to acquire connection."));
+      // return utils::failure(make_error(error_code::NoConnectionAvailable, "Failed to acquire connection."));
-    }
+    // }
     auto info = schema_->info<Type>();
     if (!info) {
       return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
@@ -85,51 +93,54 @@ public:
       return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + info->get().name() + "."));
     }
 
-    return build_select_query(data.release()).template fetch_all<Type>(*c);
+    return build_select_query(data.release()).template fetch_all<Type>(*this);
-  }
-
-  template<typename Type>
-  utils::result<query::query_from_intermediate, utils::error> select() {
-    auto c = pool_.acquire();
-    if (!c.valid()) {
-      return utils::failure(make_error(error_code::NoConnectionAvailable, "Failed to acquire connection."));
-    }
-    auto info = schema_->info<Type>();
-    if (!info) {
-      return utils::failure(make_error(error_code::UnknownType,  "Failed to determine requested type."));
-    }
-
-    session_query_builder eqb(*schema_);
-    auto data = eqb.build<Type>();
-    if (!data.is_ok()) {
-      return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + info->get().name() + "."));
-    }
-
-    return utils::ok(build_select_query(data.release()).template fetch_all<Type>(*c));
   }
 
+  // template<typename Type>
+  // utils::result<query::query_from_intermediate, utils::error> select() {
+  //   auto c = pool_.acquire();
+  //   if (!c.valid()) {
+  //     return utils::failure(make_error(error_code::NoConnectionAvailable, "Failed to acquire connection."));
+  //   }
+  //   auto info = schema_->info<Type>();
+  //   if (!info) {
+  //     return utils::failure(make_error(error_code::UnknownType,  "Failed to determine requested type."));
+  //   }
+  //
+  //   session_query_builder eqb(*schema_);
+  //   auto data = eqb.build<Type>();
+  //   if (!data.is_ok()) {
+  //     return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + info->get().name() + "."));
+  //   }
+  //
+  //   return utils::ok(build_select_query(data.release()).template fetch_all<Type>(*c));
+  // }
+  //
   template<typename Type>
   utils::result<void, utils::error> drop_table();
   utils::result<void, utils::error> drop_table(const std::string &table_name) const;
 
-  [[nodiscard]] utils::result<sql::query_result<sql::record>, utils::error> fetch(const sql::query_context &q) const;
+  [[nodiscard]] utils::result<sql::query_result<sql::record>, utils::error> fetch_all(const sql::query_context &q) const;
-  [[nodiscard]] size_t execute(const std::string &sql) const;
+  [[nodiscard]] utils::result<size_t, utils::error> execute(const std::string &sql) const;
-  [[nodiscard]] sql::statement prepare(const sql::query_context& q) const;
 
   [[nodiscard]] std::vector<object::attribute_definition> describe_table(const std::string &table_name) const;
   [[nodiscard]] bool table_exists(const std::string &table_name) const;
 
-  [[nodiscard]] const sql::dialect& dialect() const;
-
   void dump_schema(std::ostream &os) const;
 
+  [[nodiscard]] utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> fetch(const sql::query_context &ctx) const override;
+  [[nodiscard]] utils::result<size_t, utils::error> execute(const sql::query_context &ctx) const override;
+  [[nodiscard]] utils::result<sql::statement, utils::error> prepare(const sql::query_context &ctx) override;
+  [[nodiscard]] std::string str( const sql::query_context& ctx ) const override;
+  [[nodiscard]] const sql::dialect& dialect() const override;
+
 private:
   friend class query_select;
 
   static query::fetchable_query build_select_query(entity_query_data &&data);
 
 private:
-  sql::connection_pool &pool_;
+  mutable sql::statement_cache cache_;
   const sql::dialect &dialect_;
 
   std::unique_ptr<object::schema> schema_;
@@ -147,9 +158,8 @@ utils::result<void, utils::error> session::attach( const std::string& table_name
 }
 
 template<typename Type>
-utils::result<object::object_ptr<Type>, utils::error> session::insert(Type *obj)
+utils::result<object::object_ptr<Type>, utils::error> session::insert(Type *obj) {
-{
+  // auto c = pool_.acquire();
-  auto c = pool_.acquire();
   auto info = schema_->info<Type>();
   if (!info) {
     return utils::failure(info.err());
@@ -158,7 +168,7 @@ utils::result<object::object_ptr<Type>, utils::error> session::insert(Type *obj)
   auto res = query::query::insert()
     .into(info->get().name(), sql::column_generator::generate<Type>(*schema_, true))
     .values(*obj)
-    .execute(*c);
+    .execute(*this);
   if (!res) {
       return utils::failure(res.err());
   }

include/matador/query/intermediates/executable_query.hpp

@@ -8,7 +8,6 @@
 
 namespace matador::sql {
 class executor;
-class prepared_executor;
 class statement;
 struct query_context;
 }
@@ -20,7 +19,7 @@ public:
   using query_intermediate::query_intermediate;
 
   [[nodiscard]] utils::result<size_t, utils::error> execute(const sql::executor &exec) const;
-  [[nodiscard]] utils::result<sql::statement, utils::error> prepare(sql::prepared_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]] std::string str(const sql::executor &exec) const;
 };

include/matador/query/intermediates/fetchable_query.hpp

@@ -13,7 +13,6 @@
 
 namespace matador::sql {
 class executor;
-class prepared_executor;
 class statement;
 }
 
@@ -69,7 +68,7 @@ public:
     return utils::ok(std::optional<Type>{std::nullopt});
   }
 
-  [[nodiscard]] utils::result<sql::statement, utils::error> prepare(sql::prepared_executor &exec) const;
+  [[nodiscard]] utils::result<sql::statement, utils::error> prepare(sql::executor &exec) const;
 
   [[nodiscard]] std::string str(const sql::executor &exec) const;
 

include/matador/sql/connection.hpp

@@ -16,7 +16,7 @@ class connection_impl;
 /**
  * @brief The connection class represents a connection to a database.
  */
-class connection final : public executor, public prepared_executor {
+class connection final : public executor {
 public:
   using logger_ptr = std::shared_ptr<abstract_sql_logger>;
   /**

include/matador/sql/executor.hpp

@@ -12,22 +12,13 @@ struct query_context;
 class query_result_impl;
 class statement;
 
-class dialect_executor_mixin {
+class executor {
 public:
-  virtual ~dialect_executor_mixin() = default;
+  virtual ~executor() = default;
   [[nodiscard]] virtual const class dialect& dialect() const = 0;
-};
-
-class prepared_executor : public dialect_executor_mixin {
-public:
-  [[nodiscard]] virtual utils::result<statement, utils::error> prepare(const query_context &ctx) = 0;
-};
-
-class executor : public dialect_executor_mixin {
-public:
   [[nodiscard]] virtual utils::result<size_t, utils::error> execute(const query_context &ctx) const = 0;
   [[nodiscard]] virtual utils::result<std::unique_ptr<query_result_impl>, utils::error> fetch(const query_context &ctx) const = 0;
-
+  [[nodiscard]] virtual utils::result<statement, utils::error> prepare(const query_context &ctx) = 0;
   [[nodiscard]] virtual std::string str(const query_context &ctx) const = 0;
 };
 

include/matador/sql/statement.hpp

@@ -123,6 +123,8 @@ public:
 
   [[nodiscard]] std::string sql() const;
 
+  [[nodiscard]] utils::result<std::unique_ptr<query_result_impl>, utils::error> fetch_internal() const;
+
 private:
   template<class Type>
   friend class detail::identifier_binder;

include/matador/sql/statement_cache.hpp

@@ -68,6 +68,7 @@ public:
     return bus_.subscribe<EventType>(handler);
   }
 
+  connection_pool& pool() const;
 
 private:
   size_t max_size_{};

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)
+session::session(session_context&& ctx)
-: pool_(pool)
+: cache_(ctx.bus, ctx.pool, ctx.cache_size)
-, dialect_(sql::backend_provider::instance().connection_dialect(pool_.info().type))
+, 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 {
+utils::result<sql::query_result<sql::record>, utils::error> session::fetch_all(const sql::query_context &q) const {
-  auto c = pool_.acquire();
+  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 {
+utils::result<size_t, utils::error> session::execute(const std::string &sql) const {
-  auto c = pool_.acquire();
+  return execute(sql::query_context{sql});
-  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();
 }
 
 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)

source/orm/query/intermediates/executable_query.cpp

@@ -12,7 +12,7 @@ utils::result<size_t, utils::error> executable_query::execute(const sql::executo
   return exec.execute(compiler.compile(*context_, exec.dialect(), std::nullopt));
 }
 
-utils::result<sql::statement, utils::error> executable_query::prepare(sql::prepared_executor &exec) const {
+utils::result<sql::statement, utils::error> executable_query::prepare(sql::executor &exec) const {
   query_compiler compiler;
   context_->mode = query_mode::Prepared;
   return exec.prepare(compiler.compile(*context_, exec.dialect(), std::nullopt));

source/orm/query/intermediates/fetchable_query.cpp

@@ -43,7 +43,7 @@ utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> fetchable_q
   return exec.fetch(compiler.compile(*context_, exec.dialect(), std::nullopt));
 }
 
-utils::result<sql::statement, utils::error> fetchable_query::prepare(sql::prepared_executor &exec) const {
+utils::result<sql::statement, utils::error> fetchable_query::prepare(sql::executor &exec) const {
   query_compiler compiler;
   context_->mode = query_mode::Prepared;
   return exec.prepare(compiler.compile(*context_, exec.dialect(), std::nullopt));

source/orm/sql/statement.cpp

@@ -98,4 +98,14 @@ void statement::reset() const
 std::string statement::sql() const {
   return statement_proxy_->sql();
 }
+
+utils::result<std::unique_ptr<query_result_impl>, utils::error> statement::fetch_internal() const {
+  auto result = statement_proxy_->fetch(*bindings_);
+  if (!result.is_ok()) {
+    return utils::failure(result.err());
+  }
+
+  //  logger_.info(statement_->query_.sql);
+  return result;
+}
 }

source/orm/sql/statement_cache.cpp

@@ -205,4 +205,7 @@ bool statement_cache::empty() const {
   return cache_map_.empty();
 }
 
+connection_pool& statement_cache::pool() const {
+  return pool_;
+}
 }

test/backends/SessionFixture.cpp

@@ -5,7 +5,7 @@
 namespace matador::test {
 
 SessionFixture::SessionFixture()
-  : pool(connection::dns, 4), ses(pool) {}
+  : pool(connection::dns, 4), ses({bus, pool}) {}
 
 SessionFixture::~SessionFixture() {
   while (!tables_to_drop.empty()) {

test/backends/SessionFixture.hpp

@@ -3,6 +3,8 @@
 
 #include "matador/orm/session.hpp"
 
+#include "matador/utils/message_bus.hpp"
+
 #include "connection.hpp"
 
 #include <stack>
@@ -18,6 +20,7 @@ protected:
   sql::connection_pool pool;
   std::stack <std::string> tables_to_drop;
   orm::session ses;
+  utils::message_bus bus;
 
 private:
   void drop_table_if_exists(const std::string &table_name) const;

test/backends/SessionTest.cpp

@@ -234,7 +234,4 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with many-to-m
   recipes.push_back(std::make_unique<recipe>(7, "Apple Crumble"));
   recipes.push_back(std::make_unique<recipe>(8, "Beans Chili"));
   recipes.push_back(std::make_unique<recipe>(9, "Fruit Salad"));
-
-  
-
 }

test/backends/StatementCacheTest.cpp

@@ -15,13 +15,13 @@ class StatementCacheFixture
 {
 public:
   StatementCacheFixture()
-  : pool(test::connection::dns, 4), ses(pool)
+  : pool(test::connection::dns, 4)//, ses(pool)
   {}
   ~StatementCacheFixture() = default;
 
 protected:
   sql::connection_pool pool;
-  orm::session ses;
+  // orm::session ses;
 };
 
 TEST_CASE_METHOD(StatementCacheFixture, "Acquire prepared statement", "[statement cache]") {

test/orm/backend/test_statement.cpp

@@ -14,8 +14,7 @@ utils::result<size_t, utils::error> test_statement::execute(const sql::parameter
   using namespace std::chrono_literals;
   std::mt19937 rng(query_.sql.size());
   std::uniform_int_distribution dist(10, 50);
-  std::this_thread::sleep_for(std::chrono::milliseconds(50));
+  std::this_thread::sleep_for(std::chrono::milliseconds(dist(rng)));
-  // std::this_thread::sleep_for(std::chrono::milliseconds(dist(rng)));
   return utils::ok(static_cast<size_t>(8));
 }