insert_query_builder progress

include/matador/orm/session.hpp

@@ -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,7 +105,7 @@ 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."));
@@ -111,54 +113,63 @@ utils::result<object::object_ptr<Type>, utils::error> session::insert(object::ob
 
   // 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_is_unset && step.set_pk) {
-      if (step.pk_generator == utils::generator_type::Manual) {
+    //   if (step.pk_generator == utils::generator_type::Manual) {
-        if (step.pk_is_unset()) {
+    //     if (step.pk_is_unset()) {
-          return utils::failure(make_error(error_code::NoPrimaryKey, "Manual primary key is required but 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) {
+    //   } else if (step.pk_generator == utils::generator_type::Sequence) {
-        if (step.pk_is_unset()) {
+    //     if (step.pk_is_unset()) {
-          // hard-coded naming as you specified earlier
+    //       // hard-coded naming as you specified earlier
-          // <table_name>_seq (table name known in schema meta; if you prefer, store it in step too)
+    //       // <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.
+    //       // 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";
+    //       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 id_res = query::select().nextval(seq_name).fetch_value<std::uint64_t>(*this);
+    auto result = step.acquire_and_bind(cache_);
-          if (!id_res.is_ok() || !id_res.value().has_value()) {
+    if (!result.is_ok()) {
-            return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to obtain next sequence value."));
+      return utils::failure(result.err());
-          }
-          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."));
-        }
     }
+
+    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)) {
+    // if (std::holds_alternative<query::executable_query>(step.query)) {
-      const auto &q = std::get<query::executable_query>(step.query);
+    //   const auto &q = std::get<query::executable_query>(step.query);
-      const auto exec_res = q.execute(*this);
+    //   const auto exec_res = q.execute(*this);
-      if (!exec_res.is_ok()) {
+    //   if (!exec_res.is_ok()) {
-        return utils::failure(exec_res.err());
+    //     return utils::failure(exec_res.err());
-      }
+    //   }
-      continue;
+    //   continue;
-    }
+    // }
-
+    //
-    const auto &q = std::get<query::fetchable_query>(step.query);
+    // const auto &q = std::get<query::fetchable_query>(step.query);
-    auto rec_res = q.fetch_one(*this);
+    // auto rec_res = q.fetch_one(*this);
-    if (!rec_res.is_ok()) {
+    // if (!rec_res.is_ok()) {
-      return utils::failure(rec_res.err());
+    //   return utils::failure(rec_res.err());
-    }
+    // }
-    if (!rec_res.value().has_value()) {
+    // if (!rec_res.value().has_value()) {
-      return utils::failure(make_error(error_code::FailedToFindObject, "INSERT ... RETURNING did not return a row."));
+    //   return utils::failure(make_error(error_code::FailedToFindObject, "INSERT ... RETURNING did not return a row."));
-    }
+    // }
-    if (step.apply_returning) {
+    // if (step.apply_returning) {
-      step.apply_returning(*rec_res.value());
+    //   step.apply_returning(*rec_res.value());
-    }
+    // }
   }
 
   obj.change_state(object::object_state::Persistent);

include/matador/query/basic_schema.hpp

@@ -87,7 +87,7 @@ public:
 
   [[nodiscard]] bool contains(const std::type_index &index) const;
 
-  void initialize_executor(sql::executor &exec) const;
+  void initialize(sql::executor &exec) const;
 
 protected:
   template<typename Type>

include/matador/query/generator.hpp

@@ -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);

include/matador/query/insert_query_builder.hpp

@@ -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 >
+  template < class PrimaryKeyType >
-  static void on_primary_key(const char * /*id*/, V &, const utils::primary_key_attribute& /*attr*/) {}
+  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*/) {}
 
@@ -106,7 +151,7 @@ public:
 
       // Extract FK value from the foreign object
       insert_step rel_step{};
-      const auto pk = rel_step.pk_accessor.get(obj);
+      const auto pk = rel_step.pk_accessor.get(*obj);
       if (pk.is_valid()) {
         continue;
       }
@@ -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_;

include/matador/query/intermediates/executable_query.hpp

@@ -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;
 };
 

include/matador/query/query_contexts.hpp

@@ -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

include/matador/query/schema.hpp

@@ -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_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::connection &conn) ;
+  [[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);
 

include/matador/query/table.hpp

@@ -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_;
 };

include/matador/query/table_column.hpp

@@ -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;
 

include/matador/sql/statement.hpp

@@ -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;

include/matador/utils/result.hpp

@@ -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;

source/orm/CMakeLists.txt

@@ -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

source/orm/orm/session.cpp

@@ -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 {

source/orm/query/basic_schema.cpp

@@ -86,7 +86,7 @@ bool basic_schema::contains(const std::type_index &index) const {
   return schema_nodes_.count(index) == 1;
 }
 
-void basic_schema::initialize_executor(sql::executor &exec) const {
+void basic_schema::initialize(sql::executor &exec) const {
   auto factory = std::make_shared<sql::producer_resolver_factory>();
   for (const auto &[key, producer] : resolver_producers_) {
     auto resolver = producer->produce(exec);

source/orm/query/generator.cpp

@@ -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;
+}
 }

source/orm/query/insert_query_builder.cpp

@@ -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)
+insert_query_builder::insert_query_builder(const basic_schema& schema, const std::unordered_map<std::type_index, query_contexts> &contexts_by_type)
-: schema_(schema) {}
+: 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

source/orm/query/intermediates/executable_query.cpp

@@ -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 {

source/orm/query/schema.cpp

@@ -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*/) {

source/orm/query/table.cpp

@@ -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) {
+// const table_column& table::create_column(class table &tab, const std::string &name) {
-  tab.columns_.emplace_back(name);
+  // tab.columns_.emplace_back(name);
-  tab.columns_.back().table(&tab);
+  // tab.columns_.back().table(&tab);
-  return tab.columns_.back();
+  // return tab.columns_.back();
-}
+// }
 }

