column, placeholder and column_value generator progress

include/matador/query/generator.hpp

@@ -39,11 +39,11 @@ inline bool is_column_generator_option_set(const column_generator_options source
 
 constexpr auto default_column_generator_options = column_generator_options::ForceLazy;
 
-class column_generator2 {
+class column_generator {
 public:
-  explicit column_generator2(const std::string &table_name = "",
+  explicit column_generator(const std::string &table_name = "",
                             column_generator_options options = default_column_generator_options);
-  explicit column_generator2(const object::repository &repo,
+  explicit column_generator(const object::repository &repo,
                             const std::string &table_name = "",
                             column_generator_options options = default_column_generator_options);
 
@@ -105,7 +105,10 @@ public:
   }
 
   template<class ContainerType>
-  void on_has_many_to_many(const char * /*id*/, ContainerType & /*cont*/, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &/*attr*/) {
+  void on_has_many_to_many(const char * /*id*/, ContainerType & /*cont*/, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &attr) {
+    if (attr.fetch() == utils::fetch_type::LAZY || is_column_generator_option_set(options_, column_generator_options::ForceLazy)) {
+      return;
+    }
     push(join_column);
     push(inverse_join_column);
   }
@@ -184,7 +187,11 @@ public:
     result_.emplace_back(utils::_);
   }
   template<class ContainerType>
-  static void on_has_many(const char *, ContainerType &, const char *, const char *, const utils::foreign_attributes &/*attr*/) {}
+  static void on_has_many(const char * /*id*/, ContainerType &, const char *, const utils::foreign_attributes &attr) {}
+  template<class ContainerType>
+  static void on_has_many_to_many(const char *, ContainerType &, const char *, const char *, const utils::foreign_attributes &/*attr*/) {}
+  template<class ContainerType>
+  static void on_has_many_to_many(const char *, ContainerType &, const utils::foreign_attributes &/*attr*/) {}
 
 private:
     std::vector<utils::placeholder> result_;
@@ -226,7 +233,11 @@ public:
         result_.emplace_back(id, fk_value_extractor_.extract(*x));
     }
     template<class ContainerType>
-    static void on_has_many(const char *, ContainerType &, const char *, const char *, const utils::foreign_attributes &/*attr*/) {}
+    static void on_has_many(const char * /*id*/, ContainerType &, const char *, const utils::foreign_attributes &attr) {}
+    template<class ContainerType>
+    static void on_has_many_to_many(const char *, ContainerType &, const char *, const char *, const utils::foreign_attributes &/*attr*/) {}
+    template<class ContainerType>
+    static void on_has_many_to_many(const char *, ContainerType &, const utils::foreign_attributes &/*attr*/) {}
 
 private:
     detail::fk_value_extractor fk_value_extractor_{};
@@ -256,7 +267,18 @@ template<typename Type>
 std::vector<sql::column> columns(const object::repository &repo,
                                  const std::string &table_name = "",
                                  const column_generator_options options = default_column_generator_options) {
-    column_generator2 generator(repo, table_name, options);
+    column_generator generator(repo, table_name, options);
+    return generator.generate<Type>();
+}
+
+template<typename Type>
+std::vector<sql::column> columns(const object::repository &repo,
+                                 const column_generator_options options) {
+    std::string table_name;
+    if (const auto result = repo.info<Type>()) {
+        table_name = result.value().get().name();
+    }
+    column_generator generator(repo, table_name, options);
     return generator.generate<Type>();
 }
 
@@ -265,14 +287,14 @@ std::vector<sql::column> columns(const Type &obj,
                                  const object::repository &repo,
                                  const std::string &table_name = "",
                                  const column_generator_options options = default_column_generator_options) {
-    column_generator2 generator(repo, table_name, options);
+    column_generator generator(repo, table_name, options);
     return generator.generate(obj);
 }
 
 template<typename Type>
 std::vector<sql::column> columns(const std::string &table_name = "",
                                  const column_generator_options options = default_column_generator_options) {
-    column_generator2 generator(table_name, options);
+    column_generator generator(table_name, options);
     return generator.generate<Type>();
 }
 
@@ -280,7 +302,7 @@ template<typename Type>
 std::vector<sql::column> columns(const Type &obj,
                                  const std::string &table_name = "",
                                  const column_generator_options options = default_column_generator_options) {
-    column_generator2 generator(table_name, options);
+    column_generator generator(table_name, options);
     return generator.generate(obj);
 }
 

include/matador/query/intermediates/query_insert_intermediate.hpp

@@ -4,7 +4,7 @@
 #include "matador/query/intermediates/query_intermediate.hpp"
 #include "matador/query/intermediates/query_into_intermediate.hpp"
 
-#include "matador/sql/column_generator.hpp"
+#include "matador/query/generator.hpp"
 
 namespace matador::query {
 
@@ -15,7 +15,7 @@ public:
 
   template<class Type>
   query_into_intermediate into(const sql::table &table, const object::repository &schema) {
-    return into(table, sql::column_generator::generate<Type>(schema));
+    return into(table, generator::columns<Type>(schema));
   }
   query_into_intermediate into(const sql::table &table, std::initializer_list<sql::column> columns);
   query_into_intermediate into(const sql::table &table, std::vector<sql::column> &&columns);

include/matador/query/intermediates/query_into_intermediate.hpp

@@ -16,6 +16,7 @@ public:
 
   executable_query 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);
+  executable_query values(std::vector<utils::placeholder> &&values);
   executable_query values(std::vector<utils::database_type> &&values);
   template<class Type>
   executable_query values() {

include/matador/query/query.hpp

@@ -3,7 +3,7 @@
 
 #include "matador/query/query_intermediates.hpp"
 
-#include "matador/sql/column_generator.hpp"
+#include "matador/query/generator.hpp"
 
 namespace matador::sql {
 class connection;
@@ -27,7 +27,7 @@ public:
   [[nodiscard]] static query_select_intermediate select(std::vector<sql::column> columns, std::initializer_list<sql::column> additional_columns);
   template<class Type>
   [[nodiscard]] static query_select_intermediate select(const object::repository &schema) {
-    return select(sql::column_generator::generate<Type>(schema));
+    return select(generator::columns<Type>(schema));
   }
   [[nodiscard]] static query_insert_intermediate insert();
   [[nodiscard]] static query_update_intermediate update(const sql::table &table);