many to many query progress (multiple joins)

src/sql/column.cpp

@@ -1,4 +1,5 @@
 #include "matador/sql/column.hpp"
+#include "matador/sql/table.hpp"
 
 namespace matador::sql {
 
@@ -23,6 +24,14 @@ column::column(std::string table_name, const char *name, std::string as)
 , name(name)
 , alias(std::move(as)) {}
 
+column::column(struct table &t, const char *name, std::string as)
+: table(t.name)
+, name(name)
+, alias(std::move(as))
+{
+  t.columns.push_back(*this);
+}
+
 bool column::equals(const column &x) const
 {
   return table == x.table &&

src/sql/column_generator.cpp

@@ -4,9 +4,11 @@ namespace matador::sql {
 
 column_generator::column_generator(std::vector<column> &column_infos,
                                    const sql::schema &ts,
-                                   const std::string &table_name)
+                                   const std::string &table_name,
+                                   bool force_lazy)
 : column_infos_(column_infos)
 , table_schema_(ts)
+, force_lazy_(force_lazy)
 {
   table_name_stack_.push(table_name);
 }

src/sql/query.cpp

@@ -28,6 +28,14 @@ query_select_intermediate query::select(const std::vector<column>& columns)
   return {connection_, schema_, columns};
 }
 
+query_select_intermediate query::select(std::vector<column> columns, std::initializer_list<column> additional_columns)
+{
+  for (const auto &col : additional_columns) {
+    columns.push_back(col);
+  }
+  return {connection_, schema_, columns};
+}
+
 query_insert_intermediate query::insert()
 {
   return query_insert_intermediate{connection_, schema_};

src/sql/query_compiler.cpp

@@ -70,9 +70,17 @@ void query_compiler::visit(query_from_part &from_part)
 
 void query_compiler::visit(query_join_part &join_part)
 {
-  query_.sql += " " + dialect_.token_at(dialect::token_t::JOIN) +
-                " " + dialect_.prepare_identifier(join_part.table().name) +
-                (join_part.table().alias.empty() ? "" : " AS " + dialect_.prepare_identifier(join_part.table().alias));
+  if (dialect_.default_schema_name().empty()) {
+    query_.sql += " " + dialect_.token_at(dialect::token_t::JOIN) +
+                  " " + dialect_.prepare_identifier(join_part.table().name) +
+                  (join_part.table().alias.empty() ? "" : " AS " + dialect_.prepare_identifier(join_part.table().alias));
+  } else {
+    query_.sql += " " + dialect_.token_at(dialect::token_t::JOIN) +
+                  " " + dialect_.prepare_identifier(dialect_.default_schema_name()) +
+                  "." + dialect_.prepare_identifier(join_part.table().name) +
+                  (join_part.table().alias.empty() ? "" : " AS " + dialect_.prepare_identifier(join_part.table().alias));
+
+  }
 }
 
 void query_compiler::visit(query_on_part &on_part)

src/sql/query_intermediates.cpp

@@ -178,6 +178,12 @@ query_into_intermediate query_insert_intermediate::into(const table &table, std:
   return {connection_, schema_, data_};
 }
 
+query_into_intermediate query_insert_intermediate::into(const table &table)
+{
+  data_.parts.push_back(std::make_unique<query_into_part>(table, table.columns));
+  return {connection_, schema_, data_};
+}
+
 size_t query_execute_finish::execute()
 {
   query_compiler compiler(connection_.dialect());