added timestamp code, support columns for group by and order by and tested load has-many eager code

source/core/object/attribute.cpp

@@ -85,6 +85,10 @@ bool attribute::is_time() const {
   return type_ == utils::basic_type::Time;
 }
 
+bool attribute::is_timestamp() const {
+  return type_ == utils::basic_type::DateTime;
+}
+
 bool attribute::is_blob() const {
   return type_ == utils::basic_type::Blob;
 }

source/core/utils/identifier.cpp

@@ -9,63 +9,58 @@ size_t detail::hash(const char *value) {
   return std::hash<std::string_view>()(std::string_view(value, std::strlen(value)));
 }
 
-bool identifier_type_traits<const char*>::is_valid(const char *value) {
+bool identifier_type_traits<const char *>::is_valid(const char *value) {
   return value != nullptr && strlen(value) > 0;
 }
 
-std::string identifier_type_traits<const char*>::to_string(const char *value) {
+std::string identifier_type_traits<const char *>::to_string(const char *value) {
   return value;
 }
 
 identifier::base::base(const std::type_index &ti, const basic_type type)
-  : type_index_(ti)
-  , type_(type)
-{}
+: type_index_(ti)
+  , type_(type) {
+}
 
 identifier::null_pk::null_pk()
-  : base(std::type_index(typeid(null_type_t)), basic_type::Null)
-{}
+: base(std::type_index(typeid(null_type_t)), basic_type::Null) {
+}
 
-identifier::base* identifier::null_pk::copy() const
-{
+identifier::base *identifier::null_pk::copy() const {
   return new null_pk;
 }
 
-bool identifier::null_pk::equal_to(const base &x) const
-{
+bool identifier::null_pk::equal_to(const base &x) const {
   return type_index_ == x.type_index_;
 }
 
-bool identifier::null_pk::less(const base &x) const
-{
+bool identifier::null_pk::less(const base &x) const {
   return type_index_ == x.type_index_;
 }
 
-bool identifier::null_pk::is_valid() const
-{
+bool identifier::null_pk::is_valid() const {
   return identifier_type_traits<null_type_t>::is_valid();
 }
 
-std::string identifier::null_pk::str() const
-{
+std::string identifier::null_pk::str() const {
   return identifier_type_traits<null_type_t>::to_string();
 }
 
-void identifier::null_pk::serialize(identifier_serializer &s)
-{
+void identifier::null_pk::serialize(identifier_serializer &s) {
   s.serialize(null_, {});
 }
 
-size_t identifier::null_pk::hash() const
-{
+size_t identifier::null_pk::hash() const {
   return std::hash<nullptr_t>()(nullptr);
 }
 
 identifier::identifier()
-: id_(std::make_shared<null_pk>()) {}
+: id_(std::make_shared<null_pk>()) {
+}
 
 identifier::identifier(const identifier &x)
-: id_(x.id_->copy()) {}
+: id_(x.id_->copy()) {
+}
 
 identifier &identifier::operator=(const identifier &x) {
   if (this == &x) {
@@ -123,13 +118,11 @@ basic_type identifier::type() const {
   return id_->type_;
 }
 
-identifier identifier::share() const
-{
+identifier identifier::share() const {
   return identifier(id_);
 }
 
-size_t identifier::use_count() const
-{
+size_t identifier::use_count() const {
   return id_.use_count();
 }
 
@@ -157,22 +150,23 @@ bool identifier::is_time() const {
   return id_->type_ == basic_type::Time;
 }
 
+bool identifier::is_timestamp() const {
+  return id_->type_ == basic_type::DateTime;
+}
+
 bool identifier::is_blob() const {
   return id_->type_ == basic_type::Blob;
 }
 
-bool identifier::is_null() const
-{
+bool identifier::is_null() const {
   return type_index() == null_identifier.type_index();
 }
 
-bool identifier::is_valid() const
-{
+bool identifier::is_valid() const {
   return id_->is_valid();
 }
 
-void identifier::clear()
-{
+void identifier::clear() {
   id_ = std::make_unique<null_pk>();
 }
 
@@ -180,24 +174,20 @@ void identifier::serialize(identifier_serializer &s) const {
   id_->serialize(s);
 }
 
-size_t identifier::hash() const
-{
+size_t identifier::hash() const {
   return id_->hash();
 }
 
 identifier::identifier(const std::shared_ptr<base> &id)
-  : id_(id)
-{}
+: id_(id) {
+}
 
-std::ostream &operator<<(std::ostream &out, const identifier &id)
-{
+std::ostream &operator<<(std::ostream &out, const identifier &id) {
   out << id.str();
   return out;
 }
 
-size_t id_pk_hash::operator()(const identifier &id) const
-{
+size_t id_pk_hash::operator()(const identifier &id) const {
   return id.hash();
 }
-
-}
+}

source/core/utils/value.cpp

@@ -84,6 +84,10 @@ bool value::is_time() const {
   return type_ == basic_type::Time;
 }
 
+bool value::is_timestamp() const {
+  return type_ == basic_type::DateTime;
+}
+
 bool value::is_blob() const {
   return type_ == basic_type::Blob;
 }

source/orm/query/intermediates/query_create_intermediate.cpp

@@ -79,4 +79,13 @@ query_create_table_columns_intermediate query_create_table_intermediate::columns
 
   return {context_};
 }
+
+query_create_table_columns_intermediate query_create_table_intermediate::columns(const std::vector<table_column> &columns) {
+  std::list<table_column> cols;
+  for (const auto &col : columns) {
+    cols.emplace_back(col);
+  }
+
+  return this->columns(cols);
+}
 }

source/orm/query/intermediates/query_execute_where_intermediate.cpp

@@ -13,8 +13,11 @@ query_execute_limit_intermediate query_execute_where_intermediate::limit(size_t
 }
 
 query_execute_order_by_intermediate query_execute_where_intermediate::order_by(const table_column &col) {
-  context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
-  return {context_};
+  return order_by({col});
 }
 
+query_execute_order_by_intermediate query_execute_where_intermediate::order_by(std::initializer_list<table_column> columns) {
+  context_->parts.push_back(std::make_unique<internal::query_order_by_part>(columns));
+  return {context_};
+}
 }

source/orm/query/intermediates/query_from_intermediate.cpp

@@ -38,13 +38,21 @@ query_where_intermediate query_from_intermediate::where_clause(std::unique_ptr<a
   return {context_};
 }
 
-query_group_by_intermediate query_from_intermediate::group_by(const table_column &col) {
-  context_->parts.push_back(std::make_unique<internal::query_group_by_part>(col));
+query_group_by_intermediate query_from_intermediate::group_by(const table_column &column) {
+  return group_by({column});
+}
+
+query_group_by_intermediate query_from_intermediate::group_by(std::initializer_list<table_column> columns) {
+  context_->parts.push_back(std::make_unique<internal::query_group_by_part>(columns));
   return {context_};
 }
 
 query_order_by_intermediate query_from_intermediate::order_by(const table_column &col) {
-  context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
+  return order_by({col});
+}
+
+query_order_by_intermediate query_from_intermediate::order_by(std::initializer_list<table_column> columns) {
+  context_->parts.push_back(std::make_unique<internal::query_order_by_part>(columns));
   return {context_};
 }
 

source/orm/query/intermediates/query_group_by_intermediate.cpp

@@ -6,8 +6,11 @@
 namespace matador::query {
 
 query_order_by_intermediate query_group_by_intermediate::order_by(const table_column &col) {
-  context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
-  return {context_};
+  return order_by({col});
 }
 
-}
+query_order_by_intermediate query_group_by_intermediate::order_by(std::initializer_list<table_column> columns) {
+  context_->parts.push_back(std::make_unique<internal::query_order_by_part>(columns));
+  return {context_};
+}
+}

source/orm/query/intermediates/query_where_intermediate.cpp

@@ -5,15 +5,23 @@
 #include "matador/query/internal/query_parts.hpp"
 
 namespace matador::query {
+query_group_by_intermediate query_where_intermediate::group_by(const table_column &column) {
+  return group_by({column});
+}
 
-query_group_by_intermediate query_where_intermediate::group_by(const table_column &col) {
-  context_->parts.push_back(std::make_unique<internal::query_group_by_part>(col));
+query_group_by_intermediate query_where_intermediate::group_by(std::initializer_list<table_column> columns) {
+  context_->parts.push_back(std::make_unique<internal::query_group_by_part>(columns));
   return {context_};
 }
 
 query_order_by_intermediate query_where_intermediate::order_by(const table_column &col) {
-  context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
+  return order_by({col});
+}
+
+query_order_by_intermediate query_where_intermediate::order_by(std::initializer_list<table_column> columns) {
+  context_->parts.push_back(std::make_unique<internal::query_order_by_part>(columns));
   return {context_};
 }
 
+
 }

source/orm/query/internal/query_parts.cpp

@@ -4,444 +4,439 @@
 
 namespace matador::query::internal {
 query_alter_part::query_alter_part()
-: query_part(sql::dialect_token::Alter) {}
+: query_part(sql::dialect_token::Alter) {
+}
 
-void query_alter_part::accept( query_part_visitor& visitor ) {
+void query_alter_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_alter_table_part::query_alter_table_part(class table tab)
 : query_part(sql::dialect_token::Table)
-, table_(std::move(tab)) {}
+, table_(std::move(tab)) {
+}
 
-void query_alter_table_part::accept(query_part_visitor& visitor) {
+void query_alter_table_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-const table& query_alter_table_part::table() const {
+const table &query_alter_table_part::table() const {
   return table_;
 }
 
 query_add_key_constraint_part::query_add_key_constraint_part(std::string name)
 : query_part(sql::dialect_token::AddConstraint)
-, name_(std::move(name)){}
+, name_(std::move(name)) {
+}
 
-void query_add_key_constraint_part::accept( query_part_visitor& visitor ) {
+void query_add_key_constraint_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-const std::string& query_add_key_constraint_part::name() const {
-   return name_;
+const std::string &query_add_key_constraint_part::name() const {
+  return name_;
 }
 
 query_add_constraint_part_by_constraint::query_add_constraint_part_by_constraint(const query::table_constraint &co)
 : query_part(sql::dialect_token::AddConstraint)
-, constraint_(co) {}
+, constraint_(co) {
+}
 
 void query_add_constraint_part_by_constraint::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-const table_constraint & query_add_constraint_part_by_constraint::constraint() const {
+const table_constraint &query_add_constraint_part_by_constraint::constraint() const {
   return constraint_;
 }
 
 query_drop_key_constraint_part_by_name::query_drop_key_constraint_part_by_name(std::string name)
-: query_part( sql::dialect_token::DropConstraint )
-, name_(std::move( name )){}
+: query_part(sql::dialect_token::DropConstraint)
+, name_(std::move(name)) {
+}
 
-void query_drop_key_constraint_part_by_name::accept(query_part_visitor& visitor) {
+void query_drop_key_constraint_part_by_name::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-const std::string& query_drop_key_constraint_part_by_name::name() const {
+const std::string &query_drop_key_constraint_part_by_name::name() const {
   return name_;
 }
 
 query_drop_key_constraint_part_by_constraint::query_drop_key_constraint_part_by_constraint(const table_constraint &co)
-: query_part( sql::dialect_token::DropConstraint )
-, constraint_(co) {}
-
-void query_drop_key_constraint_part_by_constraint::accept(query_part_visitor& visitor) {
-    visitor.visit(*this);
+: query_part(sql::dialect_token::DropConstraint)
+, constraint_(co) {
 }
 
-const table_constraint& query_drop_key_constraint_part_by_constraint::constraint() const {
+void query_drop_key_constraint_part_by_constraint::accept(query_part_visitor &visitor) {
+  visitor.visit(*this);
+}
+
+const table_constraint &query_drop_key_constraint_part_by_constraint::constraint() const {
   return constraint_;
 }
 
-query_add_foreign_key_constraint_part::query_add_foreign_key_constraint_part(const std::vector<table_column>& columns)
+query_add_foreign_key_constraint_part::query_add_foreign_key_constraint_part(const std::vector<table_column> &columns)
 : query_part(sql::dialect_token::ForeignKey)
-, columns_(columns) {}
+, columns_(columns) {
+}
 
-void query_add_foreign_key_constraint_part::accept( query_part_visitor& visitor ) {
+void query_add_foreign_key_constraint_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-const std::vector<table_column>& query_add_foreign_key_constraint_part::columns() const {
+const std::vector<table_column> &query_add_foreign_key_constraint_part::columns() const {
   return columns_;
 }
 
-query_add_foreign_key_reference_part::query_add_foreign_key_reference_part(class table tab, const std::vector<table_column>& columns)
+query_add_foreign_key_reference_part::query_add_foreign_key_reference_part(
+  class table tab, const std::vector<table_column> &columns)
 : query_part(sql::dialect_token::References)
 , table_(std::move(tab))
-, columns_(columns) {}
+, columns_(columns) {
+}
 
-void query_add_foreign_key_reference_part::accept( query_part_visitor& visitor ) {
+void query_add_foreign_key_reference_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-const table& query_add_foreign_key_reference_part::table() const {
+const table &query_add_foreign_key_reference_part::table() const {
   return table_;
 }
 
-const std::vector<table_column>& query_add_foreign_key_reference_part::columns() const {
+const std::vector<table_column> &query_add_foreign_key_reference_part::columns() const {
   return columns_;
 }
 
-query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector<table_column>& columns)
+query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector<table_column> &columns)
 : query_part(sql::dialect_token::PrimaryKey)
-, columns_(columns) {}
+, columns_(columns) {
+}
 
-void query_add_primary_key_constraint_part::accept( query_part_visitor& visitor ) {
+void query_add_primary_key_constraint_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-const std::vector<table_column>& query_add_primary_key_constraint_part::columns() const {
+const std::vector<table_column> &query_add_primary_key_constraint_part::columns() const {
   return columns_;
 }
 
 query_select_part::query_select_part(std::vector<table_column> columns)
-  : query_part(sql::dialect_token::Select)
-  , columns_(std::move(columns)) {}
+: query_part(sql::dialect_token::Select)
+, columns_(std::move(columns)) {
+}
 
-void query_select_part::accept(query_part_visitor &visitor)
-{
+void query_select_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-const std::vector<table_column>& query_select_part::columns() const
-{
+const std::vector<table_column> &query_select_part::columns() const {
   return columns_;
 }
 
 query_from_part::query_from_part(class table tab)
-  : query_part(sql::dialect_token::From)
-  , table_(std::move(tab)) {}
+: query_part(sql::dialect_token::From)
+, table_(std::move(tab)) {
+}
 
-const table &query_from_part::table() const
-{
+const table &query_from_part::table() const {
   return table_;
 }
 
-void query_from_part::accept(query_part_visitor &visitor)
-{
+void query_from_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_join_part::query_join_part(class table tab)
-  : query_part(sql::dialect_token::Join)
-  , table_(std::move(tab)) {}
+: query_part(sql::dialect_token::Join)
+, table_(std::move(tab)) {
+}
 
-const table &query_join_part::table() const
-{
+const table &query_join_part::table() const {
   return table_;
 }
 
-void query_join_part::accept(query_part_visitor &visitor)
-{
+void query_join_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_on_part::query_on_part(std::unique_ptr<abstract_criteria> &&cond)
 : query_part(sql::dialect_token::On)
-, condition_(std::move(cond)) {}
+, condition_(std::move(cond)) {
+}
 
-const abstract_criteria &query_on_part::condition() const
-{
+const abstract_criteria &query_on_part::condition() const {
   return *condition_;
 }
 
-void query_on_part::accept(query_part_visitor &visitor)
-{
+void query_on_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_where_part::query_where_part(std::unique_ptr<abstract_criteria> &&cond)
 : query_part(sql::dialect_token::Where)
-, condition_(std::move(cond)) {}
+, condition_(std::move(cond)) {
+}
 
-void query_where_part::accept(query_part_visitor &visitor)
-{
+void query_where_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-const abstract_criteria &query_where_part::condition() const
-{
+const abstract_criteria &query_where_part::condition() const {
   return *condition_;
 }
 
 query_table_name_part::query_table_name_part(const sql::dialect_token token, std::string table_name)
 : query_part(token)
-, table_name_(std::move(table_name)) {}
-
-query_group_by_part::query_group_by_part(class table_column col)
-: query_part(sql::dialect_token::GroupBy)
-, column_(std::move(col))
-{}
-
-const table_column &query_group_by_part::column() const
-{
-  return column_;
+, table_name_(std::move(table_name)) {
 }
 
-void query_group_by_part::accept(query_part_visitor &visitor)
-{
+query_group_by_part::query_group_by_part(const std::vector<table_column> &columns)
+: query_part(sql::dialect_token::GroupBy)
+, columns_(columns) {
+}
+
+const std::vector<table_column> &query_group_by_part::columns() const {
+  return columns_;
+}
+
+void query_group_by_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-query_order_by_part::query_order_by_part(class table_column col)
+query_order_by_part::query_order_by_part(const std::vector<table_column>& columns)
 : query_part(sql::dialect_token::OrderBy)
-, column_(std::move(col))
-{}
-
-const table_column &query_order_by_part::column() const
-{
-  return column_;
+, columns_(columns) {
 }
 
-void query_order_by_part::accept(query_part_visitor &visitor)
-{
+const std::vector<table_column> &query_order_by_part::columns() const {
+  return columns_;
+}
+
+void query_order_by_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_order_by_asc_part::query_order_by_asc_part()
-: query_part(sql::dialect_token::Asc)
-{}
+: query_part(sql::dialect_token::Asc) {
+}
 
-void query_order_by_asc_part::accept(query_part_visitor &visitor)
-{
+void query_order_by_asc_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_order_by_desc_part::query_order_by_desc_part()
-: query_part(sql::dialect_token::Desc)
-{}
+: query_part(sql::dialect_token::Desc) {
+}
 
-void query_order_by_desc_part::accept(query_part_visitor &visitor)
-{
+void query_order_by_desc_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_offset_part::query_offset_part(size_t offset)
 : query_part(sql::dialect_token::Offset)
-, offset_(offset) {}
+, offset_(offset) {
+}
 
-size_t query_offset_part::offset() const
-{
+size_t query_offset_part::offset() const {
   return offset_;
 }
 
-void query_offset_part::accept(query_part_visitor &visitor)
-{
+void query_offset_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_limit_part::query_limit_part(size_t limit)
 : query_part(sql::dialect_token::Limit)
-, limit_(limit) {}
+, limit_(limit) {
+}
 
-size_t query_limit_part::limit() const
-{
+size_t query_limit_part::limit() const {
   return limit_;
 }
 
-void query_limit_part::accept(query_part_visitor &visitor)
-{
+void query_limit_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_insert_part::query_insert_part()
-: query_part(sql::dialect_token::Insert) {}
+: query_part(sql::dialect_token::Insert) {
+}
 
-void query_insert_part::accept(query_part_visitor &visitor)
-{
+void query_insert_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_into_part::query_into_part(class table tab, std::vector<table_column> columns)
 : query_part(sql::dialect_token::Insert)
 , table_(std::move(tab))
-, columns_(std::move(columns)) {}
+, columns_(std::move(columns)) {
+}
 
-const table &query_into_part::table() const
-{
+const table &query_into_part::table() const {
   return table_;
 }
 
-const std::vector<table_column> &query_into_part::columns() const
-{
+const std::vector<table_column> &query_into_part::columns() const {
   return columns_;
 }
 
-void query_into_part::accept(query_part_visitor &visitor)
-{
+void query_into_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-query_values_part::query_values_part(std::vector<std::variant<utils::placeholder, utils::database_type>> &&values)
+query_values_part::query_values_part(std::vector<std::variant<utils::placeholder, utils::database_type> > &&values)
 : query_part(sql::dialect_token::Values)
-, values_(std::move(values)) {}
+, values_(std::move(values)) {
+}
 
-const std::vector<std::variant<utils::placeholder, utils::database_type>>& query_values_part::values() const
-{
+const std::vector<std::variant<utils::placeholder, utils::database_type> > &query_values_part::values() const {
   return values_;
 }
 
-void query_values_part::accept(query_part_visitor &visitor)
-{
+void query_values_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)) {}
+, table_(std::move(tab)) {
+}
 
-const table& query_update_part::table() const
-{
+const table &query_update_part::table() const {
   return table_;
 }
 
-void query_update_part::accept(query_part_visitor &visitor)
-{
+void query_update_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-query_set_part::query_set_part(const std::vector<column_value_pair>& key_value_pairs)
+query_set_part::query_set_part(const std::vector<column_value_pair> &key_value_pairs)
 : query_part(sql::dialect_token::Set)
-, key_value_pairs_(key_value_pairs) {}
+, key_value_pairs_(key_value_pairs) {
+}
 
-const std::vector<column_value_pair> &query_set_part::column_values() const
-{
+const std::vector<column_value_pair> &query_set_part::column_values() const {
   return key_value_pairs_;
 }
 
-void query_set_part::accept(query_part_visitor &visitor)
-{
+void query_set_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_delete_part::query_delete_part()
-: query_part(sql::dialect_token::Remove) {}
+: query_part(sql::dialect_token::Remove) {
+}
 
-void query_delete_part::accept(query_part_visitor &visitor)
-{
+void query_delete_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_delete_from_part::query_delete_from_part(class table tab)
 : query_part(sql::dialect_token::From)
-, table_(std::move(tab)) {}
+, table_(std::move(tab)) {
+}
 
-const table &query_delete_from_part::table() const
-{
+const table &query_delete_from_part::table() const {
   return table_;
 }
 
-void query_delete_from_part::accept(query_part_visitor &visitor)
-{
+void query_delete_from_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_create_part::query_create_part()
-: query_part(sql::dialect_token::Create) {}
+: query_part(sql::dialect_token::Create) {
+}
 
-void query_create_part::accept(query_part_visitor &visitor)
-{
+void query_create_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_create_table_part::query_create_table_part(class table tab)
 : query_part(sql::dialect_token::Table)
-, table_(std::move(tab)) {}
+, table_(std::move(tab)) {
+}
 
-const table &query_create_table_part::table() const
-{
+const table &query_create_table_part::table() const {
   return table_;
 }
 
-void query_create_table_part::accept(query_part_visitor &visitor)
-{
+void query_create_table_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-query_create_table_columns_part::query_create_table_columns_part(const std::list<table_column>& columns)
-: query_part( sql::dialect_token::Columns )
-, columns_(columns){}
+query_create_table_columns_part::query_create_table_columns_part(const std::list<table_column> &columns)
+: query_part(sql::dialect_token::Columns)
+, columns_(columns) {
+}
 
-const std::list<table_column>& query_create_table_columns_part::columns() const {
+const std::list<table_column> &query_create_table_columns_part::columns() const {
   return columns_;
 }
 
-void query_create_table_columns_part::accept(query_part_visitor& visitor) {
+void query_create_table_columns_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-query_create_table_constraints_part::query_create_table_constraints_part(const std::list<class table_constraint>& constraints)
-: query_part( sql::dialect_token::Constraint )
-, constraints_(constraints) {}
+query_create_table_constraints_part::query_create_table_constraints_part(
+  const std::list<class table_constraint> &constraints)
+: query_part(sql::dialect_token::Constraint)
+, constraints_(constraints) {
+}
 
-const std::list<class table_constraint>& query_create_table_constraints_part::constraints() const {
+const std::list<class table_constraint> &query_create_table_constraints_part::constraints() const {
   return constraints_;
 }
 
-void query_create_table_constraints_part::accept( query_part_visitor& visitor ) {
+void query_create_table_constraints_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_create_schema_part::query_create_schema_part(std::string schema)
-: query_part( sql::dialect_token::Schema )
-, schema_( std::move( schema ) ){}
-
-const std::string& query_create_schema_part::schema() const {
-    return schema_;
+: query_part(sql::dialect_token::Schema)
+, schema_(std::move(schema)) {
 }
 
-void query_create_schema_part::accept( query_part_visitor& visitor ) {
-    visitor.visit(*this);
+const std::string &query_create_schema_part::schema() const {
+  return schema_;
+}
+
+void query_create_schema_part::accept(query_part_visitor &visitor) {
+  visitor.visit(*this);
 }
 
 query_drop_part::query_drop_part()
-: query_part(sql::dialect_token::Drop) {}
+: query_part(sql::dialect_token::Drop) {
+}
 
-void query_drop_part::accept(query_part_visitor &visitor)
-{
+void query_drop_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_drop_table_part::query_drop_table_part(class table tab)
 : query_part(sql::dialect_token::Table)
-, table_(std::move(tab)) {}
+, table_(std::move(tab)) {
+}
 
-const table &query_drop_table_part::table() const
-{
+const table &query_drop_table_part::table() const {
   return table_;
 }
 
-void query_drop_table_part::accept(query_part_visitor &visitor)
-{
+void query_drop_table_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
 query_drop_schema_part::query_drop_schema_part(std::string schema_)
-: query_part( sql::dialect_token::Schema )
-, schema_( std::move( schema_ ) ) {}
+: query_part(sql::dialect_token::Schema)
+, schema_(std::move(schema_)) {
+}
 
-const std::string& query_drop_schema_part::schema() const {
+const std::string &query_drop_schema_part::schema() const {
   return schema_;
 }
 
-void query_drop_schema_part::accept( query_part_visitor& visitor ) {
+void query_drop_schema_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
-}
+}

source/orm/query/query.cpp

@@ -49,13 +49,6 @@ query_select_intermediate query::select(const std::vector<std::string> &column_n
   return select(columns);
 }
 
-query_select_intermediate query::select(std::vector<table_column> columns, const std::initializer_list<table_column> additional_columns) {
-  for (const auto &col : additional_columns) {
-    columns.push_back(col);
-  }
-  return query_select_intermediate{columns};
-}
-
 query_insert_intermediate query::insert() {
   return {};
 }

source/orm/query/query_compiler.cpp

@@ -179,12 +179,35 @@ void query_compiler::visit(internal::query_where_part &part) {
 }
 
 void query_compiler::visit(internal::query_group_by_part &part) {
-  query_.sql += " " + dialect_->group_by() + " " + prepare_identifier(*dialect_, part.column());
+  query_.sql += " " + dialect_->group_by() + " ";
+  if (part.columns().size() < 2) {
+    for (const auto &col: part.columns()) {
+      query_.sql.append(dialect_->prepare_identifier_string(col.canonical_name()));
+    }
+  } else {
+    auto it = part.columns().begin();
+    query_.sql.append(dialect_->prepare_identifier_string((it++)->canonical_name()));
+    for (; it != part.columns().end(); ++it) {
+      query_.sql.append(", ");
+      query_.sql.append(dialect_->prepare_identifier_string(it->canonical_name()));
+    }
+  }
 }
 
 void query_compiler::visit(internal::query_order_by_part &part) {
-  query_.sql += " " + dialect_->order_by() +
-                " " + prepare_criteria(*dialect_, part.column());
+  query_.sql += " " + dialect_->order_by() + " ";
+  if (part.columns().size() < 2) {
+    for (const auto &col: part.columns()) {
+      query_.sql.append(dialect_->prepare_identifier_string(col.canonical_name()));
+    }
+  } else {
+    auto it = part.columns().begin();
+    query_.sql.append(dialect_->prepare_identifier_string((it++)->canonical_name()));
+    for (; it != part.columns().end(); ++it) {
+      query_.sql.append(", ");
+      query_.sql.append(dialect_->prepare_identifier_string(it->canonical_name()));
+    }
+  }
 }
 
 void query_compiler::visit(internal::query_order_by_asc_part &/*order_by_asc_part*/) {