added column names and values generator and tests

include/matador/sql/any_type.hpp

@@ -0,0 +1,18 @@
+#ifndef QUERY_ANY_TYPE_HPP
+#define QUERY_ANY_TYPE_HPP
+
+#include <string>
+#include <variant>
+
+namespace matador::sql {
+
+using any_type = std::variant<
+  char, short, int, long, long long,
+  unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long,
+  bool,
+  float, double,
+  const char*,
+  std::string>;
+
+}
+#endif //QUERY_ANY_TYPE_HPP

include/matador/sql/column_generator.hpp

@@ -6,16 +6,56 @@
 
 #include "matador/utils/access.hpp"
 #include "matador/utils/field_attributes.hpp"
+#include "matador/utils/identifiable.hpp"
+#include "matador/utils/identifier.hpp"
 
 #include <vector>
 
 namespace matador::utils {
-class identifiable;
 enum class cascade_type;
 }
 
 namespace matador::sql {
 
+namespace detail {
+class null_identifiable : public utils::identifiable
+{
+public:
+  void reset(const utils::identifier &) override {};
+  [[nodiscard]] bool has_primary_key() const override { return false; }
+  [[nodiscard]] const utils::identifier& primary_key() const override { return id_; }
+  utils::identifier& primary_key() override { return id_; }
+  [[nodiscard]] utils::identifier create_identifier() const override { return utils::identifier(id_); }
+
+private:
+  utils::identifier id_;
+};
+
+static null_identifiable null_id;
+
+}
+
+class fk_column_generator : public utils::identifier_serializer
+{
+public:
+  column generate(const char *id, utils::identifiable &x);
+  void serialize(short &i, const utils::field_attributes &attributes) override;
+  void serialize(int &i, const utils::field_attributes &attributes) override;
+  void serialize(long &i, const utils::field_attributes &attributes) override;
+  void serialize(long long int &i, const utils::field_attributes &attributes) override;
+  void serialize(unsigned short &i, const utils::field_attributes &attributes) override;
+  void serialize(unsigned int &i, const utils::field_attributes &attributes) override;
+  void serialize(unsigned long &i, const utils::field_attributes &attributes) override;
+  void serialize(unsigned long long int &i, const utils::field_attributes &attributes) override;
+  void serialize(std::string &string, const utils::field_attributes &attributes) override;
+  void serialize(utils::null_type_t &type, const utils::field_attributes &attributes) override;
+
+private:
+  utils::identifiable &identifiable_{detail::null_id};
+  const char *id_{};
+  column column_;
+};
+
 class column_generator
 {
 private:
@@ -37,21 +77,23 @@ public:
   template < class V >
   void on_primary_key(const char *, V &x, typename std::enable_if<std::is_integral<V>::value && !std::is_same<bool, V>::value>::type* = 0);
   void on_primary_key(const char *id, std::string &pk, size_t size);
-  void on_revision(const char *id, unsigned long long &/*rev*/);
+  void on_revision(const char *id, unsigned long long &rev);
 
   template<typename Type>
   void on_attribute(const char *id, Type &x, const utils::field_attributes &attr = utils::null_attributes);
 
   void on_belongs_to(const char *id, utils::identifiable &x, utils::cascade_type);
   void on_has_one(const char *id, utils::identifiable &x, utils::cascade_type);
-//  void on_has_many(const char *, abstract_container &, const char *, const char *, cascade_type) {}
-//  void on_has_many(const char *, abstract_container &, cascade_type) {}
+  template<class ContainerType>
+  void on_has_many(const char *, ContainerType &, const char *, const char *, utils::cascade_type) {}
+  template<class ContainerType>
+  void on_has_many(const char *, ContainerType &, utils::cascade_type) {}
 
 private:
   size_t index_ = 0;
   std::vector<column> &columns_;
 
-//  typed_column_identifier_serializer column_identifier_serializer_;
+  fk_column_generator fk_column_generator_;
 };
 
 template<typename V>

include/matador/sql/column_name_generator.hpp

@@ -0,0 +1,59 @@
+#ifndef QUERY_COLUMN_NAME_GENERATOR_HPP
+#define QUERY_COLUMN_NAME_GENERATOR_HPP
+
+#include "matador/utils/access.hpp"
+#include "matador/utils/field_attributes.hpp"
+
+#include <string>
+#include <vector>
+
+namespace matador::utils {
+class identifiable;
+}
+
+namespace matador::sql {
+
+class column_name_generator
+{
+private:
+  explicit column_name_generator(std::vector<std::string> &column_names);
+
+public:
+  ~column_name_generator() = default;
+
+  template < class Type >
+  static std::vector<std::string> generate()
+  {
+    std::vector<std::string> columns;
+    column_name_generator gen(columns);
+    Type obj;
+    matador::utils::access::process(gen, obj);
+    return std::move(columns);
+  }
+
+  template < class V >
+  void on_primary_key(const char *id, V &, typename std::enable_if<std::is_integral<V>::value && !std::is_same<bool, V>::value>::type* = 0)
+  {
+    column_names_.emplace_back(id);
+  }
+  void on_primary_key(const char *id, std::string &, size_t);
+  void on_revision(const char *id, unsigned long long &/*rev*/);
+
+  template<typename Type>
+  void on_attribute(const char *id, Type &, const utils::field_attributes &/*attr*/ = utils::null_attributes)
+  {
+    column_names_.emplace_back(id);
+  }
+
+  void on_belongs_to(const char *id, utils::identifiable &, utils::cascade_type);
+  void on_has_one(const char *id, utils::identifiable &, utils::cascade_type);
+//  void on_has_many(const char *, abstract_container &, const char *, const char *, cascade_type) {}
+//  void on_has_many(const char *, abstract_container &, cascade_type) {}
+
+private:
+  std::vector<std::string> &column_names_;
+};
+
+}
+
+#endif //QUERY_COLUMN_NAME_GENERATOR_HPP

include/matador/sql/key_value_pair.hpp

@@ -1,20 +1,10 @@
 #ifndef QUERY_KEY_VALUE_PAIR_HPP
 #define QUERY_KEY_VALUE_PAIR_HPP
 
-#include <any>
-#include <string>
-#include <variant>
+#include "matador/sql/any_type.hpp"
 
 namespace matador::sql {
 
-using any_type = std::variant<
-  char, short, int, long, long long,
-  unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long,
-  bool,
-  float, double,
-  const char*,
-  std::string>;
-
 class key_value_pair
 {
 public:

include/matador/sql/query_intermediates.hpp

@@ -3,6 +3,7 @@
 
 #include "matador/sql/column.hpp"
 #include "matador/sql/column_generator.hpp"
+#include "matador/sql/column_name_generator.hpp"
 #include "matador/sql/key_value_pair.hpp"
 #include "matador/sql/query_result.hpp"
 #include "matador/sql/record.hpp"
@@ -158,6 +159,11 @@ public:
   using query_intermediate::query_intermediate;
 
   query_into_intermediate into(const std::string &table, std::initializer_list<std::string> column_names);
+  template<class Type>
+  query_into_intermediate into(const std::string &table)
+  {
+    return into(table, column_name_generator::generate<Type>());
+  }
 };
 
 class query_execute_where_intermediate : public query_execute_finish

include/matador/sql/value_generator.hpp

@@ -0,0 +1,70 @@
+#ifndef QUERY_VALUE_GENERATOR_HPP
+#define QUERY_VALUE_GENERATOR_HPP
+
+#include "matador/sql/any_type.hpp"
+
+#include "matador/utils/access.hpp"
+#include "matador/utils/field_attributes.hpp"
+#include "matador/utils/identifiable.hpp"
+
+#include <vector>
+
+namespace matador::utils {
+enum class cascade_type;
+}
+namespace matador::sql {
+
+class value_generator
+{
+private:
+  explicit value_generator(std::vector<any_type> &values);
+
+public:
+  ~value_generator() = default;
+
+  template < class Type >
+  static std::vector<any_type> generate()
+  {
+    std::vector<any_type> values;
+    value_generator gen(values);
+    Type obj;
+    matador::utils::access::process(gen, obj);
+    return std::move(values);
+  }
+
+  template<typename ValueType>
+  void on_primary_key(const char *, ValueType &x, typename std::enable_if<std::is_integral<ValueType>::value && !std::is_same<bool, ValueType>::value>::type* = 0)
+  {
+    append(x);
+  }
+  void on_primary_key(const char *id, std::string &pk, size_t size);
+  void on_revision(const char *id, unsigned long long &rev);
+  template < class Type >
+  void on_attribute(const char *, Type &x, const utils::field_attributes &/*attr*/ = utils::null_attributes)
+  {
+    append(x);
+  }
+  void on_attribute(const char *id, char *x, const utils::field_attributes &/*attr*/ = utils::null_attributes);
+  void on_attribute(const char *id, std::string &x, const utils::field_attributes &/*attr*/ = utils::null_attributes);
+  void on_belongs_to(const char *id, utils::identifiable &x, utils::cascade_type);
+  void on_has_one(const char *id, utils::identifiable &x, utils::cascade_type);
+
+  template<class ContainerType>
+  void on_has_many(const char *, ContainerType &, const char *, const char *, utils::cascade_type) {}
+  template<class ContainerType>
+  void on_has_many(const char *, ContainerType &, utils::cascade_type) {}
+
+private:
+  template<typename Type>
+  void append(Type &value)
+  {
+    values_.emplace_back(value);
+  }
+
+private:
+  std::vector<any_type> &values_;
+};
+
+}
+
+#endif //QUERY_VALUE_GENERATOR_HPP