fix: align explicit CAST overflow behavior with MySQL (#25898)

Explicit SQL `CAST` and `CONVERT` expressions previously reused the ordinary internal cast overload, whose strict overflow errors differ from MySQL's explicit-cast behavior.

This change:

- routes only MySQL `SIGNED`, `UNSIGNED`, and `DECIMAL` cast targets through a dedicated overload, keeping MatrixOne extension integer targets and planner-inserted casts unchanged;
- applies MySQL-compatible signed/unsigned overflow handling across string, integer, float, Decimal64, Decimal128, and Decimal256 sources;
- clamps explicit decimal casts across Decimal64, Decimal128, and Decimal256 target precisions;
- preserves errors for invalid numeric strings;
- adds planner/function unit tests, column-vector coverage, extension-target regression tests, and BVT coverage for the reported cases and boundaries.

User impact: overflow cases such as large integer strings, negative-to-unsigned casts, and oversized decimals now produce MySQL-compatible values without changing existing strict semantics for implicit casts or MatrixOne extension integer targets.

Validation:

- `go test ./pkg/sql/plan/function ./pkg/sql/plan`
- `go test -race ./pkg/sql/plan/function ./pkg/sql/plan`
- `go vet ./pkg/sql/plan/function ./pkg/sql/plan`
- `make build`
- `func_cast.test` BVT: 226/226 passed
- `boundary_comprehensive.sql` BVT: 241/241 passed
- changed helper coverage: 75.0%-100%
- `git diff --check`

Approved by: @XuPeng-SH, @heni02

Author: ck89119

pkg/sql/plan/base_binder.go

@@ -155,7 +155,11 @@ func (b *baseBinder) baseBindExpr(astExpr tree.Expr, depth int32, isRoot bool) (
 		if err != nil {
 			return
 		}
-		expr, err = appendCastBeforeExpr(b.GetContext(), expr, typ)
+		if useExplicitCastOverload(exprImpl.Type) {
+			expr, err = appendExplicitCastBeforeExpr(b.GetContext(), expr, typ)
+		} else {
+			expr, err = appendCastBeforeExpr(b.GetContext(), expr, typ)
+		}
 
 	case *tree.BitCastExpr:
 		expr, err = b.bindFuncExprImplByAstExpr("bit_cast", []tree.Expr{astExpr}, depth)
@@ -281,6 +285,24 @@ func (b *baseBinder) baseBindExpr(astExpr tree.Expr, depth int32, isRoot bool) (
 	return
 }
 
+func useExplicitCastOverload(typ tree.ResolvableTypeReference) bool {
+	t, ok := typ.(*tree.T)
+	if !ok {
+		return false
+	}
+	internal := t.InternalType
+	switch defines.MysqlType(internal.Oid) {
+	case defines.MYSQL_TYPE_DECIMAL, defines.MYSQL_TYPE_NEWDECIMAL:
+		return true
+	case defines.MYSQL_TYPE_LONGLONG:
+		family := strings.ToLower(internal.FamilyString)
+		return family == "signed" || family == "integer" ||
+			(internal.Unsigned && (family == "" || family == "unsigned"))
+	default:
+		return false
+	}
+}
+
 func unwrapParenExpr(astExpr tree.Expr) tree.Expr {
 	for {
 		paren, ok := astExpr.(*tree.ParenExpr)
@@ -3000,12 +3022,22 @@ func (b *baseBinder) GetContext() context.Context { return b.sysCtx }
 // --- util functions ----
 
 func appendCastBeforeExpr(ctx context.Context, expr *Expr, toType Type, isBin ...bool) (*Expr, error) {
+	return appendCastBeforeExprWithOverload(ctx, expr, toType, 0, isBin...)
+}
+
+func appendExplicitCastBeforeExpr(ctx context.Context, expr *Expr, toType Type) (*Expr, error) {
+	return appendCastBeforeExprWithOverload(ctx, expr, toType, 1)
+}
+
+func appendCastBeforeExprWithOverload(
+	ctx context.Context, expr *Expr, toType Type, overloadID int32, isBin ...bool,
+) (*Expr, error) {
 	toType.NotNullable = expr.Typ.NotNullable
 	argsType := []types.Type{
 		makeTypeByPlan2Expr(expr),
 		makeTypeByPlan2Type(toType),
 	}
-	fGet, err := function.GetFunctionByName(ctx, "cast", argsType)
+	fGet, err := function.GetFunctionByNameWithOverload(ctx, "cast", argsType, overloadID)
 	if err != nil {
 		return nil, err
 	}

pkg/sql/plan/explicit_cast_test.go

@@ -0,0 +1,70 @@
+// Copyright 2026 Matrix Origin
+//
+// 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 plan
+
+import (
+	"context"
+	"testing"
+
+	"github.com/matrixorigin/matrixone/pkg/container/types"
+	"github.com/matrixorigin/matrixone/pkg/defines"
+	"github.com/matrixorigin/matrixone/pkg/sql/parsers/tree"
+	"github.com/matrixorigin/matrixone/pkg/sql/plan/function"
+	"github.com/stretchr/testify/require"
+)
+
+func TestExplicitCastUsesDedicatedOverload(t *testing.T) {
+	ctx := context.Background()
+	source := makePlan2StringConstExprWithType("1")
+	targetType := types.T_int64.ToType()
+	target := makePlan2TypeValue(&targetType)
+
+	ordinary, err := appendCastBeforeExpr(ctx, DeepCopyExpr(source), target)
+	require.NoError(t, err)
+	explicit, err := appendExplicitCastBeforeExpr(ctx, DeepCopyExpr(source), target)
+	require.NoError(t, err)
+
+	ordinaryFunction := ordinary.GetF().GetFunc()
+	explicitFunction := explicit.GetF().GetFunc()
+	require.Equal(t, "cast", ordinaryFunction.GetObjName())
+	require.Equal(t, "cast", explicitFunction.GetObjName())
+	_, ordinaryOverload := function.DecodeOverloadID(ordinaryFunction.GetObj())
+	_, explicitOverload := function.DecodeOverloadID(explicitFunction.GetObj())
+	require.Equal(t, int32(0), ordinaryOverload)
+	require.Equal(t, int32(1), explicitOverload)
+}
+
+func TestUseExplicitCastOverload(t *testing.T) {
+	tests := []struct {
+		name string
+		typ  tree.InternalType
+		want bool
+	}{
+		{name: "signed", typ: tree.InternalType{Oid: uint32(defines.MYSQL_TYPE_LONGLONG), FamilyString: "signed"}, want: true},
+		{name: "signed integer", typ: tree.InternalType{Oid: uint32(defines.MYSQL_TYPE_LONGLONG), FamilyString: "integer"}, want: true},
+		{name: "unsigned", typ: tree.InternalType{Oid: uint32(defines.MYSQL_TYPE_LONGLONG), Unsigned: true}, want: true},
+		{name: "decimal", typ: tree.InternalType{Oid: uint32(defines.MYSQL_TYPE_NEWDECIMAL), FamilyString: "decimal"}, want: true},
+		{name: "tinyint", typ: tree.InternalType{Oid: uint32(defines.MYSQL_TYPE_TINY), FamilyString: "tinyint"}},
+		{name: "smallint", typ: tree.InternalType{Oid: uint32(defines.MYSQL_TYPE_SHORT), FamilyString: "smallint"}},
+		{name: "int", typ: tree.InternalType{Oid: uint32(defines.MYSQL_TYPE_LONG), FamilyString: "int"}},
+		{name: "bigint", typ: tree.InternalType{Oid: uint32(defines.MYSQL_TYPE_LONGLONG), FamilyString: "bigint"}},
+		{name: "bigint unsigned", typ: tree.InternalType{Oid: uint32(defines.MYSQL_TYPE_LONGLONG), FamilyString: "bigint", Unsigned: true}},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			require.Equal(t, test.want, useExplicitCastOverload(&tree.T{InternalType: test.typ}))
+		})
+	}
+}