pk generator progress and sequence test progress

source/orm/query/intermediates/query_select_intermediate.cpp

@@ -17,6 +17,12 @@ fetchable_query query_select_intermediate::nextval(const std::string& sequence_n
   return {context_};
 }
 
+fetchable_query query_select_intermediate::currval(const std::string& sequence_name) {
+    context_->parts.pop_back();
+    context_->parts.push_back(std::make_unique<internal::query_select_currval_part>(sequence_name));
+    return {context_};
+}
+
 query_from_intermediate query_select_intermediate::from(const std::vector<table>& tables) {
   context_->parts.push_back(std::make_unique<internal::query_from_part>(tables));
   for (const auto& tab : tables) {

source/orm/query/internal/query_parts.cpp

@@ -147,6 +147,19 @@ void query_select_nextval_part::accept(query_part_visitor& visitor) {
   visitor.visit(*this);
 }
 
+query_select_currval_part::query_select_currval_part(std::string sequence_name)
+: query_part(sql::dialect_token::NextVal)
+, sequence_name_(std::move(sequence_name)){
+}
+
+const std::string& query_select_currval_part::sequence_name() const {
+  return sequence_name_;
+}
+
+void query_select_currval_part::accept(query_part_visitor& visitor) {
+  visitor.visit(*this);
+}
+
 query_from_part::query_from_part(std::vector<table> tables)
 : query_part(sql::dialect_token::From)
 , tables_(std::move(tables)) {

source/orm/query/manual_pk_generator.cpp

@@ -10,4 +10,8 @@ manual_pk_generator::manual_pk_generator()
 utils::result<int64_t, utils::error> manual_pk_generator::next_id(const sql::executor &/*exec*/) {
   return utils::failure(utils::error(sql::error_code::FAILURE, "Manual PK generator not implemented"));
 }
+
+utils::result<int64_t, utils::error> manual_pk_generator::current_id(const sql::executor& exec) {
+  return utils::failure(utils::error(sql::error_code::FAILURE, "Manual PK generator not implemented"));
+}
 }

source/orm/query/query_builder.cpp

@@ -104,6 +104,11 @@ void query_builder::visit(internal::query_select_nextval_part& part) {
   prepare_prototype(query_.prototype, part.sequence_name());
 }
 
+void query_builder::visit(internal::query_select_currval_part& part) {
+  query_.sql += dialect_->select() + " " + dialect_->currval() + "('" + part.sequence_name() + "')";
+  prepare_prototype(query_.prototype, part.sequence_name());
+}
+
 void query_builder::visit(internal::query_from_part &part) {
   query_.table_name = part.tables().front().name();
   query_.sql += " " + dialect_->from() + " ";

source/orm/query/sequence_pk_generator.cpp

@@ -6,11 +6,21 @@
 namespace matador::query {
 sequence_pk_generator::sequence_pk_generator(const std::string& sequence_name)
 : abstract_pk_generator(utils::generator_type::Sequence)
-, query_(query::select().nextval(sequence_name)) {
+, next_id_query_(query::select().nextval(sequence_name))
+, current_id_query_(query::select().currval(sequence_name)) {
 }
 
 utils::result<int64_t, utils::error> sequence_pk_generator::next_id(const sql::executor& exec) {
-    return query_.fetch_value<int64_t>(exec).and_then([](const std::optional<int64_t> id) -> utils::result<int64_t, utils::error> {
+    return next_id_query_.fetch_value<int64_t>(exec).and_then([](const std::optional<int64_t> id) -> utils::result<int64_t, utils::error> {
+        if (!id) {
+            return utils::failure(utils::error(sql::error_code::RETRIEVE_DATA_FAILED, "Sequence returned no value"));
+        }
+        return utils::ok(*id);
+    });
+}
+
+utils::result<int64_t, utils::error> sequence_pk_generator::current_id(const sql::executor& exec) {
+    return current_id_query_.fetch_value<int64_t>(exec).and_then([](const std::optional<int64_t> id) -> utils::result<int64_t, utils::error> {
         if (!id) {
             return utils::failure(utils::error(sql::error_code::RETRIEVE_DATA_FAILED, "Sequence returned no value"));
         }

source/orm/query/table_pk_generator.cpp

@@ -4,23 +4,35 @@
 #include "matador/query/error_code.hpp"
 #include "matador/query/expression/expression_operators.hpp"
 
+#include "matador/sql/error_code.hpp"
+
 namespace matador::query {
 table_pk_generator::table_pk_generator(const std::string& table_name, const std::string &sequence_name)
-: abstract_pk_generator(utils::generator_type::Table) {
-
-  query::update(table_name)
-    .set("next_id"_col, "next_id"_col + 1)
-    .where("name"_col == sequence_name)
-    .returning(("next_id"_col - 1).as("id"));
-  /*
-  *UPDATE id_table
-  SET next_id = next_id + 1
-  WHERE name = 'users'
-  RETURNING next_id - 1 AS id;
-  */
-}
+: abstract_pk_generator(utils::generator_type::Table)
+, next_id_query_(query::update(table_name)
+  .set("next_id"_col, "next_id"_col + 1)
+  .where("name"_col == sequence_name)
+  .returning(("next_id"_col - 1).as("id")))
+, current_id_query_(query::select({"next_id"_col})
+  .from(table_name)
+  .where("name"_col == sequence_name)
+) {}
 
 utils::result<int64_t, utils::error> table_pk_generator::next_id(const sql::executor &exec) {
-  return utils::failure(utils::error{error_code::Failure});
+    return next_id_query_.fetch_value<int64_t>(exec).and_then([](const std::optional<int64_t> id) -> utils::result<int64_t, utils::error> {
+        if (!id) {
+            return utils::failure(utils::error(sql::error_code::RETRIEVE_DATA_FAILED, "Sequence returned no value"));
+        }
+        return utils::ok(*id);
+    });
+}
+
+utils::result<int64_t, utils::error> table_pk_generator::current_id(const sql::executor& exec) {
+    return current_id_query_.fetch_value<int64_t>(exec).and_then([](const std::optional<int64_t> id) -> utils::result<int64_t, utils::error> {
+        if (!id) {
+            return utils::failure(utils::error(sql::error_code::RETRIEVE_DATA_FAILED, "Sequence returned no value"));
+        }
+        return utils::ok(*id);
+    });
 }
 }