Tests for constrained join clauses with regard to table collection

Author: trueqbit

dev/conditions.h

@@ -813,7 +813,7 @@ namespace sqlite_orm {
         using is_from = polyfill::is_specialization_of<T, from_t>;
 
         template<class T>
-        using is_any_join = polyfill::is_detected<on_type_t, T>;
+        using is_constrained_join = polyfill::is_detected<on_type_t, T>;
     }
 
     /**

dev/statement_serializer.h

@@ -1506,7 +1506,8 @@ namespace sqlite_orm {
                 constexpr bool hasExplicitFrom = tuple_has<is_from, conditions_tuple>::value;
                 if(!hasExplicitFrom) {
                     auto tableNames = collect_table_names(sel, context);
-                    using joins_index_sequence = filter_tuple_sequence_t<conditions_tuple, is_any_join>;
+                    using joins_index_sequence = filter_tuple_sequence_t<conditions_tuple, is_constrained_join>;
+                    // deduplicate table names of constrained join statements
                     iterate_tuple(sel.conditions, joins_index_sequence{}, [&tableNames, &context](auto& join) {
                         using original_join_type = typename std::decay_t<decltype(join)>::type;
                         using cross_join_type = mapped_type_proxy_t<original_join_type>;
@@ -1851,7 +1852,7 @@ namespace sqlite_orm {
                 ss << static_cast<std::string>(l) << " "
                    << streaming_identifier(lookup_table_name<mapped_type_proxy_t<T>>(context.db_objects),
                                            alias_extractor<T>::as_alias())
-                   << serialize(l.constraint, context);
+                   << " " << serialize(l.constraint, context);
                 return ss.str();
             }
         };

include/sqlite_orm/sqlite_orm.h

@@ -3775,7 +3775,7 @@ namespace sqlite_orm {
         using is_from = polyfill::is_specialization_of<T, from_t>;
 
         template<class T>
-        using is_any_join = polyfill::is_detected<on_type_t, T>;
+        using is_constrained_join = polyfill::is_detected<on_type_t, T>;
     }
 
     /**
@@ -16965,7 +16965,8 @@ namespace sqlite_orm {
                 constexpr bool hasExplicitFrom = tuple_has<is_from, conditions_tuple>::value;
                 if(!hasExplicitFrom) {
                     auto tableNames = collect_table_names(sel, context);
-                    using joins_index_sequence = filter_tuple_sequence_t<conditions_tuple, is_any_join>;
+                    using joins_index_sequence = filter_tuple_sequence_t<conditions_tuple, is_constrained_join>;
+                    // deduplicate table names of constrained join statements
                     iterate_tuple(sel.conditions, joins_index_sequence{}, [&tableNames, &context](auto& join) {
                         using original_join_type = typename std::decay_t<decltype(join)>::type;
                         using cross_join_type = mapped_type_proxy_t<original_join_type>;
@@ -17310,7 +17311,7 @@ namespace sqlite_orm {
                 ss << static_cast<std::string>(l) << " "
                    << streaming_identifier(lookup_table_name<mapped_type_proxy_t<T>>(context.db_objects),
                                            alias_extractor<T>::as_alias())
-                   << serialize(l.constraint, context);
+                   << " " << serialize(l.constraint, context);
                 return ss.str();
             }
         };

tests/statement_serializer_tests/select_constraints.cpp

@@ -86,6 +86,51 @@ TEST_CASE("statement_serializer select constraints") {
         }
 #endif
     }
+    // tests whether the statement serializer for a select with joins
+    // properly deduplicates the table names when no explicit from is used
+    SECTION("deduplicated table names") {
+        struct UserProps {
+            int id = 0;
+            std::string name;
+        };
+        auto table2 =
+            make_table("user_props", make_column("id", &UserProps::id), make_column("name", &UserProps::name));
+        using db_objects_t = internal::db_objects_tuple<decltype(table), decltype(table2)>;
+        auto dbObjects = db_objects_t{table, table2};
+        internal::serializer_context<db_objects_t> context{dbObjects};
+        context.use_parentheses = false;
+
+        SECTION("left join") {
+            auto expression = select(asterisk<User>(), left_join<UserProps>(using_(&UserProps::id)));
+            value = serialize(expression, context);
+            expected = R"(SELECT "users".* FROM "users" LEFT JOIN "user_props" USING ("id"))";
+        }
+        SECTION("join") {
+            auto expression = select(asterisk<User>(), join<UserProps>(using_(&UserProps::id)));
+            value = serialize(expression, context);
+            expected = R"(SELECT "users".* FROM "users" JOIN "user_props" USING ("id"))";
+        }
+        SECTION("left outer join") {
+            auto expression = select(asterisk<User>(), left_outer_join<UserProps>(using_(&UserProps::id)));
+            value = serialize(expression, context);
+            expected = R"(SELECT "users".* FROM "users" LEFT OUTER JOIN "user_props" USING ("id"))";
+        }
+        SECTION("inner join") {
+            auto expression = select(asterisk<User>(), inner_join<UserProps>(using_(&UserProps::id)));
+            value = serialize(expression, context);
+            expected = R"(SELECT "users".* FROM "users" INNER JOIN "user_props" USING ("id"))";
+        }
+        SECTION("cross join") {
+            auto expression = select(asterisk<User>(), cross_join<UserProps>());
+            value = serialize(expression, context);
+            expected = R"(SELECT "users".* FROM "users" CROSS JOIN "user_props")";
+        }
+        SECTION("natural join") {
+            auto expression = select(asterisk<User>(), natural_join<UserProps>());
+            value = serialize(expression, context);
+            expected = R"(SELECT "users".* FROM "users" NATURAL JOIN "user_props")";
+        }
+    }
     SECTION("function_call") {
         struct Func {
             bool operator()(int arg) const {