fixing postgres tests progress

include/matador/query/session.hpp

@@ -95,14 +95,14 @@ 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<Type> iqb(schema_, contexts_by_type_);
+  insert_query_builder<Type> 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."));
   }
 
   // Execute all steps; for Identity steps read RETURNING and write pk back into the object
-  for (query::insert_step &step : *steps) {
+  for (insert_step &step : *steps) {
     if (step.pk_generator == utils::generator_type::Sequence || step.pk_generator == utils::generator_type::Table) {
       const auto conn = pool_.acquire();
       if (!conn.valid()) {

include/matador/query/table.hpp

@@ -43,13 +43,11 @@ public:
   [[nodiscard]] bool is_relation_table() const;
   [[nodiscard]] bool has_primary_key() const;
 
-  [[nodiscard]] std::optional<table_column*> primary_key_column() const;
+  [[nodiscard]] const 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);
-
   table(std::string  name, std::string  alias, const std::vector<table_column>& columns);
 
 private:
@@ -61,7 +59,7 @@ private:
   std::string schema_name_;
   std::vector<table_column> columns_;
 
-  std::optional<table_column*> pk_column_{std::nullopt};
+  int pk_column_index_{-1};
   std::string join_column_name_;
   std::string inverse_join_column_name_;
 };

source/orm/query/session.cpp

@@ -42,19 +42,19 @@ session::session(session_context&& ctx, const query::schema &scm)
       // SELECT one
       queries.select_one = query::select(node.table())
         .from(node.name())
-        .where(*node.table().primary_key_column().value() == _)
+        .where(*node.table().primary_key_column() == _)
         .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() == _)
+      queries.update_one = update_set.where(*node.table().primary_key_column() == _)
         .compile(dialect_);
       // DELETE one
       queries.delete_one = query::remove()
         .from(node.name())
-        .where(*node.table().primary_key_column().value() == _)
+        .where(*node.table().primary_key_column() == _)
         .compile(dialect_);
     }
     // INSERT one
@@ -63,6 +63,11 @@ session::session(session_context&& ctx, const query::schema &scm)
       .values(query::generator::placeholders(node.table().columns().size()))
       .compile(dialect_);
 
+    queries.insert.resolver = resolver_service_;
+    queries.update_one.resolver = resolver_service_;
+    queries.delete_one.resolver = resolver_service_;
+    queries.select_one.resolver = resolver_service_;
+    queries.select_all.resolver = resolver_service_;
     contexts_by_type_[node.node().type_index()] = queries;
   }
 

source/orm/query/table.cpp

@@ -19,16 +19,20 @@ table::table(std::string name, std::string alias, const std::vector<table_column
 : name_(std::move(name))
 , alias_(std::move(alias))
 , columns_(columns) {
-  for (auto &col : columns_) {
+  for (int i = 0; i < columns.size(); ++i) {
-    col.table(this);
+    columns_[i].table(this);
-    if (col.is_primary_key()) {
+    if (columns_[i].is_primary_key()) {
-      pk_column_ = &col;
+      pk_column_index_ = i;
     }
   }
 }
 
 table::table(const table &other)
-: table(other.name_,  other.alias_, other.columns_) {
+: name_(other.name_)
+, alias_(other.alias_)
+, schema_name_(other.schema_name_)
+, columns_(other.columns_)
+, pk_column_index_(other.pk_column_index_){
   for (auto &col : columns_) {
     col.table(this);
   }
@@ -49,6 +53,7 @@ table & table::operator=(table &&other) noexcept {
   name_ = std::move(other.name_);
   alias_ = std::move(other.alias_);
   columns_ = std::move(other.columns_);
+  pk_column_index_ = other.pk_column_index_;
   for (auto &col : columns_) {
     col.table(this);
   }
@@ -109,11 +114,11 @@ bool table::is_relation_table() const {
 }
 
 bool table::has_primary_key() const {
-  return pk_column_.has_value();
+  return pk_column_index_ > -1;
 }
 
-std::optional<table_column *> table::primary_key_column() const {
+const table_column* table::primary_key_column() const {
-  return pk_column_;
+  return pk_column_index_ > -1 ? &columns_.at(pk_column_index_) : nullptr;
 }
 
 const std::string &table::join_column_name() const {
@@ -123,10 +128,4 @@ const std::string &table::join_column_name() const {
 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) {
-  // tab.columns_.emplace_back(name);
-  // tab.columns_.back().table(&tab);
-  // return tab.columns_.back();
-// }
 }

source/orm/query/table_column.cpp

@@ -139,19 +139,19 @@ bool table_column::is_nullable() const {
 }
 
 bool table_column::is_primary_key() const {
-  return !utils::is_constraint_set(attributes_.options(), utils::constraints::PrimaryKey);
+  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);
+  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);
+  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);
+  return utils::is_constraint_set(attributes_.options(), utils::constraints::Identity);
 }
 
 sql::sql_function_t table_column::function() const {

test/models/airplane.hpp

@@ -24,8 +24,8 @@ struct airplane {
     namespace field = matador::access;
     using namespace matador::utils;
     field::primary_key(op, "id", id);
-    field::attribute(op, "brand", brand, UniqueVarChar255);
+    field::attribute(op, "brand", brand, VarChar255);
-    field::attribute(op, "model", model, UniqueVarChar255);
+    field::attribute(op, "model", model, VarChar255);
   }
 };
 }

test/models/flight.hpp

@@ -29,7 +29,7 @@ struct flight {
     namespace field = matador::access;
     using namespace matador::utils;
     field::primary_key(op, "id", id);
-    field::belongs_to(op, "airplane_id", plane, {utils::cascade_type::All, fetch_type::Eager});
+    field::belongs_to(op, "airplane_id", plane, CascadeAllFetchEager);
     field::attribute(op, "pilot_name", pilot_name, VarChar255);
   }
 };