startet pk_accessor class

backends/postgres/test/CMakeLists.txt

@@ -37,6 +37,9 @@ set(TEST_SOURCES
   ../../../test/backends/SequenceFixture.hpp
   ../../../test/backends/SequenceFixture.cpp
   ../../../test/backends/SequenceTest.cpp
+  ../../../test/backends/TableSequenceFixture.hpp
+  ../../../test/backends/TableSequenceFixture.cpp
+  ../../../test/backends/TableSequenceTest.cpp
 )
 
 set(LIBRARY_TEST_TARGET PostgresTests)

demo/work/admin/LoginHistory.hpp

@@ -52,6 +52,7 @@ struct LoginHistory : core::Model {
     template<typename Operator>
     void process( Operator& op ) {
         namespace field = matador::access;
+        field::process_base<Model>( op, *this );
         field::process( op, *matador::base_class<Model>( this ) );
         field::belongs_to( op, "client", client, matador::utils::CascadeAllFetchLazy );
         field::belongs_to( op, "scenario", scenario, matador::utils::CascadeAllFetchLazy );

include/matador/query/table_column.hpp

@@ -13,6 +13,7 @@
 namespace matador::query {
 
 class table;
+class column_expression;
 
 // ReSharper disable CppNonExplicitConvertingConstructor
 class table_column {
@@ -35,6 +36,7 @@ public:
 
 
   table_column(const std::shared_ptr<abstract_column_expression>& expression) noexcept;
+  table_column(column_expression&& expression) noexcept;
   table_column& operator=(const table_column& other);
   table_column(const table_column& other) = default;
   table_column(table_column&& other) noexcept = default;

include/matador/utils/access.hpp

@@ -25,6 +25,20 @@ void process(Operator &op, const Type &object) {
   process(op, const_cast<Type &>(object));
 }
 
+template<class Base, class Derived, class Operator>
+void process_base(Operator &op, const Derived &object) {
+  static_assert(!std::is_same_v<Base, Derived>, "class Base must not be of same type as class Derived");
+  static_assert(std::is_base_of_v<Base, Derived>, "class Base must be base of class Derived");
+  process(op, static_cast<const Base&>(object));
+}
+
+template<class Base, class Derived, class Operator>
+void process_base(Operator &op, Derived &object) {
+  static_assert(!std::is_same_v<Base, Derived>, "class Base must not be of same type as class Derived");
+  static_assert(std::is_base_of_v<Base, Derived>, "class Base must be base of class Derived");
+  process(op, static_cast<Base&>(object));
+}
+
 template< class Operator, class Type >
 void primary_key(Operator &op, const char *id, Type &value, const utils::primary_key_attribute &attr) {
   op.on_primary_key(id, value, attr);

include/matador/utils/base_class.hpp

@@ -8,33 +8,31 @@ namespace matador {
 /**
  * @brief Safely casts a given derived class to its base class
  *
- * @tparam B The base class type
- * @tparam D The class type of the derived class
+ * @tparam Base The base class type
+ * @tparam Derived The class type of the derived class
  * @param derived The derived object
  * @return The cast object
  */
-template < class B, class D>
-const B* base_class(const D *derived)
-{
-  static_assert(!std::is_same_v<B, D>, "class B must not be of same type as class D");
-  static_assert(std::is_base_of_v<B, D>, "class B must be base of class D");
-  return static_cast<const B*>(derived);
+template < class Base, class Derived>
+const Base* base_class(const Derived *derived) {
+  static_assert(!std::is_same_v<Base, Derived>, "class Base must not be of same type as class Derived");
+  static_assert(std::is_base_of_v<Base, Derived>, "class Base must be base of class Derived");
+  return static_cast<const Base*>(derived);
 }
 
 /**
  * @brief Safely casts a given derived class to its base class
  *
- * @tparam B The base class type
- * @tparam D The class type of the derived class
+ * @tparam Base The base class type
+ * @tparam Derived The class type of the derived class
  * @param derived The derived object
  * @return The cast object
  */
-template < class B, class D>
-B* base_class(D *derived)
-{
-  static_assert(!std::is_same_v<B, D>, "class B must not be of same type as class D");
-  static_assert(std::is_base_of_v<B, D>, "class B must be base of class D");
-  return static_cast<B*>(derived);
+template < class Base, class Derived>
+Base* base_class(Derived *derived) {
+  static_assert(!std::is_same_v<Base, Derived>, "class Base must not be of same type as class Derived");
+  static_assert(std::is_base_of_v<Base, Derived>, "class Base must be base of class Derived");
+  return static_cast<Base*>(derived);
 }
 
 }

include/matador/utils/primary_key_accessor.hpp

@@ -0,0 +1,105 @@
+#ifndef MATADOR_PRIMARY_KEY_ACCESSOR_HPP
+#define MATADOR_PRIMARY_KEY_ACCESSOR_HPP
+
+#include "matador/utils/field_attributes.hpp"
+#include "matador/utils/primary_key_attribute.hpp"
+
+#include <cstdint>
+#include <string>
+
+namespace matador::utils {
+class foreign_attributes;
+namespace detail {
+template < typename PrimaryKeyType >
+class primary_key_setter {
+public:
+  explicit primary_key_setter(const std::string &name, const PrimaryKeyType& value)
+  : name_(name)
+  , value_(value){}
+
+  void on_primary_key(const char *id, PrimaryKeyType &pk, const utils::primary_key_attribute & = utils::default_pk_attributes) {
+    if (id != nullptr && name_ == id) {
+      pk = static_cast<PrimaryKeyType>(value_);
+    }
+  }
+  template<typename ValueType>
+  static void on_primary_key(const char * /*id*/, ValueType & /*pk*/, const utils::primary_key_attribute & = utils::default_pk_attributes) {}
+  static void on_revision(const char * /*id*/, uint64_t & /*rev*/) {}
+  template<typename T>
+  static void on_attribute(const char * /*id*/, T &, const utils::field_attributes & = utils::null_attributes) {}
+  template<class P>
+  static void on_belongs_to(const char * /*id*/, P &, const utils::foreign_attributes & ) {}
+  template<class P>
+  static void on_has_one(const char * /*id*/, P &, const utils::foreign_attributes & ) {}
+  template<class C>
+  static void on_has_many(const char * /*id*/, C &, const char * /*join_column*/, const utils::foreign_attributes & ) {}
+  template<class C>
+  static void on_has_many_to_many(const char * /*id*/, C &, const char * /*join_column*/, const char * /*inverse_join_column*/, const utils::foreign_attributes & ) {}
+  template<class C>
+  static void on_has_many_to_many(const char * /*id*/, C &, const utils::foreign_attributes & ) {}
+
+private:
+  const std::string &name_;
+  PrimaryKeyType value_{};
+};
+
+struct pk_unset_checker {
+  const std::string &name;
+  bool unset{true};
+
+  template<class V>
+  void on_primary_key(const char *id, V &pk, const utils::primary_key_attribute & = utils::default_pk_attributes) {
+    if (id != nullptr && name == id) {
+      // Your convention: 0 means unset for integer PKs
+      unset = (static_cast<std::uint64_t>(pk) == 0ULL);
+    }
+  }
+  static void on_revision(const char * /*id*/, uint64_t & /*rev*/) {}
+  template<typename T>
+  static void on_attribute(const char * /*id*/, T &, const utils::field_attributes & = utils::null_attributes) {}
+  template<class P>
+  static void on_belongs_to(const char * /*id*/, P &, const utils::foreign_attributes & ) {}
+  template<class P>
+  static void on_has_one(const char * /*id*/, P &, const utils::foreign_attributes & ) {}
+  template<class C>
+  static void on_has_many(const char * /*id*/, C &, const char * /*join_column*/, const utils::foreign_attributes & ) {}
+  template<class C>
+  static void on_has_many_to_many(const char * /*id*/, C &, const char * /*join_column*/, const char * /*inverse_join_column*/, const utils::foreign_attributes & ) {}
+  template<class C>
+  static void on_has_many_to_many(const char * /*id*/, C &, const utils::foreign_attributes & ) {}
+};
+
+struct pk_value_extractor {
+  std::uint64_t value{0};
+
+  template<class V>
+  void on_primary_key(const char * /*id*/, V &pk, const utils::primary_key_attribute & = utils::default_pk_attributes) {
+    value = static_cast<std::uint64_t>(pk);
+  }
+  static void on_revision(const char * /*id*/, uint64_t & /*rev*/) {}
+  template<typename T>
+  static void on_attribute(const char * /*id*/, T &, const utils::field_attributes & = utils::null_attributes) {}
+  template<class P>
+  static void on_belongs_to(const char * /*id*/, P &, const utils::foreign_attributes & ) {}
+  template<class P>
+  static void on_has_one(const char * /*id*/, P &, const utils::foreign_attributes & ) {}
+  template<class C>
+  static void on_has_many(const char * /*id*/, C &, const char * /*join_column*/, const utils::foreign_attributes & ) {}
+  template<class C>
+  static void on_has_many_to_many(const char * /*id*/, C &, const char * /*join_column*/, const char * /*inverse_join_column*/, const utils::foreign_attributes & ) {}
+  template<class C>
+  static void on_has_many_to_many(const char * /*id*/, C &, const utils::foreign_attributes & ) {}
+};
+
+}
+
+template<typename PrimaryKeyType>
+class primary_key_accessor {
+public:
+
+  PrimaryKeyType get() const;
+  PrimaryKeyType
+};
+}
+
+#endif //MATADOR_PRIMARY_KEY_ACCESSOR_HPP

source/core/CMakeLists.txt

@@ -124,6 +124,7 @@ add_library(matador-core STATIC
   object/collection_utils.cpp
   ../../include/matador/object/pk_field_locator.hpp
   ../../include/matador/object/object_cache.hpp
+  ../../include/matador/utils/primary_key_accessor.hpp
 )
 
 target_link_libraries(matador-core ${CMAKE_DL_LIBS})

source/orm/query/query_builder.cpp

@@ -17,16 +17,15 @@
 #include "matador/sql/dialect.hpp"
 
 namespace matador::query {
-
-sql::query_context query_builder::compile(const query_data &data,
-                                           const sql::dialect &d,
-                                           const std::optional<std::reference_wrapper<const sql::connection_impl>> conn)
-{
+sql::query_context query_builder::compile(const query_data& data,
+                                          const sql::dialect& d,
+                                          const std::optional<std::reference_wrapper<const sql::connection_impl>>
+                                          conn) {
   data_ = &data;
   dialect_ = &d;
   connection_ = conn;
   query_ = {};
-  for (const auto &part: data.parts) {
+  for (const auto& part : data.parts) {
     part->accept(*this);
   }
   finisher_(query_);
@@ -37,10 +36,10 @@ sql::query_context query_builder::compile(const query_data &data,
   return {query_};
 }
 
-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 build_fetchable_columns(sql::query_context &ctx, const std::vector<table_column> &cols, const sql::dialect &d);
-void prepare_prototype(std::vector<object::attribute> &prototype, const table_column &col);
+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 build_fetchable_columns(sql::query_context& ctx, const std::vector<table_column>& cols, const sql::dialect& d);
+void prepare_prototype(std::vector<object::attribute>& prototype, const table_column& col);
 
 void query_builder::visit(internal::query_alter_part& part) {
   query_.sql = dialect_->token_at(part.token());
@@ -74,7 +73,7 @@ void query_builder::visit(internal::query_add_foreign_key_reference_part& part)
   query_.sql += ")";
 }
 
-void query_builder::visit(internal::query_add_constraint_part_by_constraint &part) {
+void query_builder::visit(internal::query_add_constraint_part_by_constraint& part) {
   query_.sql += build_add_constraint_string(part.constraint());
 }
 
@@ -86,7 +85,7 @@ void query_builder::visit(internal::query_drop_key_constraint_part_by_constraint
   query_.sql += " " + build_drop_constraint_string(part.constraint());
 }
 
-void query_builder::visit(internal::query_select_part &part) {
+void query_builder::visit(internal::query_select_part& part) {
   query_.command = sql::sql_command::Select;
   query_.sql = dialect_->select() + " ";
 
@@ -109,11 +108,11 @@ void query_builder::visit(internal::query_select_currval_part& part) {
   prepare_prototype(query_.prototype, part.sequence_name());
 }
 
-void query_builder::visit(internal::query_from_part &part) {
+void query_builder::visit(internal::query_from_part& part) {
   query_.table_name = part.tables().front().name();
   query_.sql += " " + dialect_->from() + " ";
-  if (const auto &tables = part.tables(); tables.size() < 2) {
-    for (const auto &tab: tables) {
+  if (const auto& tables = part.tables(); tables.size() < 2) {
+    for (const auto& tab : tables) {
       query_.sql += build_table_name(*dialect_, tab);
     }
   } else {
@@ -126,30 +125,30 @@ void query_builder::visit(internal::query_from_part &part) {
   }
 }
 
-void query_builder::visit(internal::query_join_table_part &part) {
+void query_builder::visit(internal::query_join_table_part& part) {
   query_.sql += " " + build_table_name(part.token(), *dialect_, part.table());
 }
 
-void query_builder::visit(internal::query_join_query_part &part) {
+void query_builder::visit(internal::query_join_query_part& part) {
   query_.sql += " " + dialect_->join() + " (" + part.query().str(*dialect_) + ")";
 }
 
-void query_builder::visit(internal::query_on_part &part) {
+void query_builder::visit(internal::query_on_part& part) {
   criteria_evaluator evaluator(*dialect_, query_);
   query_.sql += " " + dialect_->on() +
     " " + evaluator.evaluate(part.condition());
 }
 
-void query_builder::visit(internal::query_where_part &part) {
+void query_builder::visit(internal::query_where_part& part) {
   criteria_evaluator evaluator(*dialect_, query_);
   query_.sql += " " + dialect_->where() +
     " " + evaluator.evaluate(part.condition());
 }
 
-void query_builder::visit(internal::query_group_by_part &part) {
+void query_builder::visit(internal::query_group_by_part& part) {
   query_.sql += " " + dialect_->group_by() + " ";
   if (part.columns().size() < 2) {
-    for (const auto &col: part.columns()) {
+    for (const auto& col : part.columns()) {
       query_.sql.append(dialect_->prepare_identifier_string(col.name()));
     }
   } else {
@@ -162,10 +161,10 @@ void query_builder::visit(internal::query_group_by_part &part) {
   }
 }
 
-void query_builder::visit(internal::query_order_by_part &part) {
+void query_builder::visit(internal::query_order_by_part& part) {
   query_.sql += " " + dialect_->order_by() + " ";
   if (part.columns().size() < 2) {
-    for (const auto &col: part.columns()) {
+    for (const auto& col : part.columns()) {
       query_.sql.append(dialect_->prepare_identifier_string(col.canonical_name()));
     }
   } else {
@@ -178,28 +177,28 @@ void query_builder::visit(internal::query_order_by_part &part) {
   }
 }
 
-void query_builder::visit(internal::query_order_by_asc_part &/*order_by_asc_part*/) {
+void query_builder::visit(internal::query_order_by_asc_part&/*order_by_asc_part*/) {
   query_.sql += " " + dialect_->asc();
 }
 
-void query_builder::visit(internal::query_order_by_desc_part &/*order_by_desc_part*/) {
+void query_builder::visit(internal::query_order_by_desc_part&/*order_by_desc_part*/) {
   query_.sql += " " + dialect_->desc();
 }
 
-void query_builder::visit(internal::query_offset_part &part) {
+void query_builder::visit(internal::query_offset_part& part) {
   query_.sql += " " + dialect_->offset() + " " + std::to_string(part.offset());
 }
 
-void query_builder::visit(internal::query_limit_part &part) {
+void query_builder::visit(internal::query_limit_part& part) {
   query_.sql += " " + dialect_->limit() + " " + std::to_string(part.limit());
 }
 
-void query_builder::visit(internal::query_insert_part &/*insert_part*/) {
+void query_builder::visit(internal::query_insert_part&/*insert_part*/) {
   query_.command = sql::sql_command::Insert;
   query_.sql = dialect_->insert();
 }
 
-void query_builder::visit(internal::query_into_part &part) {
+void query_builder::visit(internal::query_into_part& part) {
   query_.table_name = part.table().name();
   query_.sql += " " + dialect_->into() +
     " " + dialect_->prepare_identifier_string(part.table().name()) + " (";
@@ -208,23 +207,28 @@ void query_builder::visit(internal::query_into_part &part) {
   query_.sql += ")"/* + result*/;
 }
 
-struct value_visitor {
-  value_visitor(attribute_string_writer &w, sql::query_context &ctx)
-  : value_to_string_visitor(w, ctx) {}
-
-  void operator()(const utils::database_type &val) {
-    std::visit(value_to_string_visitor, val);
-
+struct value_visitor
+{
+  value_visitor(attribute_string_writer& w, sql::query_context& ctx)
+  : value_to_string_visitor(w, ctx) {
   }
-  void operator()(const utils::placeholder &/*val*/) {
-    value_to_string_visitor.query.bind_vars.emplace_back(std::string("value_") + std::to_string(value_to_string_visitor.query.bind_vars.size() + 1));
-    value_to_string_visitor.result = value_to_string_visitor.writer->dialect().next_placeholder(value_to_string_visitor.query.bind_vars);
+
+  void operator()(const utils::database_type& val) {
+    std::visit(value_to_string_visitor, val);
+  }
+
+  void operator()(const utils::placeholder&/*val*/) {
+    value_to_string_visitor.query.bind_vars.emplace_back(
+      std::string("value_") + std::to_string(value_to_string_visitor.query.bind_vars.size() + 1));
+    value_to_string_visitor.result = value_to_string_visitor.writer->dialect().next_placeholder(
+      value_to_string_visitor.query.bind_vars);
   }
 
   internal::basic_type_to_string_visitor value_to_string_visitor;
 };
 
-std::string query_builder::determine_value(const sql::dialect &d, sql::query_context& ctx, const abstract_column_expression &exp) {
+std::string query_builder::determine_value(const sql::dialect& d, sql::query_context& ctx,
+                                           const abstract_column_expression& exp) {
   attribute_string_writer writer(d, {});
   expression_evaluator v(d, ctx);
   exp.accept(v);
@@ -232,12 +236,13 @@ std::string query_builder::determine_value(const sql::dialect &d, sql::query_con
   return v.result();
 }
 
-std::string query_builder::determine_value(value_visitor &visitor, const std::variant<utils::placeholder, utils::database_type> &val) {
+std::string query_builder::determine_value(value_visitor& visitor,
+                                           const std::variant<utils::placeholder, utils::database_type>& val) {
   std::visit(visitor, val);
   return visitor.value_to_string_visitor.result;
 }
 
-void query_builder::visit(internal::query_values_part &part) {
+void query_builder::visit(internal::query_values_part& part) {
   query_.sql += " " + dialect_->values();
 
   attribute_string_writer writer(*dialect_, connection_);
@@ -245,7 +250,7 @@ void query_builder::visit(internal::query_values_part &part) {
   value_visitor visitor(writer, query_);
   std::string result{"("};
   if (part.values().size() < 2) {
-    for (const auto& val: part.values()) {
+    for (const auto& val : part.values()) {
       result.append(determine_value(visitor, val));
     }
   } else {
@@ -263,45 +268,42 @@ void query_builder::visit(internal::query_values_part &part) {
   query_.sql += " " + result;
 }
 
-void query_builder::visit(internal::query_returning_part &part) {
+void query_builder::visit(internal::query_returning_part& part) {
   query_.mode = sql::return_mode::Rows;
   query_.sql += " " + dialect_->returning() + " ";
 
   build_fetchable_columns(query_, part.columns(), *dialect_);
 }
 
-void query_builder::visit(internal::query_update_part &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*/) {
+void query_builder::visit(internal::query_delete_part&/*delete_part*/) {
   query_.command = sql::sql_command::Delete;
   query_.sql = dialect_->remove();
 }
 
-void query_builder::visit(internal::query_delete_from_part &part)
-{
+void query_builder::visit(internal::query_delete_from_part& part) {
   query_.table_name = part.table().name();
   query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name);
 }
 
-void query_builder::visit(internal::query_create_part &/*create_part*/)
-{
+void query_builder::visit(internal::query_create_part&/*create_part*/) {
   query_.command = sql::sql_command::CreateTable;
   query_.sql = dialect_->create();
 }
 
-void build_create_column(std::string &out, const table_column &col, const sql::dialect &d);
-std::string build_constraint(const table_constraint &cons, const sql::dialect &d);
+void build_create_column(std::string& out, const table_column& col, const sql::dialect& d);
+std::string build_constraint(const table_constraint& cons, const sql::dialect& d);
 
-void query_builder::visit(internal::query_create_table_part &part)
-{
+void query_builder::visit(internal::query_create_table_part& part) {
   query_.sql += " " + dialect_->table() + " " + dialect_->prepare_identifier_string(part.table().name()) + " (";
   query_.table_name = part.table().name();
 
-  finisher_ = [](sql::query_context &ctx) { ctx.sql += ")"; };
+  finisher_ = [](sql::query_context& ctx) { ctx.sql += ")"; };
 }
 
 void query_builder::visit(internal::query_create_table_columns_part& part) {
@@ -329,22 +331,22 @@ void query_builder::visit(internal::query_create_sequence_part& part) {
   query_.sql += " " + dialect_->sequence() + " " + dialect_->prepare_identifier_string(part.sequence_name());
 }
 
-void query_builder::visit( internal::query_create_schema_part& part ) {
+void query_builder::visit(internal::query_create_schema_part& part) {
   query_.command = sql::sql_command::CreateSchema;
   query_.sql += " " + dialect_->schema() + " " + dialect_->prepare_identifier_string(part.schema());
 }
 
-void query_builder::visit(internal::query_drop_part &part) {
+void query_builder::visit(internal::query_drop_part& part) {
   query_.command = sql::sql_command::DropTable;
   query_.sql = dialect_->token_at(part.token());
 }
 
-void query_builder::visit( internal::query_drop_schema_part& part ) {
+void query_builder::visit(internal::query_drop_schema_part& part) {
   query_.sql += " " + dialect_->drop() + " " +
     dialect_->schema() + " " + dialect_->prepare_identifier_string(part.schema());
 }
 
-void query_builder::visit(internal::query_set_part &part) {
+void query_builder::visit(internal::query_set_part& part) {
   query_.sql += " " + dialect_->set() + " ";
 
   attribute_string_writer writer(*dialect_, connection_);
@@ -357,7 +359,7 @@ void query_builder::visit(internal::query_set_part &part) {
       query_.sql.append(", ");
     }
     query_.sql.append(dialect_->prepare_identifier_string(column_value.col().name()) + "=");
-    query_.sql.append(determine_value(*dialect_,query_, column_value.expression()));
+    query_.sql.append(determine_value(*dialect_, query_, column_value.expression()));
     first = false;
   }
 
@@ -385,12 +387,12 @@ void query_builder::visit(internal::query_drop_sequence_part& part) {
   query_.sql += " " + dialect_->sequence() + " " + dialect_->prepare_identifier_string(part.sequence_name());
 }
 
-void query_builder::visit(internal::query_drop_table_part &part) {
+void query_builder::visit(internal::query_drop_table_part& part) {
   query_.table_name = part.table().name();
   query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name);
 }
 
-void build_create_column(std::string &out, const table_column &col, const sql::dialect &d) {
+void build_create_column(std::string& out, const table_column& col, const sql::dialect& d) {
   prepare_identifier_string_append(out, col.canonical_name(), d);
   out += " " + d.data_type_at(col.type());
   if (col.attributes().size() > 0) {
@@ -410,7 +412,7 @@ void build_create_column(std::string &out, const table_column &col, const sql::d
   }
 }
 
-void build_columns_with_name_only(std::string &out, const std::vector<table_column> &cols,  const sql::dialect &d) {
+void build_columns_with_name_only(std::string& out, const std::vector<table_column>& cols, const sql::dialect& d) {
   bool first = true;
   for (const auto& col : cols) {
     if (!first) {
@@ -421,7 +423,7 @@ void build_columns_with_name_only(std::string &out, const std::vector<table_colu
   }
 }
 
-void build_columns(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) {
   bool first = true;
   for (const auto& col : cols) {
     if (!first) {
@@ -432,7 +434,7 @@ 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) {
+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) {
@@ -444,7 +446,7 @@ void build_fetchable_columns(sql::query_context &ctx, const std::vector<table_co
   }
 }
 
-void prepare_prototype(std::vector<object::attribute> &prototype, const table_column &col) {
+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);
@@ -481,33 +483,35 @@ std::string build_constraint(const table_constraint& cons, const sql::dialect& d
   return result;
 }
 
-std::string query_builder::build_table_name(const sql::dialect_token token, const sql::dialect &d, const table& t) {
+std::string query_builder::build_table_name(const sql::dialect_token token, const sql::dialect& d, const table& t) {
   return d.token_at(token) + " " + build_table_name(d, t);
 }
 
-std::string query_builder::build_table_name(const sql::dialect &d, const table& t) {
+std::string query_builder::build_table_name(const sql::dialect& d, const table& t) {
   return (!d.default_schema_name().empty() ? d.prepare_identifier_string(d.default_schema_name()) + "." : "") +
     d.prepare_identifier_string(t.table_name()) +
     (!t.has_alias() ? "" : " " + d.prepare_identifier_string(t.name()));
 }
 
-std::string query_builder::build_add_constraint_string(const table_constraint &c) const {
+std::string query_builder::build_add_constraint_string(const table_constraint& c) const {
   std::string result = " " + dialect_->add_constraint() + " " + build_constraint_name(c) + " ";
   if (c.is_primary_key_constraint()) {
     result.append(dialect_->primary_key()).append(" (").append(c.column_name()).append(")");
   } else if (c.is_foreign_key_constraint()) {
-    result.append(dialect_->foreign_key()).append(" (").append(c.column_name()).append(") ").append(dialect_->references()).append(" ").append(c.referenced_table()).append(" (").append(c.referenced_column()).append(")");
+    result.append(dialect_->foreign_key()).append(" (").append(c.column_name()).append(") ").
+           append(dialect_->references()).append(" ").append(c.referenced_table()).append(" (").append(
+             c.referenced_column()).append(")");
   } else if (c.is_unique_constraint()) {
     result.append(dialect_->unique()).append(" (").append(c.column_name()).append(")");
   }
   return result;
 }
 
-std::string query_builder::build_drop_constraint_string(const table_constraint &c) const {
+std::string query_builder::build_drop_constraint_string(const table_constraint& c) const {
   return dialect_->drop_constraint() + " " + build_constraint_name(c);
 }
 
-std::string query_builder::build_constraint_name(const table_constraint &c) {
+std::string query_builder::build_constraint_name(const table_constraint& c) {
   if (c.is_primary_key_constraint()) {
     return "PK_" + c.table_name();
   }

source/orm/query/query_utils.cpp

@@ -15,6 +15,7 @@ void prepare_column(sql::query_context& ctx, const sql::dialect& d, const table_
         attribute_string_writer writer(d, {});
         expression_evaluator v(d, ctx);
         col.expression()->accept(v);
+      ctx.sql += v.result();
 
         if (col.has_alias()) {
             ctx.sql.append(" ").append(d.as()).append(" ").append(col.alias());

source/orm/query/table_column.cpp

@@ -5,6 +5,8 @@
 #include <stdexcept>
 #include <utility>
 
+#include "matador/query/expression/column_expression.hpp"
+
 namespace matador::query {
 
 table_column operator ""_col(const char *name, const size_t len) {
@@ -67,6 +69,10 @@ table_column::table_column(const class table* tab,
 table_column::table_column(const std::shared_ptr<abstract_column_expression>& expression) noexcept
 : table_column(nullptr, "", "", utils::basic_type::Unknown, {}, sql::sql_function_t::None, expression) {}
 
+table_column::table_column(column_expression&& expression) noexcept
+: table_column(std::shared_ptr(expression.release())) {
+}
+
 table_column & table_column::operator=(const table_column &other) {
   if (this == &other) {
     return *this;
@@ -95,7 +101,7 @@ bool table_column::equals(const table_column &x) const {
 }
 
 table_column table_column::as(const std::string& alias) const {
-  return {table_, column_name_, alias, type_, attributes_, function_};
+  return {table_, column_name_, alias, type_, attributes_, function_, expression_};
 }
 
 const std::string& table_column::name() const {

test/backends/SequenceFixture.hpp

@@ -1,8 +1,6 @@
 #ifndef MATADOR_SEQUENCE_FIXTURE_HPP
 #define MATADOR_SEQUENCE_FIXTURE_HPP
 
-#include "matador/query/schema.hpp"
-
 #include "matador/sql/connection.hpp"
 
 #include <stack>

test/backends/TableSequenceFixture.cpp

@@ -0,0 +1,30 @@
+#include "TableSequenceFixture.hpp"
+
+#include "matador/query/query.hpp"
+#include "matador/query/builder.hpp"
+
+#include "connection.hpp"
+
+#include "catch2/catch_test_macros.hpp"
+
+namespace matador::test {
+TableSequenceFixture::TableSequenceFixture()
+: db(connection::dns) {
+  REQUIRE(db.open());
+
+  REQUIRE(query::query::create()
+    .table(sequence_table_name)
+    .columns({
+      query::column("name", utils::basic_type::Varchar, 255),
+      query::column("next_id", utils::basic_type::Int64)
+    })
+    .execute(db));
+}
+
+TableSequenceFixture::~TableSequenceFixture() {
+  REQUIRE(query::query::drop()
+    .table(sequence_table_name)
+    .execute(db));
+  REQUIRE(db.close());
+}
+}

test/backends/TableSequenceFixture.hpp

@@ -0,0 +1,18 @@
+#ifndef MATADOR_TABLE_SEQUENCE_FIXTURE_HPP
+#define MATADOR_TABLE_SEQUENCE_FIXTURE_HPP
+
+#include "matador/sql/connection.hpp"
+
+namespace matador::test {
+class TableSequenceFixture {
+public:
+  TableSequenceFixture();
+  ~TableSequenceFixture();
+
+protected:
+  sql::connection db;
+  std::string sequence_table_name{"test_seq_table"};
+};
+}
+
+#endif //MATADOR_TABLE_SEQUENCE_FIXTURE_HPP

test/backends/TableSequenceTest.cpp

@@ -0,0 +1,40 @@
+#include "catch2/catch_test_macros.hpp"
+
+#include "matador/query/criteria.hpp"
+#include "matador/query/expression/expression_operators.hpp"
+#include "matador/query/query.hpp"
+#include "matador/query/table_column.hpp"
+
+#include "TableSequenceFixture.hpp"
+
+using namespace matador::query;
+using namespace matador::test;
+
+TEST_CASE_METHOD(TableSequenceFixture, "test create and drop table sequence", "[table_sequence][create][drop]") {
+  const auto next_id_col = "next_id"_col;
+  auto result = query::query::insert()
+    .into(sequence_table_name, { "name", next_id_col})
+    .values({ "test_seq", 1 })
+    .execute(db);
+  REQUIRE(result);
+  REQUIRE(result->affected_rows == 1);
+
+  table_column exp(next_id_col - 1);
+  auto id_result = query::query::update(sequence_table_name)
+    .set(next_id_col, next_id_col + 1)
+    .where("name"_col == "test_seq")
+    .returning((next_id_col - 1).as("id"))
+    .fetch_value<int64_t>(db);
+
+  REQUIRE(id_result);
+  REQUIRE(id_result->has_value());
+  REQUIRE(id_result->value() == 1);
+
+  id_result = query::query::select({next_id_col})
+    .from(sequence_table_name)
+    .where("name"_col == "test_seq")
+    .fetch_value<int64_t>(db);
+  REQUIRE(id_result);
+  REQUIRE(id_result->has_value());
+  REQUIRE(id_result->value() == 2);
+}