added returning to update statement and added error code implementation for query

source/orm/query/error_code.cpp

@@ -0,0 +1,45 @@
+#include "matador/query/error_code.hpp"
+
+namespace matador::query {
+const char* query_category_impl::name() const noexcept {
+  return "query";
+}
+
+std::string query_category_impl::message(int ev) const {
+  switch (static_cast<error_code>(ev)) {
+    case error_code::Success:
+      return "Success";
+    case error_code::Failure:
+      return "Failure";
+    case error_code::InvalidQuery:
+      return "Invalid query";
+    case error_code::InvalidSchema:
+      return "Invalid schema";
+    case error_code::InvalidTable:
+      return "Invalid table";
+    case error_code::InvalidColumn:
+      return "Invalid column";
+    case error_code::InvalidConstraint:
+      return "Invalid constraint";
+    case error_code::InvalidDataType:
+      return "Invalid data type";
+    case error_code::InvalidValue:
+      return "Invalid value";
+    default:
+      return "Unknown error";
+  }
+}
+
+const std::error_category& query_category() {
+  static query_category_impl instance;
+  return instance;
+}
+
+std::error_code make_error_code(error_code e) {
+  return {static_cast<int>(e), query_category()};
+}
+
+std::error_condition make_error_condition(error_code e) {
+  return {static_cast<int>(e), query_category()};
+}
+}

source/orm/query/intermediates/query_execute_where_intermediate.cpp

@@ -8,6 +8,10 @@
 #include "matador/query/query_data.hpp"
 
 namespace matador::query {
+fetchable_query query_execute_where_intermediate::returning(const std::vector<table_column>& table_columns) {
+  context_->parts.push_back(std::make_unique<internal::query_returning_part>(table_columns));
+  return {context_};
+}
 
 query_execute_limit_intermediate query_execute_where_intermediate::limit(size_t limit) {
   context_->parts.push_back(std::make_unique<internal::query_limit_part>(limit));

source/orm/query/intermediates/query_into_intermediate.cpp

@@ -4,11 +4,6 @@
 #include "matador/query/query_data.hpp"
 
 namespace matador::query {
-fetchable_query query_values_intermediate::returning(const table_column &col) {
-  context_->parts.push_back(std::make_unique<internal::query_returning_part>(std::vector{col}));
-  return {context_};
-}
-
 query_values_intermediate query_into_intermediate::values(const std::initializer_list<std::variant<utils::placeholder, utils::database_type>> values) {
   return this->values(std::vector(values));
 }

source/orm/query/intermediates/query_set_intermediate.cpp

@@ -4,6 +4,9 @@
 #include "matador/query/query_data.hpp"
 
 namespace matador::query {
+query_execute_where_intermediate query_set_intermediate::where(std::unique_ptr<abstract_criteria> cond) {
+  return where_clause(std::move(cond));
+}
 
 query_execute_where_intermediate query_set_intermediate::where_clause(std::unique_ptr<abstract_criteria> &&cond)
 {

source/orm/query/intermediates/query_values_intermediate.cpp

@@ -0,0 +1,11 @@
+#include "matador/query/intermediates/query_values_intermediate.hpp"
+
+#include "matador/query/internal/query_parts.hpp"
+#include "matador/query/query_data.hpp"
+
+namespace matador::query {
+fetchable_query query_values_intermediate::returning(const std::vector<table_column>& table_columns) {
+  context_->parts.push_back(std::make_unique<internal::query_returning_part>(table_columns));
+  return {context_};
+}
+}

source/orm/query/schema.cpp

@@ -3,6 +3,7 @@
 #include "matador/query/schema.hpp"
 
 #include "matador/query/query.hpp"
+#include "matador/query/manual_pk_generator.hpp"
 
 #include "matador/object/repository_node.hpp"
 
@@ -164,6 +165,6 @@ schema::iterator schema::insert_table(const std::type_index &ti, const object::r
   for (const auto &attr: node.info().attributes()) {
     columns.emplace_back(nullptr, attr.name(), attr.type(), attr.attributes());
   }
-  return schema_nodes_.insert({ti, schema_node{table(node.name(), columns), generator_type, node}}).first;
+  return schema_nodes_.insert({ti, schema_node{table(node.name(), columns), std::make_unique<manual_pk_generator>(), node}}).first;
 }
 } // namespace matador::query

source/orm/query/table_pk_generator.cpp

@@ -1,5 +1,6 @@
 #include "matador/query/table_pk_generator.hpp"
 #include "matador/query/query.hpp"
+#include "matador/query/error_code.hpp"
 
 namespace matador::query {
 table_pk_generator::table_pk_generator(const std::string& table_name, const std::string &sequence_name)
@@ -18,5 +19,6 @@ table_pk_generator::table_pk_generator(const std::string& table_name, const std:
 }
 
 utils::result<int64_t, utils::error> table_pk_generator::next_id(const sql::executor &exec) {
+  return utils::failure(utils::error{error_code::Failure});
 }
 }