cherry pick #16261 to release-3.0

Signed-off-by: sre-bot <[email protected]>

expression/expression.go

@@ -83,6 +83,7 @@ type Expression interface {
 	// ConstItem checks if this expression is constant item, regardless of query evaluation state.
 	// An expression is constant item if it:
 	// refers no tables.
+	// refers no correlated column.
 	// refers no subqueries that refers any tables.
 	// refers no non-deterministic functions.
 	// refers no statement parameters.

expression/function_traits.go

@@ -94,7 +94,8 @@ var IllegalFunctions4GeneratedColumns = map[string]struct{}{
 	ast.Version:          {},
 }
 
-// DeferredFunctions stores non-deterministic functions, which can be deferred only when the plan cache is enabled.
+// DeferredFunctions stores functions which are foldable but should be deferred as well when plan cache is enabled.
+// Note that, these functions must be foldable at first place, i.e, they are not in `unFoldableFunctions`.
 var DeferredFunctions = map[string]struct{}{
 	ast.Now:              {},
 	ast.CurrentTimestamp: {},
@@ -103,12 +104,9 @@ var DeferredFunctions = map[string]struct{}{
 	ast.CurrentTime:      {},
 	ast.UTCTimestamp:     {},
 	ast.UnixTimestamp:    {},
-	ast.Sysdate:          {},
 	ast.Curdate:          {},
 	ast.CurrentDate:      {},
 	ast.UTCDate:          {},
-	ast.Rand:             {},
-	ast.UUID:             {},
 }
 
 // inequalFunctions stores functions which cannot be propagated from column equal condition.

expression/util.go

@@ -689,6 +689,27 @@ func BuildNotNullExpr(ctx sessionctx.Context, expr Expression) Expression {
 	return notNull
 }
 
+// IsRuntimeConstExpr checks if a expr can be treated as a constant in **executor**.
+func IsRuntimeConstExpr(expr Expression) bool {
+	switch x := expr.(type) {
+	case *ScalarFunction:
+		if _, ok := unFoldableFunctions[x.FuncName.L]; ok {
+			return false
+		}
+		for _, arg := range x.GetArgs() {
+			if !IsRuntimeConstExpr(arg) {
+				return false
+			}
+		}
+		return true
+	case *Column:
+		return false
+	case *Constant, *CorrelatedColumn:
+		return true
+	}
+	return false
+}
+
 // isMutableEffectsExpr checks if expr contains function which is mutable or has side effects.
 func isMutableEffectsExpr(expr Expression) bool {
 	switch x := expr.(type) {

planner/core/rule_column_pruning.go

@@ -160,7 +160,7 @@ func (ls *LogicalSort) PruneColumns(parentUsedCols []*expression.Column) error {
 	for i := len(ls.ByItems) - 1; i >= 0; i-- {
 		cols := expression.ExtractColumns(ls.ByItems[i].Expr)
 		if len(cols) == 0 {
-			if !ls.ByItems[i].Expr.ConstItem() {
+			if !expression.IsRuntimeConstExpr(ls.ByItems[i].Expr) {
 				continue
 			}
 			ls.ByItems = append(ls.ByItems[:i], ls.ByItems[i+1:]...)