planner: remove some empty file after logical ops are all classified.

pkg/planner/core/BUILD.bazel

@@ -17,15 +17,13 @@ go_library(
         "flat_plan.go",
         "foreign_key.go",
         "fragment.go",
-        "hashcode.go",
         "hint_utils.go",
         "index_join_path.go",
         "indexmerge_path.go",
         "indexmerge_unfinished_path.go",
         "initialize.go",
         "logical_initialize.go",
         "logical_plan_builder.go",
-        "logical_plans.go",
         "memtable_infoschema_extractor.go",
         "memtable_predicate_extractor.go",
         "mock.go",

pkg/planner/core/core_init.go

@@ -30,7 +30,6 @@ func init() {
 	utilfuncp.AddSelection = addSelection
 	utilfuncp.FindBestTask = findBestTask
 	utilfuncp.PruneByItems = pruneByItems
-	utilfuncp.HasMaxOneRowUtil = HasMaxOneRow
 	utilfuncp.GetTaskPlanCost = getTaskPlanCost
 	utilfuncp.CanPushToCopImpl = canPushToCopImpl
 	utilfuncp.PushDownTopNForBaseLogicalPlan = pushDownTopNForBaseLogicalPlan

pkg/planner/core/operator/logicalop/BUILD.bazel

@@ -17,6 +17,7 @@ go_library(
         "logical_max_one_row.go",
         "logical_mem_table.go",
         "logical_partition_union_all.go",
+        "logical_plans_misc.go",
         "logical_projection.go",
         "logical_schema_producer.go",
         "logical_selection.go",

pkg/planner/core/operator/logicalop/base_logical_plan.go

@@ -151,7 +151,7 @@ func (p *BaseLogicalPlan) BuildKeyInfo(_ *expression.Schema, _ []*expression.Sch
 	for i := range p.children {
 		childMaxOneRow[i] = p.children[i].MaxOneRow()
 	}
-	p.maxOneRow = utilfuncp.HasMaxOneRowUtil(p.self, childMaxOneRow)
+	p.maxOneRow = HasMaxOneRow(p.self, childMaxOneRow)
 }
 
 // PushDownTopN implements the LogicalPlan.<5th> interface.

pkg/planner/core/operator/logicalop/logical_plans_misc.go

@@ -0,0 +1,72 @@
+// Copyright 2024 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 logicalop
+
+import (
+	"github.com/pingcap/tidb/pkg/planner/core/base"
+)
+
+var (
+	_ base.LogicalPlan = &LogicalJoin{}
+	_ base.LogicalPlan = &LogicalAggregation{}
+	_ base.LogicalPlan = &LogicalProjection{}
+	_ base.LogicalPlan = &LogicalSelection{}
+	_ base.LogicalPlan = &LogicalApply{}
+	_ base.LogicalPlan = &LogicalMaxOneRow{}
+	_ base.LogicalPlan = &LogicalTableDual{}
+	_ base.LogicalPlan = &DataSource{}
+	_ base.LogicalPlan = &TiKVSingleGather{}
+	_ base.LogicalPlan = &LogicalTableScan{}
+	_ base.LogicalPlan = &LogicalIndexScan{}
+	_ base.LogicalPlan = &LogicalUnionAll{}
+	_ base.LogicalPlan = &LogicalPartitionUnionAll{}
+	_ base.LogicalPlan = &LogicalSort{}
+	_ base.LogicalPlan = &LogicalLock{}
+	_ base.LogicalPlan = &LogicalLimit{}
+	_ base.LogicalPlan = &LogicalWindow{}
+	_ base.LogicalPlan = &LogicalExpand{}
+	_ base.LogicalPlan = &LogicalUnionScan{}
+	_ base.LogicalPlan = &LogicalMemTable{}
+	_ base.LogicalPlan = &LogicalShow{}
+	_ base.LogicalPlan = &LogicalShowDDLJobs{}
+	_ base.LogicalPlan = &LogicalCTE{}
+	_ base.LogicalPlan = &LogicalCTETable{}
+	_ base.LogicalPlan = &LogicalSequence{}
+)
+
+// HasMaxOneRow returns if the LogicalPlan will output at most one row.
+func HasMaxOneRow(p base.LogicalPlan, childMaxOneRow []bool) bool {
+	if len(childMaxOneRow) == 0 {
+		// The reason why we use this check is that, this function
+		// is used both in planner/core and planner/cascades.
+		// In cascades planner, LogicalPlan may have no `children`.
+		return false
+	}
+	switch x := p.(type) {
+	case *LogicalLock, *LogicalLimit, *LogicalSort, *LogicalSelection,
+		*LogicalApply, *LogicalProjection, *LogicalWindow, *LogicalAggregation:
+		return childMaxOneRow[0]
+	case *LogicalMaxOneRow:
+		return true
+	case *LogicalJoin:
+		switch x.JoinType {
+		case SemiJoin, AntiSemiJoin, LeftOuterSemiJoin, AntiLeftOuterSemiJoin:
+			return childMaxOneRow[0]
+		default:
+			return childMaxOneRow[0] && childMaxOneRow[1]
+		}
+	}
+	return false
+}

pkg/planner/core/plan.go

@@ -21,7 +21,6 @@ import (
 	"github.com/pingcap/tidb/pkg/expression"
 	"github.com/pingcap/tidb/pkg/planner/cardinality"
 	"github.com/pingcap/tidb/pkg/planner/core/base"
-	"github.com/pingcap/tidb/pkg/planner/core/operator/logicalop"
 	"github.com/pingcap/tidb/pkg/planner/property"
 	"github.com/pingcap/tidb/pkg/planner/util"
 	"github.com/pingcap/tidb/pkg/sessionctx"
@@ -241,28 +240,3 @@ func getActualProbeCntFromProbeParents(pps []base.PhysicalPlan, statsColl *execd
 	}
 	return res
 }
-
-// HasMaxOneRow returns if the LogicalPlan will output at most one row.
-func HasMaxOneRow(p base.LogicalPlan, childMaxOneRow []bool) bool {
-	if len(childMaxOneRow) == 0 {
-		// The reason why we use this check is that, this function
-		// is used both in planner/core and planner/cascades.
-		// In cascades planner, LogicalPlan may have no `children`.
-		return false
-	}
-	switch x := p.(type) {
-	case *logicalop.LogicalLock, *logicalop.LogicalLimit, *logicalop.LogicalSort, *logicalop.LogicalSelection,
-		*logicalop.LogicalApply, *logicalop.LogicalProjection, *logicalop.LogicalWindow, *logicalop.LogicalAggregation:
-		return childMaxOneRow[0]
-	case *logicalop.LogicalMaxOneRow:
-		return true
-	case *logicalop.LogicalJoin:
-		switch x.JoinType {
-		case logicalop.SemiJoin, logicalop.AntiSemiJoin, logicalop.LeftOuterSemiJoin, logicalop.AntiLeftOuterSemiJoin:
-			return childMaxOneRow[0]
-		default:
-			return childMaxOneRow[0] && childMaxOneRow[1]
-		}
-	}
-	return false
-}

pkg/planner/memo/BUILD.bazel

@@ -14,9 +14,9 @@ go_library(
         "//pkg/expression",
         "//pkg/planner/core",
         "//pkg/planner/core/base",
+        "//pkg/planner/core/operator/logicalop",
         "//pkg/planner/pattern",
         "//pkg/planner/property",
-        "//pkg/planner/util/utilfuncp",
     ],
 )
 

pkg/planner/memo/group.go

@@ -22,9 +22,9 @@ import (
 	// import core pkg first to call its init func.
 	_ "github.com/pingcap/tidb/pkg/planner/core"
 	"github.com/pingcap/tidb/pkg/planner/core/base"
+	"github.com/pingcap/tidb/pkg/planner/core/operator/logicalop"
 	"github.com/pingcap/tidb/pkg/planner/pattern"
 	"github.com/pingcap/tidb/pkg/planner/property"
-	"github.com/pingcap/tidb/pkg/planner/util/utilfuncp"
 )
 
 // ExploreMark is uses to mark whether a Group or GroupExpr has
@@ -223,5 +223,5 @@ func (g *Group) BuildKeyInfo() {
 		g.Prop.Schema.Keys = childSchema[0].Keys
 	}
 	e.ExprNode.BuildKeyInfo(g.Prop.Schema, childSchema)
-	g.Prop.MaxOneRow = e.ExprNode.MaxOneRow() || utilfuncp.HasMaxOneRowUtil(e.ExprNode, childMaxOneRow)
+	g.Prop.MaxOneRow = e.ExprNode.MaxOneRow() || logicalop.HasMaxOneRow(e.ExprNode, childMaxOneRow)
 }

pkg/planner/util/utilfuncp/func_pointer_misc.go

@@ -28,12 +28,6 @@ import (
 
 // this file is used for passing function pointer at init(){} to avoid some import cycles.
 
-// HasMaxOneRowUtil is used in baseLogicalPlan implementation of LogicalPlan interface, while
-// the original HasMaxOneRowUtil has some dependency of original core pkg: like Datasource which
-// hasn't been moved out of core pkg, so associative func pointer is introduced.
-// todo: (1) arenatlx, remove this func pointer when concrete Logical Operators moved out of core.
-var HasMaxOneRowUtil func(p base.LogicalPlan, childMaxOneRow []bool) bool
-
 // AppendCandidate4PhysicalOptimizeOp is used in all logicalOp's findBestTask to trace the physical
 // optimizing steps. Since we try to move baseLogicalPlan out of core, then other concrete logical
 // operators, this appendCandidate4PhysicalOptimizeOp will make logicalOp/pkg back import core/pkg;