planner: fix select lock don't have Hash64 and Equals methods itself in next-gen mode. (pingcap#63227)

close pingcap#63229

Author: AilinKid

pkg/parser/ast/BUILD.bazel

@@ -28,6 +28,7 @@ go_library(
         "//pkg/parser/terror",
         "//pkg/parser/tidb",
         "//pkg/parser/types",
+        "//pkg/parser/util",
         "@com_github_pingcap_errors//:errors",
         "@com_github_pingcap_failpoint//:failpoint",
     ],

pkg/parser/ast/dml.go

@@ -14,12 +14,14 @@
 package ast
 
 import (
+	"reflect"
 	"strings"
 
 	"github.com/pingcap/errors"
 	"github.com/pingcap/tidb/pkg/parser/auth"
 	"github.com/pingcap/tidb/pkg/parser/format"
 	"github.com/pingcap/tidb/pkg/parser/mysql"
+	"github.com/pingcap/tidb/pkg/parser/util"
 )
 
 var (
@@ -632,6 +634,45 @@ type SelectLockInfo struct {
 	Tables   []*TableName
 }
 
+// Hash64 implements the cascades/base.Hasher.<0th> interface.
+func (n *SelectLockInfo) Hash64(h util.IHasher) {
+	h.HashInt(int(n.LockType))
+	h.HashUint64(n.WaitSec)
+	h.HashInt(len(n.Tables))
+	for _, one := range n.Tables {
+		// to make it simple, we just use lockInfo's addr.
+		h.HashUint64(uint64(reflect.ValueOf(one).Pointer()))
+	}
+}
+
+// Equals implements the cascades/base.Hasher.<1th> interface.
+func (n *SelectLockInfo) Equals(other any) bool {
+	n2, ok := other.(*SelectLockInfo)
+	if !ok {
+		return false
+	}
+	if n == nil {
+		return n2 == nil
+	}
+	if other == nil {
+		return false
+	}
+	ok = n.LockType == n2.LockType &&
+		n.WaitSec == n2.WaitSec
+	if !ok {
+		return false
+	}
+	if len(n.Tables) != len(n2.Tables) {
+		return false
+	}
+	for i, one := range n.Tables {
+		if one != n2.Tables[i] {
+			return false
+		}
+	}
+	return true
+}
+
 // String implements fmt.Stringer.
 func (n SelectLockType) String() string {
 	switch n {

pkg/parser/ast/model.go

@@ -19,7 +19,7 @@ import (
 	"unsafe"
 
 	"github.com/pingcap/errors"
-	"github.com/pingcap/tidb/pkg/parser/types"
+	"github.com/pingcap/tidb/pkg/parser/util"
 )
 
 // TableLockType is the type of the table lock.
@@ -272,7 +272,7 @@ type CIStr struct {
 }
 
 // Hash64 implements HashEquals interface.
-func (cis *CIStr) Hash64(h types.IHasher) {
+func (cis *CIStr) Hash64(h util.IHasher) {
 	h.HashString(cis.L)
 }
 

pkg/parser/types/BUILD.bazel

@@ -14,6 +14,7 @@ go_library(
         "//pkg/parser/format",
         "//pkg/parser/mysql",
         "//pkg/parser/terror",
+        "//pkg/parser/util",
     ],
 )
 

pkg/parser/types/field_type.go

@@ -24,6 +24,7 @@ import (
 	"github.com/pingcap/tidb/pkg/parser/charset"
 	"github.com/pingcap/tidb/pkg/parser/format"
 	"github.com/pingcap/tidb/pkg/parser/mysql"
+	"github.com/pingcap/tidb/pkg/parser/util"
 )
 
 // UnspecifiedLength is unspecified length.
@@ -39,21 +40,6 @@ var (
 	TiDBStrictIntegerDisplayWidth bool
 )
 
-// IHasher is internal usage represent cascades/base.Hasher
-type IHasher interface {
-	HashBool(val bool)
-	HashInt(val int)
-	HashInt64(val int64)
-	HashUint64(val uint64)
-	HashFloat64(val float64)
-	HashRune(val rune)
-	HashString(val string)
-	HashByte(val byte)
-	HashBytes(val []byte)
-	Reset()
-	Sum64() uint64
-}
-
 // FieldType records field type information.
 type FieldType struct {
 	// tp is type of the field
@@ -101,7 +87,7 @@ func (ft *FieldType) DeepCopy() *FieldType {
 }
 
 // Hash64 implements the cascades/base.Hasher.<0th> interface.
-func (ft *FieldType) Hash64(h IHasher) {
+func (ft *FieldType) Hash64(h util.IHasher) {
 	h.HashByte(ft.tp)
 	h.HashUint64(uint64(ft.flag))
 	h.HashInt(ft.flen)

pkg/parser/util/BUILD.bazel

@@ -0,0 +1,8 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "util",
+    srcs = ["hash64.go"],
+    importpath = "github.com/pingcap/tidb/pkg/parser/util",
+    visibility = ["//visibility:public"],
+)

pkg/parser/util/hash64.go

@@ -0,0 +1,33 @@
+// Copyright 2025 The ql Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSES/QL-LICENSE file.
+
+// Copyright 2015 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,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package util
+
+// IHasher is internal usage represent cascades/base.Hasher
+type IHasher interface {
+	HashBool(val bool)
+	HashInt(val int)
+	HashInt64(val int64)
+	HashUint64(val uint64)
+	HashFloat64(val float64)
+	HashRune(val rune)
+	HashString(val string)
+	HashByte(val byte)
+	HashBytes(val []byte)
+	Reset()
+	Sum64() uint64
+}

pkg/planner/core/generator/hash64_equals/BUILD.bazel

@@ -6,7 +6,7 @@ go_library(
     importpath = "github.com/pingcap/tidb/pkg/planner/core/generator/hash64_equals",
     visibility = ["//visibility:private"],
     deps = [
-        "//pkg/parser/types",
+        "//pkg/parser/util",
         "//pkg/planner/cascades/base",
         "//pkg/planner/core/operator/logicalop",
     ],

pkg/planner/core/generator/hash64_equals/hash64_equals_generator.go

@@ -23,7 +23,7 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/pingcap/tidb/pkg/parser/types"
+	"github.com/pingcap/tidb/pkg/parser/util"
 	"github.com/pingcap/tidb/pkg/planner/cascades/base"
 	"github.com/pingcap/tidb/pkg/planner/core/operator/logicalop"
 )
@@ -40,7 +40,8 @@ func GenHash64Equals4LogicalOps() ([]byte, error) {
 		logicalop.LogicalExpand{}, logicalop.LogicalLimit{}, logicalop.LogicalMaxOneRow{}, logicalop.DataSource{},
 		logicalop.LogicalMemTable{}, logicalop.LogicalUnionAll{}, logicalop.LogicalPartitionUnionAll{}, logicalop.LogicalProjection{},
 		logicalop.LogicalSelection{}, logicalop.LogicalSequence{}, logicalop.LogicalShow{}, logicalop.LogicalShowDDLJobs{},
-		logicalop.LogicalSort{}, logicalop.LogicalTableDual{}, logicalop.LogicalTopN{}, logicalop.LogicalUnionScan{}, logicalop.LogicalWindow{},
+		logicalop.LogicalSort{}, logicalop.LogicalTableDual{}, logicalop.LogicalTopN{}, logicalop.LogicalUnionScan{},
+		logicalop.LogicalWindow{}, logicalop.LogicalLock{},
 	}
 	c := new(cc)
 	c.write(codeGenHash64EqualsPrefix)
@@ -56,7 +57,7 @@ func GenHash64Equals4LogicalOps() ([]byte, error) {
 
 // IHashEquals is the interface for hash64 and equals inside parser pkg.
 type IHashEquals interface {
-	Hash64(h types.IHasher)
+	Hash64(h util.IHasher)
 	Equals(other any) bool
 }
 
@@ -155,6 +156,8 @@ func logicalOpName2PlanCodecString(name string) string {
 		return "plancodec.TypeUnionScan"
 	case "LogicalWindow":
 		return "plancodec.TypeWindow"
+	case "LogicalLock":
+		return "plancodec.TypeLock"
 	default:
 		return ""
 	}

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

@@ -69,9 +69,9 @@ type BaseLogicalPlan struct {
 
 // Hash64 implements HashEquals.<0th> interface.
 func (p *BaseLogicalPlan) Hash64(h base2.Hasher) {
-	_, ok1 := p.self.(*LogicalSequence)
-	_, ok2 := p.self.(*LogicalMaxOneRow)
-	if !ok1 && !ok2 {
+	switch p.self.(type) {
+	case *LogicalSequence, *LogicalMaxOneRow, *LogicalLock:
+	default:
 		intest.Assert(false, "Hash64 should not be called directly")
 	}
 	h.HashInt(p.ID())