planner: support left outer join into anti semi join (#64959)

close #64329

Author: hawkingrei

pkg/planner/core/casetest/rule/BUILD.bazel

@@ -12,12 +12,13 @@ go_test(
         "rule_inject_extra_projection_test.go",
         "rule_join_reorder_test.go",
         "rule_outer2inner_test.go",
+        "rule_outer_to_semi_join_test.go",
         "rule_predicate_pushdown_test.go",
         "rule_predicate_simplification_test.go",
     ],
     data = glob(["testdata/**"]),
     flaky = True,
-    shard_count = 14,
+    shard_count = 15,
     deps = [
         "//pkg/config",
         "//pkg/domain",

pkg/planner/core/casetest/rule/main_test.go

@@ -34,6 +34,8 @@ func TestMain(m *testing.M) {
 	testDataMap.LoadTestSuiteData("testdata", "join_reorder_suite", true)
 	testDataMap.LoadTestSuiteData("testdata", "predicate_pushdown_suite", true)
 	testDataMap.LoadTestSuiteData("testdata", "predicate_simplification", true)
+	testDataMap.LoadTestSuiteData("testdata", "outer_to_semi_join_suite", true)
+
 	opts := []goleak.Option{
 		goleak.IgnoreTopFunction("github.com/golang/glog.(*fileSink).flushDaemon"),
 		goleak.IgnoreTopFunction("github.com/bazelbuild/rules_go/go/tools/bzltestutil.RegisterTimeoutHandler.func1"),
@@ -71,3 +73,7 @@ func GetPredicatePushdownSuiteData() testdata.TestData {
 func GetPredicateSimplificationSuiteData() testdata.TestData {
 	return testDataMap["predicate_simplification"]
 }
+
+func GetOuterToSemiJoinSuiteData() testdata.TestData {
+	return testDataMap["outer_to_semi_join_suite"]
+}

pkg/planner/core/casetest/rule/rule_outer_to_semi_join_test.go

@@ -0,0 +1,60 @@
+// Copyright 2025 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package rule
+
+import (
+	"testing"
+
+	"github.com/pingcap/tidb/pkg/testkit"
+	"github.com/pingcap/tidb/pkg/testkit/testdata"
+)
+
+func TestOuterToSemiJoin(tt *testing.T) {
+	testkit.RunTestUnderCascades(tt, func(t *testing.T, tk *testkit.TestKit, cascades, caller string) {
+		tk.MustExec("use test")
+		tk.MustExec("drop table if exists A, B")
+		// A.id is not a primary key to allow NULL values for the test.
+		tk.MustExec("CREATE TABLE A (id INT, val INT, nullable_val INT)")
+		tk.MustExec("CREATE TABLE B (id INT PRIMARY KEY, a_id INT, val INT, non_null_col INT NOT NULL, nullable_col INT)")
+
+		// Insert data into A
+		// A.val=10, 20, NULL, 40
+		tk.MustExec("INSERT INTO A VALUES (1, 10, 100), (2, 20, NULL), (3, NULL, 300), (4, 40, 400), (NULL, 50, 500)")
+
+		// Insert data into B
+		// B.val=10 matches A.val=10.
+		// B.val=NULL matches A.val=NULL via <=>.
+		// B.val=500 and 600 have no match in A.val.
+		tk.MustExec("INSERT INTO B VALUES (101, 1, 10, 1, 1), (102, 2, NULL, 2, NULL), (103, 5, 500, 5, 5), (104, NULL, 600, 6, 6)")
+
+		var input []string
+		var output []struct {
+			SQL    string
+			Plan   []string
+			Result []string
+		}
+		suite := GetOuterToSemiJoinSuiteData()
+		suite.LoadTestCases(t, &input, &output, cascades, caller)
+		for i, sql := range input {
+			testdata.OnRecord(func() {
+				output[i].SQL = sql
+				output[i].Plan = testdata.ConvertRowsToStrings(tk.MustQuery("EXPLAIN FORMAT='plan_tree' " + sql).Rows())
+				output[i].Result = testdata.ConvertRowsToStrings(tk.MustQuery(sql).Rows())
+			})
+			tk.MustQuery("EXPLAIN FORMAT='plan_tree' " + sql).Check(testkit.Rows(output[i].Plan...))
+			tk.MustQuery(sql).Check(testkit.Rows(output[i].Result...))
+		}
+	})
+}

pkg/planner/core/casetest/rule/testdata/outer_to_semi_join_suite_in.json

@@ -0,0 +1,65 @@
+[
+  {
+    "name": "TestOuterToSemiJoin",
+    "cases": [
+      // GROUP 1: LEFT JOIN to SEMI JOIN (Positive cases, equi-join on id)
+      "select A.* from A left join B on A.id = B.a_id where B.val > 0",
+      "select A.* from A left join B on A.id = B.a_id is null where B.val > 0",
+      "select A.* from A left join B on A.id <=> B.a_id where B.val > 0",
+      "select A.* from A left join B on A.id = B.a_id and B.val > 100 where B.id is not null",
+
+      // GROUP 2: LEFT JOIN to ANTI SEMI JOIN (Positive cases, equi-join on id)
+      "select A.* from A left join B on A.id = B.a_id where B.id IS NULL order by A.id",
+      "select A.* from A left join B on A.id = B.a_id where B.non_null_col IS NULL",
+      "select A.* from A left join B on A.id = B.a_id is null where B.non_null_col IS NULL",
+      "select A.* from A left join B on A.id <=> B.a_id where B.id IS NULL",
+      "select A.* from A left join B on A.id = B.a_id where B.id is null and A.val > 30 order by A.id",
+
+      // GROUP 3: LEFT JOIN (Negative cases, should NOT be converted, equi-join on id)
+      "select A.* from A left join B on A.id = B.a_id where B.nullable_col IS NULL",
+      "select A.* from A left join B on A.id = B.a_id where B.id IS NULL OR B.val > 100",
+      "select A.* from A left join B on A.id = B.a_id and B.val > 500 where B.id is null",
+
+      // GROUP 4: RIGHT JOIN to SEMI/ANTI SEMI JOIN (Positive cases, equi-join)
+      "select B.* from A right join B on A.id = B.a_id where A.val > 10",
+      "select B.* from A right join B on A.id = B.a_id where A.id IS NULL",
+      "select B.* from A right join B on A.id = B.a_id is null where A.id IS NULL",
+      "select B.* from A right join B on A.id <=> B.a_id where A.id IS NULL",
+      "select B.* from A right join B on A.id = B.a_id where A.id is null and B.val > 100 order by B.id",
+      "select B.* from A right join B on A.val <=> B.val where A.id IS NULL",
+      "select B.* from A right join B on A.val <=> B.val where A.id IS NOT NULL",
+      "select B.* from A right join B on A.id = B.a_id and B.val > 100 where A.id is null",
+
+      // GROUP 5: RIGHT JOIN (Negative cases, should NOT be converted, equi-join)
+      "select B.* from A right join B on A.id = B.a_id where A.nullable_val IS NULL",
+      "select B.* from A right join B on A.id = B.a_id where A.id IS NULL OR A.val > 20",
+
+      // GROUP 6: Non-Equi JOINs
+      // Sub-group: Positive cases (should be converted to Anti Semi Join)
+      "select A.* from A left join B on A.id < B.a_id where B.id is null",
+      "select A.* from A left join B on A.id > B.a_id where B.non_null_col is null",
+      "select B.* from A right join B on A.id > B.a_id where A.id is null",
+      // Sub-group: Negative cases (should NOT be converted)
+      "select A.* from A left join B on A.id > B.a_id where B.val > 0",
+      "select A.* from A left join B on A.id > B.a_id where B.nullable_col is null",
+
+      // GROUP 7: JOIN on nullable & non-unique columns (A.val = B.val)
+      "select A.* from A left join B on A.val = B.val where B.id IS NULL",
+      "select A.* from A left join B on A.val = B.val where B.non_null_col IS NULL",
+      "select A.* from A left join B on A.val = B.val where B.nullable_col IS NULL",
+      "select A.* from A left join B on A.val <=> B.val where B.id IS NULL",
+      "select A.* from A left join B on A.val <=> B.val where B.non_null_col > 0",
+
+      // GROUP 8: Projecting columns from both tables (Negative cases for Semi Join conversion)
+      // These conversions should NOT happen because Semi/Anti-Semi Join cannot project columns from the inner table.
+      "select A.*, B.val from A left join B on A.id = B.a_id where B.val > 10",
+      "select A.id, B.val from A left join B on A.id <=> B.a_id where B.val > 0",
+      "select A.id, B.non_null_col from A left join B on A.id = B.a_id where B.non_null_col IS NULL",
+      "select B.id, A.val from A right join B on A.id = B.a_id where A.val > 10",
+      "select B.val, A.id from A right join B on A.val <=> B.val where A.id IS NULL",
+      "select A.id, B.id from A left join B on A.id < B.a_id where B.id is null",
+      "select A.val, B.val from A left join B on A.val = B.val where B.non_null_col IS NULL",
+      "select A.id, B.val from A left join B on A.id = B.a_id where B.val > 0"
+    ]
+  }
+]