added `returning` token for insert query

include/matador/query/intermediates/query_into_intermediate.hpp

@@ -2,24 +2,32 @@
 #define QUERY_INTO_INTERMEDIATE_HPP
 
 #include "matador/query/intermediates/executable_query.hpp"
+#include "matador/query/intermediates/fetchable_query.hpp"
 
 #include "matador/query/value_extractor.hpp"
 
 #include "matador/utils/placeholder.hpp"
 
 namespace matador::query {
+class table_column;
 
-class query_into_intermediate : public query_intermediate
+class query_values_intermediate : public executable_query {
-{
+public:
+  using executable_query::executable_query;
+
+  fetchable_query returning(const table_column &col);
+};
+
+class query_into_intermediate : public query_intermediate {
 public:
   using query_intermediate::query_intermediate;
 
-  executable_query values(std::initializer_list<std::variant<utils::placeholder, utils::database_type>> values);
+  query_values_intermediate values(std::initializer_list<std::variant<utils::placeholder, utils::database_type>> values);
-  executable_query values(std::vector<std::variant<utils::placeholder, utils::database_type>> &&values);
+  query_values_intermediate values(std::vector<std::variant<utils::placeholder, utils::database_type>> &&values);
-  executable_query values(std::vector<utils::placeholder> &&values);
+  query_values_intermediate values(std::vector<utils::placeholder> &&values);
-  executable_query values(std::vector<utils::database_type> &&values);
+  query_values_intermediate values(std::vector<utils::database_type> &&values);
   template<class Type>
-  executable_query values(const Type &obj) {
+  query_values_intermediate values(const Type &obj) {
     return values(value_extractor::extract(obj));
   }
 };

include/matador/query/internal/query_parts.hpp

@@ -317,8 +317,7 @@ private:
 /**
  * Represents the SQL VALUES part
  */
-class query_values_part final : public query_part
+class query_values_part final : public query_part {
-{
 public:
   explicit query_values_part(std::vector<std::variant<utils::placeholder, utils::database_type>> &&values);
 
@@ -331,6 +330,19 @@ private:
   std::vector<std::variant<utils::placeholder, utils::database_type>> values_;
 };
 
+class query_returning_part final : public query_part {
+public:
+  explicit query_returning_part(std::vector<table_column> columns);
+
+  [[nodiscard]] const std::vector<table_column>& columns() const;
+
+private:
+  void accept(query_part_visitor &visitor) override;
+
+private:
+  std::vector<table_column> columns_;
+};
+
 class query_update_part final : public query_part
 {
 public:

include/matador/query/query_builder.hpp

@@ -44,7 +44,6 @@ protected:
   void visit(internal::query_drop_key_constraint_part_by_name &part) override;
   void visit(internal::query_drop_key_constraint_part_by_constraint &part) override;
 
-protected:
   void visit(internal::query_select_part &part) override;
   void visit(internal::query_from_part &part) override;
   void visit(internal::query_join_table_part &part) override;
@@ -57,9 +56,11 @@ protected:
   void visit(internal::query_order_by_desc_part &part) override;
   void visit(internal::query_offset_part &part) override;
   void visit(internal::query_limit_part &part) override;
+
   void visit(internal::query_insert_part &part) override;
   void visit(internal::query_into_part &part) override;
   void visit(internal::query_values_part &part) override;
+  void visit(internal::query_returning_part &part) override;
 
   void visit(internal::query_update_part &part) override;
   void visit(internal::query_set_part &part) override;

include/matador/query/query_part_visitor.hpp

@@ -4,7 +4,9 @@
 namespace matador::query {
 
 namespace internal {
+// Alter common
 class query_alter_part;
+// Alter table
 class query_alter_table_part;
 class query_add_key_constraint_part;
 class query_drop_key_constraint_part_by_name;
@@ -13,6 +15,7 @@ class query_add_foreign_key_constraint_part;
 class query_add_constraint_part_by_constraint;
 class query_add_foreign_key_reference_part;
 class query_add_primary_key_constraint_part;
+// Select
 class query_select_part;
 class query_from_part;
 class query_join_table_part;
@@ -25,20 +28,30 @@ class query_order_by_asc_part;
 class query_order_by_desc_part;
 class query_offset_part;
 class query_limit_part;
+// Insert
 class query_insert_part;
 class query_into_part;
 class query_values_part;
+class query_returning_part;
+// Update
 class query_update_part;
 class query_set_part;
+// Delete
 class query_delete_part;
 class query_delete_from_part;
+// Create common
 class query_create_part;
+// Create table
 class query_create_table_part;
 class query_create_table_columns_part;
 class query_create_table_constraints_part;
+// Create schema
 class query_create_schema_part;
+// Drop common
 class query_drop_part;
+// Drop table
 class query_drop_table_part;
+// Drop schema
 class query_drop_schema_part;
 }
 
@@ -72,6 +85,7 @@ public:
   virtual void visit(internal::query_insert_part &part) = 0;
   virtual void visit(internal::query_into_part &part) = 0;
   virtual void visit(internal::query_values_part &part) = 0;
+  virtual void visit(internal::query_returning_part &part) = 0;
 
   virtual void visit(internal::query_update_part &part) = 0;
   virtual void visit(internal::query_set_part &part) = 0;

include/matador/query/query_utils.hpp

@@ -12,6 +12,7 @@ class dialect;
 namespace matador::query {
 class table_column;
 
+void prepare_column(std::string &out, const sql::dialect& d, const table_column &col);
 [[nodiscard]] std::string prepare_identifier(const sql::dialect& d, const table_column &col);
 [[nodiscard]] std::string prepare_criteria(const sql::dialect& d, const table_column &col);
 }

include/matador/sql/dialect.hpp

@@ -166,6 +166,7 @@ public:
   [[nodiscard]] const std::string& primary_key() const;
   [[nodiscard]] const std::string& references() const;
   [[nodiscard]] const std::string& remove() const;
+  [[nodiscard]] const std::string& returning() const;
   [[nodiscard]] const std::string& rollback() const;
   [[nodiscard]] const std::string& schema() const;
   [[nodiscard]] const std::string& select() const;
@@ -236,6 +237,7 @@ private:
     {dialect_token::PrimaryKey,  "PRIMARY KEY"},
     {dialect_token::References,  "REFERENCES"},
     {dialect_token::Remove,      "DELETE"},
+    {dialect_token::Returning,   "RETURNING"},
     {dialect_token::Rollback,    "ROLLBACK TRANSACTION"},
     {dialect_token::Schema,      "SCHEMA"},
     {dialect_token::Select,      "SELECT"},

include/matador/sql/dialect_token.hpp

@@ -51,6 +51,7 @@ enum class dialect_token : uint8_t {
   PrimaryKey,
   References,
   Remove,
+  Returning,
   Rollback,
   Schema,
   Select,

include/matador/sql/execute_result.hpp

@@ -1,11 +1,14 @@
 #ifndef MATADOR_EXECUTE_RESULT_HPP
 #define MATADOR_EXECUTE_RESULT_HPP
+
+#include "matador/utils/identifier.hpp"
+
 #include <vector>
 
 namespace matador::sql {
 struct execute_result {
   size_t affected_rows{};
-  std::vector<long long> insert_ids{};
+  std::vector<utils::identifier> generated_ids{};
 };
 }
 #endif  // MATADOR_EXECUTE_RESULT_HPP

include/matador/sql/query_context.hpp

@@ -27,9 +27,10 @@ enum class sql_command {
   AlterSchema
 };
 
-struct sql_command_info {
+enum class return_mode {
-  std::string sql;
+  None,
-  sql_command command{};
+  GeneratedKeys,
+  Rows
 };
 
 struct query_context {
@@ -44,6 +45,14 @@ struct query_context {
   // Data for resolving query result
   std::shared_ptr<resolver_service> resolver{};
   std::type_index result_type = typeid(void);
+  return_mode mode = return_mode::None;
+
+  [[nodiscard]] bool is_ddl() const { return command == sql_command::Create || command == sql_command::Alter; }
+  [[nodiscard]] bool is_dml() const { return command == sql_command::Insert || command == sql_command::Update || command == sql_command::Delete; }
+  [[nodiscard]] bool is_query() const { return command == sql_command::Select; }
+
+  [[nodiscard]] bool expects_rows() const { return mode == return_mode::Rows; }
+  [[nodiscard]] bool expects_generated_keys() const { return mode == return_mode::GeneratedKeys; }
 };
 }
 

include/matador/sql/record.hpp

@@ -9,20 +9,14 @@
 namespace matador::sql {
 
 class record final {
-private:
-  using field_ref = std::reference_wrapper<field>;
-  using field_by_index = std::vector<field_ref>;
-  using field_index_pair = std::pair<field, field_by_index::difference_type>;
-  using field_by_name_map = std::unordered_map<std::string, field_index_pair>;
-
 public:
-  using iterator = field_by_index::iterator;
+  using iterator = std::vector<field>::iterator;
-  using const_iterator = field_by_index::const_iterator;
+  using const_iterator = std::vector<field>::const_iterator;
 
   record() = default;
   record(std::initializer_list<field> columns);
   explicit record(const std::vector<field> &columns);
-  record(const record &x);
+  record(const record &x) = default;
   record& operator=(const record &x);
   record(record&&) noexcept = default;
   record& operator=(record&&) noexcept = default;
@@ -34,13 +28,13 @@ public:
   template<class Operator>
   void process(Operator &op) {
     for(auto &f : fields_) {
-      f.get().process(op);
+      f.process(op);
     }
   }
 
-  void append(const field &col);
+  void append(field col);
 
-  [[nodiscard]] const std::vector<field_ref>& columns() const;
+  [[nodiscard]] const std::vector<field>& columns() const;
 
   [[nodiscard]] const field& at(const std::string &name) const;
   [[nodiscard]] const field& at(size_t index) const;
@@ -71,12 +65,8 @@ public:
   void clear();
 
 private:
-  void init();
+  std::vector<field> fields_;
-  void add_to_map(field &col, size_t index);
+  std::unordered_map<std::string, std::size_t> index_by_name_;
-
-private:
-  field_by_index fields_;
-  field_by_name_map fields_by_name_;
 };
 
 }

source/orm/query/intermediates/query_into_intermediate.cpp

@@ -4,18 +4,21 @@
 #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_};
+}
 
-executable_query query_into_intermediate::values(const std::initializer_list<std::variant<utils::placeholder, utils::database_type>> values)
+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));
 }
 
-executable_query query_into_intermediate::values(std::vector<std::variant<utils::placeholder, utils::database_type>> &&values) {
+query_values_intermediate query_into_intermediate::values(std::vector<std::variant<utils::placeholder, utils::database_type>> &&values) {
   context_->parts.push_back(std::make_unique<internal::query_values_part>(std::move(values)));
   return {context_};
 }
 
-executable_query query_into_intermediate::values(std::vector<utils::placeholder>&& values) {
+query_values_intermediate query_into_intermediate::values(std::vector<utils::placeholder>&& values) {
   std::vector<std::variant<utils::placeholder, utils::database_type>> transformed_values;
   transformed_values.reserve(values.size());
   for (auto&& val : values) {
@@ -24,7 +27,7 @@ executable_query query_into_intermediate::values(std::vector<utils::placeholder>
   return this->values(std::move(transformed_values));
 }
 
-executable_query query_into_intermediate::values(std::vector<utils::database_type>&& values) {
+query_values_intermediate query_into_intermediate::values(std::vector<utils::database_type>&& values) {
   std::vector<std::variant<utils::placeholder, utils::database_type>> transformed_values;
   transformed_values.reserve(values.size());
   for (auto&& val : values) {

source/orm/query/internal/query_parts.cpp

@@ -311,6 +311,19 @@ void query_values_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
+query_returning_part::query_returning_part(std::vector<table_column> columns)
+: query_part(sql::dialect_token::Returning)
+, columns_(std::move(columns)) {
+}
+
+const std::vector<table_column> & query_returning_part::columns() const {
+  return columns_;
+}
+
+void query_returning_part::accept(query_part_visitor &visitor) {
+  visitor.visit(*this);
+}
+
 query_update_part::query_update_part(class table tab)
 : query_part(sql::dialect_token::Update)
 , table_(std::move(tab)) {

source/orm/query/query_builder.cpp

@@ -36,16 +36,10 @@ sql::query_context query_builder::compile(const query_data &data,
   return {query_};
 }
 
-std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const table_column &col) {
+void build_columns_with_name_only(std::string &out, const std::vector<table_column> &cols, const sql::dialect &d);
-  if (col.is_function()) {
+void build_columns(std::string &out, const std::vector<table_column> &cols, const sql::dialect &d);
-    ctx.prototype.emplace_back(col.has_alias() ? col.alias() : col.canonical_name());
+void build_fetchable_columns(sql::query_context &ctx, const std::vector<table_column> &cols, const sql::dialect &d);
-    ctx.prototype.back().change_type(utils::basic_type::Int32);
+void prepare_prototype(std::vector<object::attribute> &prototype, const table_column &col);
-  } else {
-    ctx.prototype.emplace_back(col.has_alias() ? col.alias() : col.canonical_name());
-  }
-
-  return prepare_identifier(*d, col);
-}
 
 void query_builder::visit(internal::query_alter_part& part) {
   query_.sql = dialect_->token_at(part.token());
@@ -61,9 +55,6 @@ void query_builder::visit(internal::query_add_key_constraint_part& part) {
   query_.sql += " " + dialect_->add_constraint() + " " + part.name();
 }
 
-void build_columns_with_name_only(std::string &out, const std::vector<table_column> &cols, const sql::dialect &d);
-void build_columns(std::string &out, const std::vector<table_column> &cols, const sql::dialect &d);
-
 void query_builder::visit(internal::query_add_foreign_key_constraint_part& part) {
   query_.sql += " " + dialect_->token_at(part.token()) + " (";
   build_columns(query_.sql, part.columns(), *dialect_);
@@ -100,23 +91,7 @@ void query_builder::visit(internal::query_select_part &part) {
 
   query_.prototype.clear();
 
-  std::string result;
+  build_fetchable_columns(query_, part.columns(), *dialect_);
-  if (part.columns().empty()) {
-      result = dialect_->asterisk();
-  } else if (const auto &columns = part.columns(); columns.size() < 2) {
-    for (const auto &col: columns) {
-      result.append(handle_column(query_, dialect_, col ));
-    }
-  } else {
-    auto it = columns.begin();
-    result.append(handle_column(query_, dialect_, *it++));
-    for (; it != columns.end(); ++it) {
-      result.append(", ");
-      result.append(handle_column(query_, dialect_, *it));
-    }
-  }
-
-  query_.sql += result;
 }
 
 void query_builder::visit(internal::query_from_part &part) {
@@ -265,15 +240,20 @@ void query_builder::visit(internal::query_values_part &part) {
   query_.sql += " " + result;
 }
 
-void query_builder::visit(internal::query_update_part &part)
+void query_builder::visit(internal::query_returning_part &part) {
-{
+  query_.mode = sql::return_mode::Rows;
-  query_.command = sql::sql_command::Update;
+  query_.sql += " " + dialect_->returning() + " ";
-  query_.table_name = part.table().name();
+
-  query_.sql += query_builder::build_table_name(part.token(), *dialect_, query_.table_name);
+  build_fetchable_columns(query_, part.columns(), *dialect_);
 }
 
-void query_builder::visit(internal::query_delete_part &/*delete_part*/)
+void query_builder::visit(internal::query_update_part &part) {
-{
+  query_.command = sql::sql_command::Update;
+  query_.table_name = part.table().name();
+  query_.sql += build_table_name(part.token(), *dialect_, query_.table_name);
+}
+
+void query_builder::visit(internal::query_delete_part &/*delete_part*/) {
   query_.command = sql::sql_command::Delete;
   query_.sql = dialect_->remove();
 }
@@ -408,6 +388,27 @@ void build_columns(std::string &out, const std::vector<table_column> &cols,  con
   }
 }
 
+void build_fetchable_columns(sql::query_context &ctx, const std::vector<table_column> &cols, const sql::dialect &d) {
+  bool first = true;
+  for (const auto& col : cols) {
+    if (!first) {
+      ctx.sql.append(", ");
+    }
+    prepare_prototype(ctx.prototype, col);
+    prepare_column(ctx.sql, d, col);
+    first = false;
+  }
+}
+
+void prepare_prototype(std::vector<object::attribute> &prototype, const table_column &col) {
+  if (col.is_function()) {
+    prototype.emplace_back(col.has_alias() ? col.alias() : col.canonical_name());
+    prototype.back().change_type(utils::basic_type::Int32);
+  } else {
+    prototype.emplace_back(col.has_alias() ? col.alias() : col.canonical_name());
+  }
+}
+
 std::string build_constraint(const table_constraint& cons, const sql::dialect& d) {
     std::string result;
     if (!cons.name().empty()) {

source/orm/query/query_utils.cpp

@@ -4,6 +4,18 @@
 #include "matador/query/internal/string_builder_utils.hpp"
 
 namespace matador::query {
+void prepare_column(std::string &out, const sql::dialect &d, const table_column &col) {
+  if (!col.is_function()) {
+    prepare_identifier_string_append(out, col.name(), d);
+  } else {
+    if (col.column_name() == d.asterisk()) {
+      out += d.sql_function_at(col.function()) + "(" + col.column_name() + ")";
+    } else {
+      out += d.sql_function_at(col.function()) + "(" + col.column_name() + ") " + d.as() + " " + col.alias();
+    }
+  }
+}
+
 std::string prepare_identifier(const sql::dialect& d, const table_column& col) {
   std::string result;
   if (!col.is_function()) {

source/orm/sql/dialect.cpp

@@ -271,6 +271,10 @@ const std::string &dialect::remove() const {
   return token_at(dialect_token::Remove);
 }
 
+const std::string & dialect::returning() const {
+  return token_at(dialect_token::Returning);
+}
+
 const std::string &dialect::rollback() const {
   return token_at(dialect_token::Rollback);
 }

source/orm/sql/record.cpp

@@ -7,76 +7,66 @@ namespace matador::sql {
 
 record::record(const std::initializer_list<field> columns) {
   for (auto &&col :columns) {
-    const auto it = fields_by_name_.emplace(col.name(), field_index_pair {col, fields_.size()});
+    index_by_name_.emplace(col.name(), fields_.size());
-    fields_.push_back(std::ref(it.first->second.first));
+    fields_.push_back(col);
   }
 }
 
-record::record(const std::vector<field> &columns) {
+record::record(const std::vector<field> &columns)
-  for (auto &&col :columns) {
+: fields_(columns) {
-    const auto it = fields_by_name_.emplace(col.name(), field_index_pair {col, fields_.size()});
+  for (auto i = 0u; i < columns.size(); ++i) {
-    fields_.push_back(std::ref(it.first->second.first));
+    index_by_name_.emplace(columns[i].name(), i);
   }
 }
 
-record::record(const record &x)
+record &record::operator=(const record &x) {
-: fields_by_name_(x.fields_by_name_)
-{
-  for (auto& col : x.fields_) {
-    auto &it = fields_by_name_.at(col.get().name());
-    fields_.push_back(std::ref(it.first));
-  }
-}
-
-record &record::operator=(const record &x)
-{
   if (&x == this) {
     return *this;
   }
 
-  fields_by_name_ = x.fields_by_name_;
+  fields_ = x.fields_;
-  fields_.clear();
+  index_by_name_ = x.index_by_name_;
-//  pk_index_ = x.pk_index_;
-  for (auto& col : x.fields_) {
-    auto &it = fields_by_name_.at(col.get().name());
-    fields_.push_back(std::ref(it.first));
-  }
   return *this;
 }
 
-const std::vector<record::field_ref> &record::columns() const {
+const std::vector<field> &record::columns() const {
   return fields_;
 }
 
 const field &record::at(const std::string &name) const {
-  const auto &res = fields_by_name_.at(name);
+  const auto it = index_by_name_.find(name);
-  const auto &f = res.first;
+  if (it == index_by_name_.end()) {
-  return f;
+    throw std::out_of_range("Column not found");
+  }
+
+  return fields_[it->second];
 }
 
-const field &record::at(const size_t index) const
+const field &record::at(const size_t index) const {
-{
   return fields_.at(index);
 }
 
 field &record::at(const std::string &name) {
-  auto &[fst, snd] = fields_by_name_.at(name);
+  const auto it = index_by_name_.find(name);
-  return fst;
+  if (it == index_by_name_.end()) {
+    throw std::out_of_range("Column not found");
+  }
+
+  return fields_[it->second];
 }
 
 field &record::at(const size_t index) {
   return fields_.at(index);
 }
 
-record::iterator record::find(const std::string &column_name)
+record::iterator record::find(const std::string &column_name) {
-{
+  const auto it = index_by_name_.find(column_name);
-  auto it = fields_by_name_.find(column_name);
+  return it != index_by_name_.end() ? fields_.begin() + static_cast<long>(it->second) : fields_.end();
-  return it != fields_by_name_.end() ? fields_.begin() + it->second.second : fields_.end();
 }
 
 record::const_iterator record::find(const std::string &column_name) const {
-  auto it = fields_by_name_.find(column_name);
+  const auto it = index_by_name_.find(column_name);
-  return it != fields_by_name_.end() ? fields_.begin() + it->second.second : fields_.end();
+  return it != index_by_name_.end() ? fields_.begin() + static_cast<long>(it->second) : fields_.end();
 }
 
 bool record::operator==(const record &rhs) const {
@@ -95,68 +85,45 @@ bool record::operator!=(const record &rhs) const {
   return !operator==(rhs);
 }
 
-void record::append(const field &col) {
+void record::append(field col) {
-  const auto [fst, snd] = fields_by_name_.emplace(col.name(), field_index_pair {col, fields_.size()});
+  index_by_name_.emplace(col.name(), fields_.size());
-  fields_.push_back(std::ref(fst->second.first));
+  fields_.push_back(std::move(col));
 }
 
-record::iterator record::begin()
+record::iterator record::begin() {
-{
   return fields_.begin();
 }
 
-record::const_iterator record::begin() const
+record::const_iterator record::begin() const {
-{
   return fields_.begin();
 }
 
-record::const_iterator record::cbegin() const
+record::const_iterator record::cbegin() const {
-{
   return fields_.cbegin();
 }
 
-record::iterator record::end()
+record::iterator record::end() {
-{
   return fields_.end();
 }
 
-record::const_iterator record::end() const
+record::const_iterator record::end() const {
-{
   return fields_.end();
 }
 
-record::const_iterator record::cend() const
+record::const_iterator record::cend() const {
-{
   return fields_.cend();
 }
 
-size_t record::size() const
+size_t record::size() const {
-{
   return fields_.size();
 }
 
-bool record::empty() const
+bool record::empty() const {
-{
   return fields_.empty();
 }
 
-void record::clear()
+void record::clear() {
-{
   fields_.clear();
-  fields_by_name_.clear();
+  index_by_name_.clear();
 }
-
-void record::init()
-{
-  size_t index{0};
-  for(auto &col : fields_) {
-    add_to_map(col, index++);
-  }
-}
-
-void record::add_to_map(field &col, size_t index)
-{
-  fields_by_name_.emplace(col.name(), field_index_pair {std::ref(col), index});
-}
-
 }

test/backends/QueryTest.cpp

@@ -87,6 +87,30 @@ TEST_CASE_METHOD(QueryFixture, "Execute select statement with where clause", "[q
   }
 }
 
+TEST_CASE_METHOD(QueryFixture, "Execute insert with returning", "[query][insert][returning]") {
+  REQUIRE(repo.attach<person>("persons"));
+  auto result = repo.create(db);
+  REQUIRE(result.is_ok());
+
+  check_table_exists(PERSON.table_name());
+
+  person george{7, "george", 45};
+  george.image.emplace_back(37);
+
+  auto res = query::insert()
+    .into(PERSON, {PERSON.id, PERSON.name, PERSON.age, PERSON.image})
+    .values(george)
+    .returning(PERSON.id)
+    .fetch_one(db);
+  REQUIRE(res.is_ok());
+
+  auto rec = res.release();
+  REQUIRE(rec->size() == 1);
+  REQUIRE(rec->at(0).name() == "persons.id");
+  REQUIRE(rec->at(0).is_integer());
+  REQUIRE(rec->at(0).as<uint32_t>() == 7);
+}
+
 TEST_CASE_METHOD(QueryFixture, "Execute insert statement", "[query][insert]") {
   auto res = query::create()
     .table("person")

test/utils/record_printer.cpp

@@ -33,22 +33,19 @@ record_printer::record_printer(std::ostream &os)
 }
 
 void record_printer::print_header(const sql::record &rec) const {
-  for (const auto &f_ref: rec.columns()) {
+  for (const auto &f: rec.columns()) {
-    const auto &f = f_ref.get();
     os_ << std::left << std::setw(width(f)) << f.name() << " ";
   }
   os_ << "\n";
 
-  for (const auto &f_ref: rec.columns()) {
+  for (const auto &f: rec.columns()) {
-    const auto &f = f_ref.get();
     os_ << std::string(width(f), '-') << " ";
   }
   os_ << "\n";
 }
 
 void record_printer::print(const sql::record &rec) const {
-  for (const auto &f_ref: rec.columns()) {
+  for (const auto &f: rec.columns()) {
-    const auto &f = f_ref.get();
     os_ << std::left << std::setw(width(f)) << f.str() << " ";
   }
   os_ << "\n";

todo.md

@@ -1,13 +1,25 @@
 # Todo
 
 - move `prepare_*` methods from `dialect` to `query_compiler`
-- add `session_insert_builder` and `session_update_builder` (returning multiple statements)
+- add `insert_query_builder` and `update_update_builder` (returning multiple statements)
 - finish fetch eager many-to-many relations
 - implement lazy loading
 - implement polymorphic class hierarchies
-- finish `schema_repository` classes (move add/drop from `session` to `schema`)
+- finish `database` (schema_repository) class (move add/drop from `session` to `schema`)
 - implement a flag class for enumerations
 
+- PK generator
+1. Introduce execute_context
+2. Introduce execute_result
+3. Add `abstract_pk_generator` class
+4. Add `identity_pk_generator` class
+5. Add `sequence_pk_generator` class
+6. Add `table_pk_generator` class
+7. Add `manual_pk_generator` class 
+8. Extend `session::insert` logic to use pk generator
+9. Extend `postgres_connection::execute` to handle `returning` clause
+10. Add generator to `schema_node` or `table` class when attaching type
+11. Extend `query_builder` and `intermediates` with `returning` intermediate
 
 __Proposal for polymorphic classes:__