fix: reject OUTER joins (LEFT/RIGHT/FULL) in distributed shuffle join

The distributed shuffle join algorithm only supports INNER joins.
LEFT, RIGHT, and FULL outer joins require different handling
(e.g., broadcasting the outer table, or double-shuffle with side tables)
that is not yet implemented. Instead of producing incorrect results,
we now return a clear error message.

Also add unit tests RightJoinRejection and FullJoinRejection to
verify this behavior.

Author: poyrazK

src/distributed/distributed_executor.cpp

@@ -188,6 +188,22 @@ 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) {
+                    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. " +
+                                  join_type_name +
+                                  " joins are not yet supported in distributed mode.");
+                    return res;
+                }
+
                 // Assume join key is in the condition
                 std::string left_key;
                 std::string right_key;

tests/distributed_tests.cpp

@@ -447,4 +447,44 @@ TEST(DistributedExecutorTests, NonEqualityJoinRejection) {
     EXPECT_THAT(res.error(), testing::HasSubstr("equality join condition"));
 }
 
+TEST(DistributedExecutorTests, RightJoinRejection) {
+    auto catalog = Catalog::create();
+    const config::Config config;
+    ClusterManager cm(&config);
+    cm.register_node("n1", "127.0.0.1", 7800, config::RunMode::Data);
+    DistributedExecutor exec(*catalog, cm);
+
+    auto lexer =
+        std::make_unique<Lexer>("SELECT * FROM table1 RIGHT JOIN table2 ON table1.id = table2.id");
+    Parser parser(std::move(lexer));
+    auto stmt = parser.parse_statement();
+
+    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
+    EXPECT_FALSE(res.success());
+    EXPECT_THAT(res.error(), testing::HasSubstr("only supports INNER joins"));
+    EXPECT_THAT(res.error(), testing::HasSubstr("RIGHT"));
+}
+
+TEST(DistributedExecutorTests, FullJoinRejection) {
+    auto catalog = Catalog::create();
+    const config::Config config;
+    ClusterManager cm(&config);
+    cm.register_node("n1", "127.0.0.1", 7800, config::RunMode::Data);
+    DistributedExecutor exec(*catalog, cm);
+
+    auto lexer =
+        std::make_unique<Lexer>("SELECT * FROM table1 FULL JOIN table2 ON table1.id = table2.id");
+    Parser parser(std::move(lexer));
+    auto stmt = parser.parse_statement();
+
+    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
+    EXPECT_FALSE(res.success());
+    EXPECT_THAT(res.error(), testing::HasSubstr("only supports INNER joins"));
+    EXPECT_THAT(res.error(), testing::HasSubstr("FULL"));
+}
+
 }  // namespace