source/orm/query/table_column.cpp

@@ -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_;
 }

test/backends/QueryTest.cpp

@@ -311,7 +311,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and for single
     .and_then([this] {return repo.create(db); });
   REQUIRE(result.is_ok());
 
-  repo.initialize_executor(db);
+  repo.initialize(db);
 
   REQUIRE(db.exists(AIRPLANE.table_name()));
   REQUIRE(db.exists(FLIGHT.table_name()));
@@ -538,7 +538,7 @@ TEST_CASE_METHOD(QueryFixture, "Test load entity with eager has many relation",
     .and_then([this] {return repo.create(db); });
   REQUIRE(result.is_ok());
 
-  repo.initialize_executor(db);
+  repo.initialize(db);
 
   const std::vector shipments {
     make_object<shipment>(1, "4711"),
@@ -636,7 +636,7 @@ TEST_CASE_METHOD(QueryFixture, "Test load entity with lazy has many relation", "
   } );
   REQUIRE(result.is_ok());
 
-  repo.initialize_executor(db);
+  repo.initialize(db);
 
   const std::vector authors {
     make_object<author>(1, "Michael", "Crichton", "23.10.1942", 1975, true),
@@ -718,7 +718,7 @@ TEST_CASE_METHOD(QueryFixture, "Test load entity with lazy belongs to relation",
     .and_then([this] {return repo.create(db); });
   REQUIRE(result.is_ok());
 
-  repo.initialize_executor(db);
+  repo.initialize(db);
 
   const std::vector deps {
     make_object<department>(1, "Human Resources"),
@@ -864,7 +864,7 @@ TEST_CASE_METHOD(QueryFixture, "Test load entity with eager has many to many rel
 
   REQUIRE(result.is_ok());
 
-  repo.initialize_executor(db);
+  repo.initialize(db);
 
   REQUIRE(db.exists(RECIPE.table_name()));
   REQUIRE(db.exists(INGREDIENT.table_name()));

test/backends/SessionFixture.cpp

@@ -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)) {
+  if (db.exists(table_name)) {
-    REQUIRE(ses.drop_table(table_name));
+    REQUIRE(query::drop().table(table_name).execute(db));
   }
 }
 

test/backends/SessionFixture.hpp

@@ -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;
 

test/backends/SessionInsertHasMany.cpp

@@ -2,6 +2,8 @@
 
 #include "SessionFixture.hpp"
 
+#include "connection.hpp"
+
 #include "models/author.hpp"
 #include "models/book.hpp"
 
@@ -15,7 +17,8 @@ TEST_CASE_METHOD(SessionFixture, "Test insert object with has many relation", "[
     .and_then([this] { return schema.create(db); } );
   REQUIRE(result.is_ok());
 
-  schema.initialize_executor(ses);
+  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);
 

test/backends/SessionTest.cpp

@@ -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,7 +70,9 @@ TEST_CASE_METHOD(SessionFixture, "Session delete test", "[session][delete]") {
     .and_then([this] { return schema.create(db); } );
   REQUIRE(res.is_ok());
 
-  schema.initialize_executor(ses);
+  orm::session ses({bus, connection::dns, 4}, schema);
+
+  schema.initialize(ses);
 
   auto result = ses.insert(make_object<airplane>(1, "Boeing", "A380"));
   REQUIRE(result.is_ok());
@@ -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,7 +175,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());
 
-  schema.initialize_executor(ses);
+  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),
     make_object<author>( 2, "Steven", "King", "21.9.1947", 1956, false)
@@ -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"),

test/backends/StatementTest.cpp

@@ -26,7 +26,7 @@ public:
   StatementTestFixture() {
     REQUIRE(repo.attach<airplane>("airplanes")
       .and_then([this] {return repo.create(db); }));
-    repo.initialize_executor(db);
+    repo.initialize(db);
   }
 
 protected:

test/orm/query/InsertQueryBuilderTest.cpp

@@ -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);
+  // 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>(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>(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>(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>(5, "Misery", object_ptr<author>{}, 1987));
-  s_king->books.push_back(make_object<book>(6, "The Dark Tower: The Gunslinger", object_ptr<author>{}, 1982));
+  // s_king->books.push_back(make_object<book>(6, "The Dark Tower: The Gunslinger", object_ptr<author>{}, 1982));
-
+  //
-  insert_query_builder iqb(scm);
+  // insert_query_builder iqb(scm);
-
+  //
-  auto build_result = iqb.build(s_king);
+  // auto build_result = iqb.build(s_king);
-  REQUIRE(build_result.is_ok());
+  // REQUIRE(build_result.is_ok());
-
+  //
-  const auto& stmts = *build_result;
+  // const auto& stmts = *build_result;
-  REQUIRE(stmts.size() == 1);
+  // REQUIRE(stmts.size() == 1);
 }

test/orm/query/QueryBuilderTest.cpp

@@ -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)))##");
 }

test/orm/sql/StatementCacheTest.cpp

@@ -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();
 }