fix: only reject RIGHT and FULL joins, allow LEFT joins

The distributed shuffle join can correctly handle LEFT joins in the
current implementation because each node executes the query locally
and LEFT join only requires preserving unmatched left-table rows
(which are already local to each node). RIGHT and FULL joins require
tracking unmatched rows across partitions which is not yet implemented.

Update error message to say "INNER and LEFT" instead of just "INNER".

Author: poyrazK

src/distributed/distributed_executor.cpp

@@ -188,25 +188,14 @@ QueryResult DistributedExecutor::execute(const parser::Statement& stmt,
                 const std::string left_table = select_stmt->from()->to_string();
                 const std::string right_table = join.table->to_string();
 
-                // Check join type - shuffle join only supports INNER joins
-                if (join.type != parser::SelectStatement::JoinType::Inner) {
+                // Check join type - shuffle join only supports INNER and LEFT joins
+                // RIGHT and FULL joins require tracking unmatched rows across partitions
+                if (join.type == parser::SelectStatement::JoinType::Right ||
+                    join.type == parser::SelectStatement::JoinType::Full) {
                     QueryResult res;
-                    std::string join_type_name;
-                    switch (join.type) {
-                        case parser::SelectStatement::JoinType::Left:
-                            join_type_name = "LEFT";
-                            break;
-                        case parser::SelectStatement::JoinType::Right:
-                            join_type_name = "RIGHT";
-                            break;
-                        case parser::SelectStatement::JoinType::Full:
-                            join_type_name = "FULL";
-                            break;
-                        default:
-                            join_type_name = "OUTER";
-                            break;
-                    }
-                    res.set_error("Distributed Shuffle Join only supports INNER joins. " +
+                    std::string join_type_name =
+                        (join.type == parser::SelectStatement::JoinType::Right) ? "RIGHT" : "FULL";
+                    res.set_error("Distributed Shuffle Join only supports INNER and LEFT joins. " +
                                   join_type_name +
                                   " joins are not yet supported in distributed mode.");
                     return res;

tests/distributed_tests.cpp

@@ -462,9 +462,9 @@ TEST(DistributedExecutorTests, RightJoinRejection) {
     auto res =
         exec.execute(*stmt, "SELECT * FROM table1 RIGHT JOIN table2 ON table1.id = table2.id");
 
-    // Should fail because distributed shuffle join only supports INNER joins
+    // Should fail because distributed shuffle join only supports INNER and LEFT joins
     EXPECT_FALSE(res.success());
-    EXPECT_THAT(res.error(), testing::HasSubstr("only supports INNER joins"));
+    EXPECT_THAT(res.error(), testing::HasSubstr("only supports INNER and LEFT joins"));
     EXPECT_THAT(res.error(), testing::HasSubstr("RIGHT"));
 }
 
@@ -483,9 +483,9 @@ TEST(DistributedExecutorTests, FullJoinRejection) {
     auto res =
         exec.execute(*stmt, "SELECT * FROM table1 FULL JOIN table2 ON table1.id = table2.id");
 
-    // Should fail because distributed shuffle join only supports INNER joins
+    // Should fail because distributed shuffle join only supports INNER and LEFT joins
     EXPECT_FALSE(res.success());
-    EXPECT_THAT(res.error(), testing::HasSubstr("only supports INNER joins"));
+    EXPECT_THAT(res.error(), testing::HasSubstr("only supports INNER and LEFT joins"));
     EXPECT_THAT(res.error(), testing::HasSubstr("FULL"));
 }